hakmem/core/box/madvise_guard_box.c

// madvise_guard_box.c - Box: Safe madvise wrapper with DSO guard
#include "madvise_guard_box.h"
#include "ss_os_acquire_box.h"
#include "log_once_box.h"

#include <dlfcn.h>
#include <errno.h>
#include <stdbool.h>
#include <stdatomic.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>

#if !HAKMEM_BUILD_RELEASE
static hak_log_once_t g_madvise_bad_ptr_once = HAK_LOG_ONCE_INIT;
static hak_log_once_t g_madvise_enomem_once = HAK_LOG_ONCE_INIT;
#endif

static int ss_madvise_guard_env(const char* name, int default_on) {
    const char* e = getenv(name);
    if (!e || *e == '\0') {
        return default_on;
    }
    return (*e != '0') ? 1 : 0;
}

int ss_madvise_guard_enabled(void) {
    static int enabled = -1;
    if (__builtin_expect(enabled == -1, 0)) {
        enabled = ss_madvise_guard_env("HAKMEM_SS_MADVISE_GUARD", 1);
    }
    return enabled;
}

int ss_madvise_guard_quiet_logs(void) {
    static int quiet = -1;
    if (__builtin_expect(quiet == -1, 0)) {
        quiet = ss_madvise_guard_env("HAKMEM_SS_MADVISE_GUARD_QUIET", 0);
    }
    return quiet;
}

int ss_os_madvise_guarded(void* ptr, size_t len, int advice, const char* where) {
    (void)where;
    if (!ptr || len == 0) {
        return 0;
    }

#if !HAKMEM_BUILD_RELEASE
    bool quiet = ss_madvise_guard_quiet_logs() != 0;
#endif

    // Guard can be turned off via env for A/B testing.
    if (!ss_madvise_guard_enabled()) {
        int ret = madvise(ptr, len, advice);
        ss_os_stats_record_madvise();
        return ret;
    }

    Dl_info dli = {0};
    if (dladdr(ptr, &dli) != 0 && dli.dli_fname != NULL) {
#if !HAKMEM_BUILD_RELEASE
        hak_log_once_fprintf(&g_madvise_bad_ptr_once,
                             quiet,
                             stderr,
                             "[SS_MADVISE_GUARD] skip ptr=%p len=%zu owner=%s\n",
                             ptr,
                             len,
                             dli.dli_fname);
#endif
        return 0;
    }

    if (atomic_load_explicit(&g_ss_madvise_disabled, memory_order_relaxed)) {
        return 0;
    }

    int ret = madvise(ptr, len, advice);
    ss_os_stats_record_madvise();
    if (ret == 0) {
        return 0;
    }

    int e = errno;
    if (e == ENOMEM) {
        atomic_fetch_add_explicit(&g_ss_os_madvise_fail_enomem, 1, memory_order_relaxed);
        atomic_store_explicit(&g_ss_madvise_disabled, true, memory_order_relaxed);
#if !HAKMEM_BUILD_RELEASE
        hak_log_once_fprintf(&g_madvise_enomem_once,
                             quiet,
                             stderr,
                             "[SS_OS_MADVISE] madvise(advice=%d, ptr=%p, len=%zu) failed with ENOMEM; disabling further madvise\n",
                             advice,
                             ptr,
                             len);
#endif
        return 0; // soft fail, do not propagate ENOMEM
    }

    atomic_fetch_add_explicit(&g_ss_os_madvise_fail_other, 1, memory_order_relaxed);
    errno = e;
    if (e == EINVAL) {
        return -1; // let caller handle strict mode
    }
    return 0;
}