#![allow(unsafe_code)]
use std::path::{Path, PathBuf};
use kh_runtime::bottle::host_path_to_guest;
use kh_runtime::process as proc_state;
use kh_runtime::{
AddressSpace, GuestPageSize, TrapConfig, TrapError, TrapEvent, bootstrap_stack, call_guest,
call_guest_args, finish_with_exit_code, install_main_guest_tls, install_trap_handlers,
map_stack, patch_svc_to_brk, registry_install, registry_take, set_bottle_root,
};
#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
use kh_runtime::{VM_PROT_EXECUTE, VM_PROT_READ, VM_PROT_WRITE, mprotect_darwin, mprotect_rw};
use crate::error::LoadError;
use crate::init;
use crate::session::LoadSession;
pub const DEFAULT_STACK_SIZE: u64 = 8 * 1024 * 1024;
#[derive(Debug, Clone)]
pub struct RunOptions {
pub root: Option<PathBuf>,
pub guest_page_size: GuestPageSize,
pub guest_args: Vec<String>,
pub max_events: usize,
pub max_syscalls: usize,
pub dry_load: bool,
}
impl Default for RunOptions {
fn default() -> Self {
Self {
root: None,
guest_page_size: GuestPageSize::default(),
guest_args: Vec::new(),
max_events: 256,
max_syscalls: 256,
dry_load: false,
}
}
}
#[derive(Debug)]
pub struct RunResult {
pub exit_code: Option<i32>,
pub events: Vec<TrapEvent>,
pub patched_svc: usize,
pub entry: u64,
pub sp: u64,
pub slide: u64,
pub initializers_run: usize,
}
pub fn run_micro(path: &Path, opts: &RunOptions) -> Result<RunResult, LoadError> {
if opts.dry_load {
return Err(LoadError::NotImplemented(
"run_micro: use LoadSession::dry_load for --dry-load",
));
}
crate::load_timing::begin_run();
crate::load_timing::note(format!("executable={}", path.display()));
set_bottle_root(opts.root.clone());
let guest_exec = host_path_to_guest(path).or_else(|| {
path.to_str().map(str::to_owned)
});
proc_state::set_guest_executable_path(guest_exec.clone());
drop(registry_take());
let mut session = crate::load_timing::time_result("open_session", || {
LoadSession::open_with_guest(path, opts.root.clone(), opts.guest_page_size)
})?;
let _ = session.map_process()?;
let slide = session
.images()
.first()
.map_or(0, crate::session::ProcessImage::slide);
let entry = session
.entry_va()
.ok_or(LoadError::NotImplemented("image has no entry point"))?;
let host = session
.images()
.first()
.and_then(|img| img.memory.as_ref())
.map(kh_runtime::GuestMemory::host)
.ok_or(LoadError::NotImplemented("memory missing"))?;
let mut stack =
crate::load_timing::time_result("map_stack", || map_stack(host, DEFAULT_STACK_SIZE))?;
let argv0 = guest_exec.as_deref().filter(|s| !s.is_empty()).map_or_else(
|| {
path.file_name()
.and_then(|s| s.to_str())
.unwrap_or("guest")
.to_owned()
},
str::to_owned,
);
let mut argv_owned = Vec::with_capacity(opts.guest_args.len().saturating_add(1));
argv_owned.push(argv0);
argv_owned.extend(opts.guest_args.iter().cloned());
let argv_refs: Vec<&str> = argv_owned.iter().map(String::as_str).collect();
let home = guest_home_env();
let mut env_owned = vec![
"PATH=/Library/Developer/CommandLineTools/usr/libexec/git-core:\
/Library/Developer/CommandLineTools/usr/bin:\
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
.to_owned(),
home,
"TMPDIR=/var/folders/xx/kakehashi_default_user_temp000/T/".to_owned(),
];
if let Some(sdk_env) = guest_sdk_env(opts.root.as_deref()) {
env_owned.extend(sdk_env);
}
for (k, v) in std::env::vars() {
let keep = k.starts_with("GIT_")
|| k == "DYLD_LIBRARY_PATH"
|| k == "DYLD_FALLBACK_LIBRARY_PATH"
|| k == "DYLD_FRAMEWORK_PATH";
if !keep || k.contains('\0') || v.contains('\0') {
continue;
}
if k.len().saturating_add(v.len()) > 512 {
continue;
}
env_owned.push(format!("{k}={v}"));
}
let env_refs: Vec<&str> = env_owned.iter().map(String::as_str).collect();
let stack_base = stack.guest_addr;
let sp = crate::load_timing::time_result("bootstrap_stack", || {
bootstrap_stack(stack.host_bytes_mut(), stack_base, &argv_refs, &env_refs)
.map_err(|err| LoadError::NotImplemented(stack_err_static(&err)))
})?;
crate::load_timing::time("registry_install", || {
let mut address_space = AddressSpace::new();
for img in session.images() {
if let Some(memory) = img.memory.as_ref() {
for region in memory.regions() {
address_space.register_borrowed(region);
}
}
}
address_space.register_borrowed(&stack);
drop(registry_install(address_space));
});
warn_if_hypercall_env_opt_out();
let hypercall_wired =
crate::load_timing::time("wire_hypercall", || install_libsystem_hypercall(&mut session));
let mut patched_svc = 0usize;
crate::load_timing::time_result("patch_svc", || {
for memory in session.mapped_memories_mut() {
patched_svc = patched_svc
.saturating_add(patch_svc_to_brk(memory.regions_mut()).map_err(trap_to_load)?);
}
Ok::<(), LoadError>(())
})?;
crate::load_timing::time_result("install_traps", || {
install_trap_handlers(&TrapConfig {
max_events: opts.max_events,
max_syscalls: opts.max_syscalls,
})
.map_err(trap_to_load)
})?;
let main_tls = crate::load_timing::time("main_tls", install_main_guest_tls);
if main_tls != 0 {
tracing::debug!(
main_tls = format_args!("{main_tls:#x}"),
"installed main guest TLS (TPIDR_EL0)"
);
}
let initializers_run =
crate::load_timing::time_result("initializers", || init::run_initializers(&session, sp))?;
tracing::info!(
entry = format_args!("{entry:#x}"),
sp = format_args!("{sp:#x}"),
slide,
patched_svc,
hypercall_wired,
main_tls = format_args!("{main_tls:#x}"),
initializers_run,
images = session.images().len(),
root = ?opts.root,
"jumping to guest entry"
);
let argc = u64::try_from(argv_owned.len()).unwrap_or(0);
let argv_ptr = sp.wrapping_add(8);
let envp_ptr = argv_ptr.wrapping_add(argc.saturating_add(1).saturating_mul(8));
let apple_ptr = envp_ptr.wrapping_add(8);
let heap_dump_va = freestanding_export_va(&session, "_kh_heap_stats_dump")
.or_else(|| freestanding_export_va(&session, "kh_heap_stats_dump"));
let setprogname_va = freestanding_export_va(&session, "_setprogname")
.or_else(|| freestanding_export_va(&session, "setprogname"));
crate::load_timing::time("dyld_table", || register_dyld_images(&session));
crate::load_timing::dump("pre-entry");
if let Some(va) = setprogname_va {
let argv0_cstr = {
let rel = sp.wrapping_sub(stack_base).wrapping_add(8);
let off = usize::try_from(rel).unwrap_or(usize::MAX);
stack
.host_bytes()
.get(off..off.saturating_add(8))
.and_then(|b| <[u8; 8]>::try_from(b).ok())
.map(u64::from_le_bytes)
.filter(|&p| p != 0)
};
if let Some(ptr) = argv0_cstr {
let _ = unsafe { call_guest(va, sp, ptr) };
}
}
std::mem::forget(stack);
std::mem::forget(session);
let guest_t0 = std::time::Instant::now();
let status = unsafe {
call_guest_args(entry, sp, argc, argv_ptr, envp_ptr, apple_ptr)
.map_err(|err| LoadError::PageLayout(err.to_string()))?
};
let guest_ns = u64::try_from(guest_t0.elapsed().as_nanos()).unwrap_or(u64::MAX);
crate::load_timing::record("guest_main_return", guest_ns);
crate::load_timing::dump("post-return");
if let Some(va) = heap_dump_va {
let _ = unsafe { call_guest(va, sp, 0) };
}
let low = u32::try_from(status & 0xffff_ffff).unwrap_or(0);
let code = i32::from_ne_bytes(low.to_ne_bytes());
finish_with_exit_code(code);
}
fn register_dyld_images(session: &LoadSession) {
use crate::session::ImageLoadStatus;
for img in session.images() {
if !matches!(img.status, ImageLoadStatus::Mapped) {
continue;
}
let slide = img.slide();
let exports = img
.exports
.iter()
.map(|e| (e.name.clone(), e.value.wrapping_add(slide)));
kh_runtime::dyld_register_image(
img.path.clone(),
img.install_name.clone(),
exports,
);
}
}
fn freestanding_export_va(session: &LoadSession, name: &str) -> Option<u64> {
let mut any = None;
for img in session.images() {
let path = img.path.to_string_lossy();
let is_libsystem = path.contains("libSystem") || path.contains("libkh_libsystem");
for exp in &img.exports {
if exp.name != name {
continue;
}
let va = exp.value.saturating_add(img.slide());
if is_libsystem {
return Some(va);
}
if any.is_none() {
any = Some(va);
}
}
}
any
}
fn stack_err_static(err: &kh_runtime::StackError) -> &'static str {
match err {
kh_runtime::StackError::TooSmall { .. } => "guest stack too small",
kh_runtime::StackError::InvalidString => "invalid stack string",
}
}
fn guest_home_env() -> String {
match std::env::var("HOME") {
Ok(h) if h.starts_with("/Volumes/linux") && !h.contains('\0') => {
format!("HOME={h}")
}
Ok(h) if h.starts_with('/') && !h.contains('\0') => {
format!("HOME=/Volumes/linux{h}")
}
_ => "HOME=/var/root".to_owned(),
}
}
const GUEST_DEFAULT_SDKROOT: &str = "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk";
const GUEST_DEFAULT_DEVELOPER_DIR: &str = "/Library/Developer/CommandLineTools";
fn guest_sdk_env(bottle: Option<&Path>) -> Option<Vec<String>> {
let bottle = bottle?;
let stdio = bottle
.join("Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/stdio.h");
if !stdio.is_file() {
let sdks = bottle.join("Library/Developer/CommandLineTools/SDKs");
let Ok(entries) = std::fs::read_dir(&sdks) else {
return None;
};
let found = entries.flatten().any(|ent| {
let name = ent.file_name();
let name = name.to_string_lossy();
name.starts_with("MacOSX")
&& name.contains(".sdk")
&& ent.path().join("usr/include/stdio.h").is_file()
});
if !found {
return None;
}
}
Some(vec![
format!("SDKROOT={GUEST_DEFAULT_SDKROOT}"),
format!("DEVELOPER_DIR={GUEST_DEFAULT_DEVELOPER_DIR}"),
])
}
fn trap_to_load(err: TrapError) -> LoadError {
match err {
TrapError::Map(map_err) => LoadError::Map(map_err),
TrapError::UnsupportedArch => LoadError::PageLayout(
"trap backend requires Linux aarch64 for live execution".to_owned(),
),
TrapError::SignalSetup(io_err) => {
LoadError::PageLayout(format!("trap signal setup: {io_err}"))
}
}
}
fn warn_if_hypercall_env_opt_out() {
let Some(v) = std::env::var_os("KAKEHASHI_HYPERCALL") else {
return;
};
let off = v == "0"
|| v.eq_ignore_ascii_case("false")
|| v.eq_ignore_ascii_case("no")
|| v.eq_ignore_ascii_case("off");
if off {
tracing::warn!(
"KAKEHASHI_HYPERCALL={v:?} is ignored; freestanding hypercall is always wired \
(use residual svc→brk only for unpatched fixtures, not as a product path)"
);
}
}
fn install_libsystem_hypercall(session: &mut LoadSession) -> bool {
#[cfg(not(all(target_arch = "aarch64", target_os = "linux")))]
{
let _ = session;
false
}
#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
{
install_libsystem_hypercall_linux(session)
}
}
#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
fn install_libsystem_hypercall_linux(session: &mut LoadSession) -> bool {
let entry_u64 = kh_runtime::hypercall_entry_addr();
if entry_u64 == 0 {
return false;
}
let mut wired_entry = false;
for img in session.images_mut() {
let slide = img.slide();
let exports: Vec<_> = img.exports.clone();
for exp in exports {
let slot = exp.name.as_str();
if slot != "_kh_bsd_hypercall" && slot != "kh_bsd_hypercall" {
continue;
}
let va = exp.value.saturating_add(slide);
if !write_libsystem_u64(img, va, entry_u64) {
continue;
}
wired_entry = true;
tracing::info!(
va = format_args!("{va:#x}"),
entry = format_args!("{entry_u64:#x}"),
"wired libSystem BSD hypercall"
);
}
}
wired_entry
}
#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
fn write_libsystem_u64(img: &mut crate::session::ProcessImage, va: u64, value: u64) -> bool {
let Some(memory) = img.memory.as_mut() else {
return false;
};
let Some(region_idx) = memory.regions().iter().position(|region| {
let start = region.guest_addr;
let end = start.saturating_add(u64::try_from(region.host_len()).unwrap_or(0));
va >= start && va.saturating_add(8) <= end
}) else {
return false;
};
let Some(region) = memory.regions().get(region_idx) else {
return false;
};
let old_prot = region.prot;
let need_rw = old_prot & VM_PROT_WRITE == 0;
if need_rw {
let Some(region) = memory.regions_mut().get_mut(region_idx) else {
return false;
};
if mprotect_rw(region).is_err() {
return false;
}
}
let ok = memory.write_u64_le(va, value).is_some();
if need_rw {
let mut restore = (old_prot | VM_PROT_READ) & !VM_PROT_WRITE;
if old_prot & VM_PROT_EXECUTE != 0 {
restore |= VM_PROT_EXECUTE;
}
if let Some(region) = memory.regions_mut().get_mut(region_idx) {
drop(mprotect_darwin(region, restore));
region.prot = restore;
}
}
ok
}