kit

linux.c (7269B)

---

 /* Linux-specific env bits: memfd_create dual-mapped exec memory (+ optional
  * MAP_32BIT runtime-alias hint on x86_64 to keep direct call/jmp
  * displacements in range from text), st_mtim mtime, dlsym pass-through
  * with optional `_` retry, host_target OS=LINUX/OBJ=ELF. */
 
 #include <dlfcn.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 
 #include "env_posix.h"
 
 /* ---------------- dual-mapped exec memory (memfd_create) ----------------
  * memfd_create gives us an anonymous fd; two mmaps of that fd alias the
  * same physical pages at distinct VAs. Both aliases live across the
  * close(fd) below. The runtime-alias hint and any extra mmap flags are
  * arch-specific (x86_64 uses MAP_32BIT to keep direct displacements in
  * range from text); see linux_exec_hint_<arch>.c. */
 KitStatus os_execmem_reserve_exec(size_t size, KitExecMemRegion* out) {
   int fd = (int)syscall(SYS_memfd_create, "kit-jit", 0u);
   int extra = env_execmem_runtime_extra_flags();
   void* w;
   void* r;
   ExecMemToken* tok;
   if (fd < 0) return KIT_ERR;
   if (ftruncate(fd, (off_t)size) != 0) {
     close(fd);
     return KIT_ERR;
   }
 
   w = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED | extra, fd, 0);
   if (w == MAP_FAILED) {
     close(fd);
     return KIT_NOMEM;
   }
   r = mmap(env_execmem_low_runtime_hint(size), size, PROT_READ,
            MAP_SHARED | extra, fd, 0);
   if (r == MAP_FAILED) {
     munmap(w, size);
     close(fd);
     return KIT_NOMEM;
   }
   close(fd);
 
   tok = (ExecMemToken*)malloc(sizeof(*tok));
   if (!tok) {
     munmap(r, size);
     munmap(w, size);
     return KIT_NOMEM;
   }
   tok->write_addr = w;
   tok->runtime_addr = r;
   tok->size = size;
 
   exec_dual_register(w, r, size);
 
   out->write = w;
   out->runtime = r;
   out->size = size;
   out->token = tok;
   return KIT_OK;
 }
 
 /* ---------------- dbg W^X dance ---------------- */
 /* Linux dual-mapping uses memfd: write alias and runtime alias have
  * distinct VAs. Prefer the alias lookup; fall back to a transient
  * mprotect of the runtime alias for single-mapping reservations. */
 
 static size_t page_floor(size_t v, size_t pg) { return v & ~(pg - 1); }
 static size_t page_ceil(size_t v, size_t pg) {
   return (v + pg - 1) & ~(pg - 1);
 }
 
 KitStatus os_dbg_code_write_begin(void* user, void* runtime_addr, size_t n,
                                   void** write_out) {
   size_t pg;
   uintptr_t a;
   uintptr_t base;
   size_t span;
   (void)user;
   if (!runtime_addr || !n || !write_out) return KIT_INVALID;
   if (exec_dual_lookup(runtime_addr, n, write_out) == 0) return KIT_OK;
   pg = driver_host_page_size();
   a = (uintptr_t)runtime_addr;
   base = page_floor(a, pg);
   span = page_ceil((a - base) + n, pg);
   if (mprotect((void*)base, span, PROT_READ | PROT_WRITE | PROT_EXEC) != 0)
     return KIT_ERR;
   *write_out = runtime_addr;
   return KIT_OK;
 }
 
 void os_dbg_code_write_end(void* user, void* runtime_addr, size_t n) {
   void* w;
   size_t pg;
   uintptr_t a;
   uintptr_t base;
   size_t span;
   (void)user;
   if (exec_dual_lookup(runtime_addr, n, &w) == 0)
     return; /* dual: nothing to flip back */
   pg = driver_host_page_size();
   a = (uintptr_t)runtime_addr;
   base = page_floor(a, pg);
   span = page_ceil((a - base) + n, pg);
   mprotect((void*)base, span, PROT_READ | PROT_EXEC);
 }
 
 void os_dbg_flush_icache(void* user, void* runtime_addr, size_t n) {
   (void)user;
   env_flush_icache(runtime_addr, n);
 }
 
 /* ---------------- st_mtim ---------------- */
 
 int os_stat_mtime_ns(const struct stat* sb, int64_t* out) {
   *out =
       (int64_t)sb->st_mtim.tv_sec * 1000000000LL + (int64_t)sb->st_mtim.tv_nsec;
   return 0;
 }
 
 /* ---------------- dlsym ---------------- */
 /* ELF has no underscore mangling; pass through. The retry with a stripped
  * leading underscore matches the old shim's behavior for users that hand
  * us Mach-O-mangled names. */
 void* os_dlsym(const char* name) {
   void* p = dlsym(RTLD_DEFAULT, name);
   if (!p && name[0] == '_' && name[1] != '\0')
     p = dlsym(RTLD_DEFAULT, name + 1);
   return p;
 }
 
 /* ---------------- host_target os/obj ---------------- */
 
 void os_host_target_fill(KitTargetSpec* t) {
   t->os = KIT_OS_LINUX;
   t->obj = KIT_OBJ_ELF;
 }
 
 /* ---------------- self executable path ---------------- */
 /* /proc/self/exe is a kernel-maintained symlink to the running binary; reading
  * it yields the canonical absolute path. readlink does not NUL-terminate and a
  * truncated read is indistinguishable from an exact fit, so grow until the
  * result fits with room for the terminator. */
 int driver_self_exe_path(DriverEnv* env, char** out, size_t* out_size) {
   size_t cap = 256;
   if (!env || !out || !out_size) return 1;
   for (;;) {
     char* buf = (char*)driver_alloc(env, cap);
     ssize_t n;
     if (!buf) return 1;
     n = readlink("/proc/self/exe", buf, cap);
     if (n < 0) {
       driver_free(env, buf, cap);
       return 1;
     }
     if ((size_t)n < cap) {
       buf[n] = '\0';
       *out = buf;
       *out_size = cap;
       return 0;
     }
     driver_free(env, buf, cap);
     if (cap >= (size_t)1 << 20) return 1; /* implausible path length */
     cap *= 2;
   }
 }
 
 /* ---------------- default hosted dirs probe ---------------- */
 /* Linux multiarch triple for the supported 64-bit arches; NULL otherwise. */
 static const char* linux_multiarch_triple(KitArchKind arch) {
   switch (arch) {
     case KIT_ARCH_ARM_64:
       return "aarch64-linux-gnu";
     case KIT_ARCH_X86_64:
       return "x86_64-linux-gnu";
     case KIT_ARCH_RV64:
       return "riscv64-linux-gnu";
     default:
       return NULL;
   }
 }
 
 /* A live Linux root is not sysroot-shaped: glibc keeps crt + libc_nonshared.a
  * in /usr/lib/<triple> and libc.so.6 in /lib/<triple>; musl/Alpine is flat in
  * /usr/lib + /lib. We hand the resolver an ordered library search list that
  * covers both, plus the standard include roots, and let its per-file search
  * bind each crt/libc wherever it actually lives. Host target only. */
 int driver_default_hosted_dirs(DriverEnv* env, KitTargetSpec target,
                                DriverHostedDirs* out) {
   const char* triple;
   (void)env;
   if (target.os != KIT_OS_LINUX) return 1;
   triple = linux_multiarch_triple(target.arch);
   /* Includes: top-level first, then the arch multiarch dir (glibc), then
    * /usr/local/include. Emission order matters for header shadowing. */
   if (driver_hosted_dirs_add_inc(out, "/usr/include") != 0) return 1;
   if (triple &&
       driver_hosted_dirs_add_inc_join(out, "/usr/include", triple) != 0)
     return 1;
   if (driver_hosted_dirs_add_inc(out, "/usr/local/include") != 0) return 1;
   /* Libdirs: glibc multiarch first, then flat musl/base dirs, then lib64
    * (where the glibc x86_64 loader and some libs live). */
   if (triple) {
     if (driver_hosted_dirs_add_lib_join(out, "/usr/lib", triple) != 0) return 1;
     if (driver_hosted_dirs_add_lib_join(out, "/lib", triple) != 0) return 1;
   }
   if (driver_hosted_dirs_add_lib(out, "/usr/lib") != 0) return 1;
   if (driver_hosted_dirs_add_lib(out, "/lib") != 0) return 1;
   if (driver_hosted_dirs_add_lib(out, "/usr/lib64") != 0) return 1;
   if (driver_hosted_dirs_add_lib(out, "/lib64") != 0) return 1;
   return out->nlibdirs ? 0 : 1;
 }