kit

freebsd.c (5155B)

---

 /* FreeBSD-specific env bits. Uses:
  *   - memfd_create(3) (FreeBSD 13+) for the dual-map fd
  *   - st_mtim (POSIX.1-2008) for mtime
  *   - dlsym(RTLD_DEFAULT) for the resolver
  *
  * If this file ever needs to support pre-13 FreeBSD, switch the fd source
  * to shm_open(SHM_ANON, O_RDWR, 0) + shm_unlink(); the rest of the dance
  * (ftruncate + two mmaps of the fd at distinct VAs) is identical. */
 
 #include <dlfcn.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "env_posix.h"
 
 /* ---------------- dual-mapped exec memory ---------------- */
 
 KitStatus os_execmem_reserve_exec(size_t size, KitExecMemRegion* out) {
   int fd = memfd_create("kit-jit", 0);
   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, fd, 0);
   if (w == MAP_FAILED) {
     close(fd);
     return KIT_NOMEM;
   }
   r = mmap(NULL, size, PROT_READ, MAP_SHARED, 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 ---------------- */
 /* Same shape as Linux: prefer alias lookup, fall back to 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;
   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 ---------------- */
 
 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_FREEBSD;
   t->obj = KIT_OBJ_ELF;
 }
 
 /* ---------------- self executable path ---------------- */
 /* The KERN_PROC_PATHNAME sysctl returns the absolute path of a process's text
  * image; pid -1 selects the calling process. A first call with a NULL buffer
  * reports the required length (including the NUL). */
 int driver_self_exe_path(DriverEnv* env, char** out, size_t* out_size) {
   int mib[4];
   size_t len = 0;
   size_t cap;
   char* buf;
 
   if (!env || !out || !out_size) return 1;
   mib[0] = CTL_KERN;
   mib[1] = KERN_PROC;
   mib[2] = KERN_PROC_PATHNAME;
   mib[3] = -1;
   if (sysctl(mib, 4, NULL, &len, NULL, 0) != 0 || len == 0) return 1;
   cap = len;
   buf = (char*)driver_alloc(env, cap);
   if (!buf) return 1;
   if (sysctl(mib, 4, buf, &len, NULL, 0) != 0) {
     driver_free(env, buf, cap);
     return 1;
   }
   buf[cap - 1u] = '\0'; /* defensive: ensure termination */
   *out = buf;
   *out_size = cap;
   return 0;
 }
 
 /* ---------------- default hosted dirs probe ---------------- */
 /* FreeBSD base system is flat: headers in /usr/include, crt + libc in /usr/lib
  * and /lib (libc.so.7 lives in /lib). Host target only. */
 int driver_default_hosted_dirs(DriverEnv* env, KitTargetSpec target,
                                DriverHostedDirs* out) {
   (void)env;
   if (target.os != KIT_OS_FREEBSD) return 1;
   if (driver_hosted_dirs_add_inc(out, "/usr/include") != 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;
   return out->nlibdirs ? 0 : 1;
 }