#![allow(unsafe_code)]
use kh_runtime::{GuestMemory, call_guest};
use crate::error::LoadError;
use crate::image::MachOImage;
use crate::session::{ImageLoadStatus, ImageRole, LoadSession, ProcessImage};
pub const S_MOD_INIT_FUNC_POINTERS: u32 = 0x9;
pub const S_INIT_FUNC_OFFSETS: u32 = 0x16;
pub const SECTION_TYPE: u32 = 0xff;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct InitFunc {
pub va: u64,
pub image_path: String,
}
pub fn collect_mod_init(
image: &MachOImage,
memory: &GuestMemory,
preferred_base: u64,
) -> Result<Vec<u64>, LoadError> {
let slide = memory.slide();
let mut out = Vec::new();
for seg in &image.segments {
for sect in &seg.sections {
let kind = sect.flags & SECTION_TYPE;
if kind == S_MOD_INIT_FUNC_POINTERS {
collect_mod_init_pointers(sect, memory, slide, &mut out)?;
} else if kind == S_INIT_FUNC_OFFSETS {
collect_init_func_offsets(sect, memory, preferred_base, slide, &mut out)?;
}
}
}
Ok(out)
}
fn collect_mod_init_pointers(
sect: &crate::image::SectionInfo,
memory: &GuestMemory,
slide: u64,
out: &mut Vec<u64>,
) -> Result<(), LoadError> {
if sect.size == 0 {
return Ok(());
}
if !sect.size.is_multiple_of(8) {
return Err(LoadError::Resolve(format!(
"mod_init section {}/{} size {:#x} not multiple of 8",
sect.segname, sect.name, sect.size
)));
}
let base = sect.addr.wrapping_add(slide);
let count = usize::try_from(sect.size.saturating_div(8)).unwrap_or(0);
for i in 0..count {
let slot_off = u64::try_from(i).unwrap_or(0).saturating_mul(8);
let slot = base.wrapping_add(slot_off);
let va = memory.read_u64_le(slot).ok_or_else(|| {
LoadError::Resolve(format!(
"mod_init slot unreadable at {slot:#x} ({}/{})",
sect.segname, sect.name
))
})?;
if va == 0 {
continue;
}
out.push(va);
}
Ok(())
}
fn collect_init_func_offsets(
sect: &crate::image::SectionInfo,
memory: &GuestMemory,
preferred_base: u64,
slide: u64,
out: &mut Vec<u64>,
) -> Result<(), LoadError> {
if sect.size == 0 {
return Ok(());
}
if !sect.size.is_multiple_of(4) {
return Err(LoadError::Resolve(format!(
"init_offsets section {}/{} size {:#x} not multiple of 4",
sect.segname, sect.name, sect.size
)));
}
let base = sect.addr.wrapping_add(slide);
let image_load = preferred_base.wrapping_add(slide);
let count = usize::try_from(sect.size.saturating_div(4)).unwrap_or(0);
for i in 0..count {
let slot_off = u64::try_from(i).unwrap_or(0).saturating_mul(4);
let slot = base.wrapping_add(slot_off);
let raw = memory.read_u32_le(slot).ok_or_else(|| {
LoadError::Resolve(format!(
"init_offsets slot unreadable at {slot:#x} ({}/{})",
sect.segname, sect.name
))
})?;
if raw == 0 {
continue;
}
let va = image_load.wrapping_add(u64::from(raw));
out.push(va);
}
Ok(())
}
pub fn plan_initializers(images: &[ProcessImage]) -> Result<Vec<InitFunc>, LoadError> {
let mut plan = Vec::new();
let dylibs: Vec<&ProcessImage> = images
.iter()
.filter(|i| i.role == ImageRole::Dylib && matches!(i.status, ImageLoadStatus::Mapped))
.collect();
for img in dylibs.into_iter().rev() {
push_image_inits(img, &mut plan)?;
}
if let Some(main) = images.first()
&& main.role == ImageRole::Main
&& matches!(main.status, ImageLoadStatus::Mapped)
{
push_image_inits(main, &mut plan)?;
}
Ok(plan)
}
fn push_image_inits(img: &ProcessImage, plan: &mut Vec<InitFunc>) -> Result<(), LoadError> {
let (Some(image), Some(memory)) = (img.image.as_ref(), img.memory.as_ref()) else {
return Ok(());
};
for va in collect_mod_init(image, memory, img.preferred_base())? {
plan.push(InitFunc {
va,
image_path: img.path.display().to_string(),
});
}
Ok(())
}
pub fn run_initializers(session: &LoadSession, guest_sp: u64) -> Result<usize, LoadError> {
let plan = plan_initializers(session.images())?;
let total = plan.len();
tracing::info!(total, "mod_init plan");
let mut ran = 0_usize;
for init in &plan {
tracing::info!(
idx = ran,
total,
va = format_args!("{:#x}", init.va),
image = %init.image_path,
"run mod_init"
);
let _ret = unsafe {
call_guest(init.va, guest_sp, 0)
.map_err(|err| LoadError::PageLayout(err.to_string()))?
};
ran = ran.saturating_add(1);
tracing::debug!(
idx = ran.saturating_sub(1),
va = format_args!("{:#x}", init.va),
"mod_init done"
);
}
Ok(ran)
}