Upload folder using huggingface_hub

v13/breaking_rsa_solution.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fd817bf5e5ea2d24c3470eb10338979da075472b026c8ec4492d6d9e5a7fb3c
+size 74512293

v13/my_solution/.dockerignore

@@ -0,0 +1,5 @@
+.cache
+.git
+.gitattributes
+__pycache__
+*.log

v13/my_solution/Dockerfile

@@ -0,0 +1,55 @@
+FROM ubuntu:24.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip python3-dev \
+    build-essential gcc g++ make \
+    autoconf automake libtool m4 perl \
+    libgmp-dev libhwloc15 libhwloc-dev libgomp1 \
+    zlib1g-dev git \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN pip install --no-cache-dir --break-system-packages gmpy2 flask requests
+
+RUN git clone --depth 1 https://gitlab.inria.fr/zimmerma/ecm.git /tmp/ecm-src \
+    && cd /tmp/ecm-src \
+    && autoreconf -i && ./configure CFLAGS="-O2" \
+    && make -j"$(nproc)" && make install && ldconfig \
+    && cp ecm /usr/local/bin/ecm \
+    && rm -rf /tmp/ecm-src
+
+COPY cado-nfs.tar.gz /tmp/
+RUN tar xzf /tmp/cado-nfs.tar.gz -C / \
+    && rm /tmp/cado-nfs.tar.gz \
+    && chmod +x /opt/cado-nfs/build/release/sieve/las \
+                /opt/cado-nfs/build/release/polyselect/polyselect \
+    && python3 /opt/cado-nfs/build/release/cado-nfs.py --help > /dev/null 2>&1
+
+COPY ramnfs/broker.c ramnfs/shim.c /opt/ramnfs/
+RUN cd /opt/ramnfs \
+    && gcc -O2 -pthread -o broker broker.c -lpthread \
+    && gcc -O2 -fPIC -shared -o shim.so shim.c -ldl -lpthread \
+    && chmod +x broker
+
+RUN userdel -r ubuntu 2>/dev/null; useradd -m -u 1000 -s /usr/sbin/nologin miner
+
+WORKDIR /app
+COPY enigma_challenges /app/enigma_challenges/
+COPY breaking_rsa.py /app/
+
+ENV ECM_BIN=/usr/local/bin/ecm \
+    CADO_NFS=/opt/cado-nfs/build/release/cado-nfs.py \
+    RAMNFS_BROKER=/opt/ramnfs/broker \
+    RAMNFS_SHIM=/opt/ramnfs/shim.so \
+    RAMNFS_SOCK=/tmp/ramnfs.sock \
+    RAMNFS_WORKDIR=/ramwork/factor.work \
+    HOME=/tmp \
+    TMPDIR=/tmp \
+    WALL_TIME=14400 \
+    DEADLINE_MARGIN=120 \
+    ECM_PRETEST_CAP=60 \
+    PYTHONUNBUFFERED=1
+
+USER miner
+ENTRYPOINT ["python3", "/app/breaking_rsa.py"]

v13/my_solution/breaking_rsa.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+import glob
+import json
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import *
+
+import gmpy2
+from gmpy2 import mpz
+
+from enigma_challenges.breaking_rsa import Problem, Solution
+from enigma_challenges.solution_output import build_solution_zip, write_solution_output
+
+CHALLENGE_INPUT_FILE = "/challenge_input/challenge_input.json"
+
+
+def _env_int(name: str, default: int) -> int:
+    try:
+        return int(os.environ.get(name, default))
+    except (TypeError, ValueError):
+        return default
+
+
+def _cpu_count() -> int:
+    n = os.cpu_count() or 8
+    try:
+        parts = Path("/sys/fs/cgroup/cpu.max").read_text().split()
+        if parts and parts[0] != "max":
+            return max(1, min(n, int(parts[0]) // int(parts[1])))
+    except (OSError, ValueError, IndexError):
+        pass
+    try:
+        quota = int(Path("/sys/fs/cgroup/cpu/cpu.cfs_quota_us").read_text())
+        period = int(Path("/sys/fs/cgroup/cpu/cpu.cfs_period_us").read_text())
+        if quota > 0 and period > 0:
+            return max(1, min(n, quota // period))
+    except (OSError, ValueError):
+        pass
+    return n
+
+
+def _find_bin(env_key: str, candidates: List[str]) -> Optional[str]:
+    env = os.environ.get(env_key, "").strip()
+    if env and os.path.isfile(env):
+        return env
+    for c in candidates:
+        if os.path.isfile(c):
+            return c
+    return None
+
+
+def _find_cado_script() -> Optional[str]:
+    env = os.environ.get("CADO_NFS", "").strip()
+    if env and os.path.isfile(env):
+        return env
+    for c in ["/opt/cado-nfs/build/release/cado-nfs.py",
+              "/usr/local/bin/cado-nfs.py", "/usr/bin/cado-nfs.py"]:
+        if os.path.isfile(c):
+            return c
+    for pat in ["/opt/cado-nfs/build/*/cado-nfs.py", "/usr/local/lib/cado-nfs-*/cado-nfs.py"]:
+        m = sorted(glob.glob(pat))
+        if m:
+            return m[-1]
+    return None
+
+
+def _start_broker(sock_path: str) -> Optional[subprocess.Popen]:
+    broker = _find_bin("RAMNFS_BROKER", ["/opt/ramnfs/broker", "/app/ramnfs/broker"])
+    if not broker:
+        return None
+    try:
+        os.unlink(sock_path)
+    except OSError:
+        pass
+    try:
+        proc = subprocess.Popen([broker, sock_path],
+                                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except Exception:
+        return None
+    for _ in range(50):
+        if os.path.exists(sock_path):
+            return proc
+        time.sleep(0.1)
+    proc.kill()
+    return None
+
+
+def _factors_from_line(line: str, n: mpz) -> Optional[Tuple[int, int]]:
+    parts = line.split()
+    if len(parts) < 2 or not all(re.fullmatch(r"\d+", p) for p in parts):
+        return None
+    prod = 1
+    for p in parts:
+        prod *= int(p)
+    if prod == n and all(gmpy2.is_prime(mpz(int(p))) for p in parts):
+        a, b = int(parts[0]), int(parts[1])
+        return (a, b) if a <= b else (b, a)
+    return None
+
+
+def _kill(proc: subprocess.Popen) -> None:
+    if proc is None or proc.poll() is not None:
+        return
+    for sig in (signal.SIGTERM, signal.SIGKILL):
+        try:
+            os.killpg(os.getpgid(proc.pid), sig)
+        except Exception:
+            try:
+                proc.kill()
+            except Exception:
+                pass
+        try:
+            proc.wait(timeout=8)
+            return
+        except Exception:
+            continue
+
+
+def _run_cado(n: mpz) -> Optional[Tuple[int, int]]:
+    cado = _find_cado_script()
+    if not cado:
+        return None
+    shim = _find_bin("RAMNFS_SHIM", ["/opt/ramnfs/shim.so", "/app/ramnfs/shim.so"])
+    sock = os.environ.get("RAMNFS_SOCK", "/tmp/ramnfs.sock")
+    workdir = os.environ.get("RAMNFS_WORKDIR", "/ramwork/factor.work")
+    threads = _env_int("CADO_THREADS", 0) or _cpu_count()
+
+    broker = None
+    if shim:
+        broker = _start_broker(sock)
+        if not broker:
+            shim = None
+    if not shim:
+        workdir = os.path.join(os.environ.get("TMPDIR", "/tmp"), "cado_run")
+        os.makedirs(workdir, exist_ok=True)
+
+    env = dict(os.environ)
+    env["HOME"] = env["TMPDIR"] = "/tmp"
+    if shim:
+        env["LD_PRELOAD"] = shim
+        env["RAMNFS_SOCK"] = sock
+        env["RAMNFS_PREFIX"] = "/ramwork"
+
+    cado_build = str(Path(cado).parent)
+    cmd = [
+        sys.executable, cado, str(int(n)),
+        f"tasks.workdir={workdir}",
+        f"tasks.threads={threads}",
+        "server.address=localhost", "server.port=0", "server.threaded=1",
+        f"slaves.nrclients={threads}",
+        f"slaves.cado_nfs_client.bindir={cado_build}",
+        f"tasks.linalg.bwc.threads={threads}",
+        "tasks.sieve.las.threads=1",
+    ]
+    if os.environ.get("CADO_ADMAX"):
+        cmd.append(f"tasks.polyselect.admax={os.environ['CADO_ADMAX']}")
+    if os.environ.get("CADO_DEGREE"):
+        cmd.append(f"tasks.polyselect.degree={os.environ['CADO_DEGREE']}")
+
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                            text=True, env=env, start_new_session=True)
+    factors: Optional[Tuple[int, int]] = None
+    try:
+        assert proc.stdout
+        for raw in proc.stdout:
+            for line in raw.replace("\r", "\n").splitlines():
+                s = line.strip()
+                if not s:
+                    continue
+                factors = _factors_from_line(s, n)
+                if factors:
+                    break
+            if factors:
+                break
+    except Exception:
+        pass
+    finally:
+        _kill(proc)
+        if broker:
+            _kill(broker)
+    return factors
+
+
+def factor_semiprime(n_int: int) -> Tuple[Optional[int], Optional[int], str]:
+    res = _run_cado(mpz(n_int))
+    if res:
+        return res[0], res[1], "cado_gnfs"
+    return None, None, "failed"
+
+
+def _load_problem() -> Tuple[str, "Problem"]:
+    if os.path.isfile(CHALLENGE_INPUT_FILE):
+        try:
+            data = json.loads(Path(CHALLENGE_INPUT_FILE).read_text())
+            prob = Problem(int(data["difficulty"]), int(data["num"]), int(data["num_bits"]))
+            cid = (sys.argv[1].strip() if len(sys.argv) > 1 else "") or "challenge"
+            return cid, prob
+        except Exception:
+            pass
+    if len(sys.argv) == 3:
+        prob = Problem.from_json(sys.argv[2].strip())
+        return sys.argv[1].strip(), prob
+    raise SystemExit("No problem input")
+
+
+def main() -> None:
+    timestamp_start = datetime.now(timezone.utc).isoformat()
+    start = time.time()
+    challenge_id, problem = _load_problem()
+    if problem.num < 6:
+        sys.exit(1)
+
+    p, q, method = factor_semiprime(problem.num)
+    solve_time = time.time() - start
+
+    ok = (p is not None and q is not None
+          and mpz(p) * mpz(q) == problem.num
+          and gmpy2.is_prime(mpz(p)) and gmpy2.is_prime(mpz(q)))
+    solution = Solution("success", int(p), int(q)) if ok else Solution("failed", None, None)
+
+    result_json = json.dumps(solution.to_dict(), indent=2)
+    solve_info_json = json.dumps({
+        "solution_status": solution.status,
+        "challenge_id": challenge_id,
+        "timestamp_utc": timestamp_start,
+        "solve_time_seconds": solve_time,
+        "method": method,
+        "num_bits": problem.num_bits,
+    })
+
+    output_dir = os.environ.get("OUTPUT_DIR")
+    if output_dir:
+        try:
+            Path(output_dir).mkdir(exist_ok=True)
+            Path(output_dir, "result.json").write_text(result_json)
+            Path(output_dir, "solve_info.json").write_text(solve_info_json)
+        except OSError:
+            pass
+
+    write_solution_output(build_solution_zip({
+        "result.json": result_json,
+        "solve_info.json": solve_info_json,
+    }))
+    os._exit(0 if solution.status == "success" else 1)
+
+
+if __name__ == "__main__":
+    main()

v13/my_solution/cado-nfs.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64b4ad20da54b389fbe7c0b521dc95339aeb8fb61aaebf6db8bee1309602b2c8
+size 74769637

v13/my_solution/enigma_challenges/__init__.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+import collections.abc
+import json
+from pathlib import Path
+import typing
+from typing import *
+
+class Challenge[P, S, V](ABC):
+
+    @abstractmethod
+    def generate(self, seed: int) -> tuple[P, V]:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def verify(self, problem: P, solution: S, secrets: V) -> bool:
+        raise NotImplementedError()
+
+class Solver[P, S](ABC):
+
+    @abstractmethod
+    def solve(self, problem: P) -> S:
+        raise NotImplementedError()
+
+def _is_callable_hint(ty: Any) -> bool:
+    return typing.get_origin(ty) is collections.abc.Callable or ty is collections.abc.Callable
+
+def _is_serde(ty: type) -> bool:
+    return isinstance(ty, type) and issubclass(ty, Serde) and (ty is not Serde)
+
+def _convert_from(val: Any, ty: Any) -> Any:
+    if ty is Any:
+        return val
+    origin = typing.get_origin(ty)
+    args = typing.get_args(ty)
+    if origin is Union:
+        if val is None and type(None) in args:
+            return None
+        for variant in args:
+            if variant is type(None):
+                continue
+            try:
+                return _convert_from(val, variant)
+            except (TypeError, KeyError):
+                continue
+        raise TypeError(f'value {val!r} does not match any variant of {ty}')
+    if origin is list:
+        if not isinstance(val, list):
+            raise TypeError(f'expected list, got {type(val)}')
+        if args:
+            return [_convert_from(item, args[0]) for item in val]
+        return val
+    if origin is dict:
+        if not isinstance(val, dict):
+            raise TypeError(f'expected dict, got {type(val)}')
+        if len(args) == 2:
+            return {_convert_from(k, args[0]): _convert_from(v, args[1]) for k, v in val.items()}
+        return val
+    if origin is tuple:
+        if not isinstance(val, (list, tuple)):
+            raise TypeError(f'expected tuple, got {type(val)}')
+        if args:
+            return tuple((_convert_from(item, a) for item, a in zip(val, args)))
+        return tuple(val)
+    if _is_serde(ty):
+        if isinstance(val, ty):
+            return val
+        if isinstance(val, dict):
+            return ty.from_dict(val)
+        raise TypeError(f'expected dict or {ty.__name__}, got {type(val)}')
+    if isinstance(ty, type) and (not isinstance(val, ty)):
+        raise TypeError(f'expected type `{ty.__name__}` but got `{type(val).__name__}`')
+    return val
+
+def _convert_to(val: Any) -> Any:
+    if isinstance(val, Serde):
+        return val.to_dict()
+    if isinstance(val, list):
+        return [_convert_to(item) for item in val]
+    if isinstance(val, dict):
+        return {k: _convert_to(v) for k, v in val.items()}
+    if isinstance(val, tuple):
+        return [_convert_to(item) for item in val]
+    return val
+
+class Serde:
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        hints = typing.get_type_hints(cls)
+        defaults = {key: val for key in dir(cls) if not key.startswith('__') and (not isinstance((val := getattr(cls, key)), Callable))}
+        args = list()
+        for key, ty in hints.items():
+            if _is_callable_hint(ty):
+                continue
+            if key in data:
+                val = data[key]
+            elif key in defaults:
+                val = defaults[key]
+            else:
+                raise KeyError(f"missing expected key '{key}'")
+            args.append(_convert_from(val, ty))
+        return cls(*args)
+
+    def to_dict(self) -> dict[str, Any]:
+        hints = typing.get_type_hints(type(self))
+        result = {}
+        for key, ty in hints.items():
+            if _is_callable_hint(ty):
+                continue
+            result[key] = _convert_to(getattr(self, key))
+        return result
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        return cls.from_dict(json.loads(json_str))
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json_file(cls, json_file: Path) -> Self:
+        with json_file.open('r') as infile:
+            return cls.from_dict(json.load(infile))
+
+    def to_json_file(self, out: Path) -> None:
+        with out.open('w') as outfile:
+            json.dump(self.to_dict(), outfile)

v13/my_solution/enigma_challenges/breaking_rsa.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import logging
+from typing import *
+import gmpy2
+from . import Challenge, Serde
+_logger = logging.getLogger(__name__)
+
+@dataclass
+class Problem(Serde):
+    difficulty: int
+    num: int
+    num_bits: int
+
+@dataclass
+class Solution(Serde):
+    status: str
+    p: Optional[int]
+    q: Optional[int]
+
+@dataclass
+class Verif(Serde):
+    n: int
+    p: int
+    q: int
+
+def validate_breaking_rsa_solution(solution: Solution, verif: Verif, prob: Problem | None=None, require_success_status: bool=True) -> tuple[bool, str | None]:
+    if require_success_status and getattr(solution, 'status', None) != 'success':
+        return (False, f"Solution status is '{getattr(solution, 'status', None)}', not 'success'")
+    if solution.p is None or solution.q is None:
+        return (False, 'Solution has missing factors (p or q is null)')
+    try:
+        sol_p = int(solution.p)
+        sol_q = int(solution.q)
+    except (TypeError, ValueError):
+        return (False, f'Solution p/q are not valid integers: p={solution.p}, q={solution.q}')
+    sol_p, sol_q = (min(sol_p, sol_q), max(sol_p, sol_q))
+    p_check, q_check = (min(verif.p, verif.q), max(verif.p, verif.q))
+    n = verif.n
+    if sol_p * sol_q != n:
+        return (False, f'p * q != n: {sol_p} * {sol_q} != {n}')
+    if sol_p != p_check or sol_q != q_check:
+        return (False, f"Factors don't match expected: got ({sol_p}, {sol_q}), expected ({p_check}, {q_check})")
+    if prob is not None:
+        if prob.num != n or sol_p * sol_q != prob.num:
+            return (False, f'n mismatch between problem ({prob.num}) and verif ({n})')
+    return (True, None)
+
+def _gen_prime(num_bits: int, rng: gmpy2.random_state) -> gmpy2.mpz:
+    n = gmpy2.mpz_urandomb(rng, num_bits)
+    n |= 1 << num_bits - 1 | 1
+    return gmpy2.next_prime(n)
+
+@dataclass
+class BreakingRSA(Challenge[Problem, Solution, Verif]):
+    difficulty: int
+    num_bits: int
+
+    def generate(self, seed: int) -> tuple[Problem, Verif]:
+        rng = gmpy2.random_state(seed)
+        bits_p = self.num_bits // 2
+        bits_q = self.num_bits - bits_p
+        fermat_thresh = 2 ** max(bits_p - 100, 1)
+        while True:
+            p = _gen_prime(bits_p, rng)
+            q = _gen_prime(bits_q, rng)
+            n = p * q
+            if n.bit_length() == self.num_bits and abs(p - q) > fermat_thresh:
+                break
+        n = int(n)
+        p = int(p)
+        q = int(q)
+        _logger.info(f'Generated {self.num_bits}-bit semiprime ({len(str(n))} digits)')
+        problem = Problem(self.difficulty, n, self.num_bits)
+        verif = Verif(n, p, q)
+        return (problem, verif)
+
+    def verify(self, prob: Problem, sol: Solution, verif: Verif) -> bool:
+        success, reason = validate_breaking_rsa_solution(sol, verif, prob, require_success_status=False)
+        if success:
+            _logger.info('Verification SUCCESS')
+        elif sol.p is None or sol.q is None:
+            _logger.info(f'Verification FAILURE: missing factors, got p={sol.p} and' + f' q={sol.q}, with solution status {sol.status}')
+        else:
+            _logger.info(f'Verification FAILURE: {reason or 'factors do not match'}')
+        return success

v13/my_solution/enigma_challenges/solution_output.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+import base64
+import binascii
+import io
+import os
+import sys
+import zipfile
+SOLUTION_OUTPUT_SEPARATOR: bytes = b'\n----- ENIGMA-SOLUTION-OUTPUT-BEGIN-a8c7f3e2-9d4b-4c5a-8f1e-2b6d3a4e5f7c -----\n'
+
+def build_solution_zip(files: dict[str, str | bytes]) -> bytes:
+    buffer = io.BytesIO()
+    with zipfile.ZipFile(buffer, 'w', compression=zipfile.ZIP_DEFLATED) as zf:
+        for name, content in files.items():
+            zf.writestr(name, content)
+    return buffer.getvalue()
+
+def write_solution_output(zip_bytes: bytes) -> None:
+    sys.stdout.flush()
+    sys.stderr.flush()
+    encoded = base64.b64encode(zip_bytes)
+    buf = sys.stdout.buffer
+    buf.write(SOLUTION_OUTPUT_SEPARATOR)
+    buf.write(encoded)
+    buf.write(b'\n')
+    buf.flush()
+
+def split_on_separator(raw_stdout: bytes) -> tuple[bytes, bytes, bool]:
+    idx = raw_stdout.find(SOLUTION_OUTPUT_SEPARATOR)
+    if idx == -1:
+        return (raw_stdout, b'', False)
+    return (raw_stdout[:idx], raw_stdout[idx + len(SOLUTION_OUTPUT_SEPARATOR):], True)
+
+def extract_artifacts(raw_stdout: bytes, output_dir: str) -> tuple[bool, str | None]:
+    os.makedirs(output_dir, exist_ok=True)
+    logs_bytes, payload_b64, found = split_on_separator(raw_stdout)
+    log_path = os.path.join(output_dir, 'stdout.log')
+    with open(log_path, 'wb') as f:
+        f.write(logs_bytes)
+    if not found:
+        return (False, 'No solution output separator found in container stdout. The solver must print logs, then the separator line, then a base64-encoded zip of result.json and other artifacts.')
+    payload_b64 = payload_b64.strip()
+    if not payload_b64:
+        return (False, 'Separator found but base64 payload is empty.')
+    try:
+        payload_bytes = base64.b64decode(payload_b64, validate=True)
+    except (binascii.Error, ValueError) as e:
+        return (False, f'Base64 decode of solution payload failed: {e}')
+    if not payload_bytes:
+        return (False, 'Decoded payload is empty.')
+    zip_path = os.path.join(output_dir, 'solution_artifacts.zip')
+    with open(zip_path, 'wb') as f:
+        f.write(payload_bytes)
+    if not zipfile.is_zipfile(zip_path):
+        return (False, 'Decoded payload is not a valid zip file.')
+    try:
+        with zipfile.ZipFile(zip_path, 'r') as zf:
+            dest = os.path.abspath(output_dir)
+            for member in zf.infolist():
+                member_path = os.path.normpath(os.path.join(dest, member.filename))
+                if not (member_path == dest or member_path.startswith(dest + os.sep)):
+                    return (False, f"Zip member '{member.filename}' escapes output directory.")
+            zf.extractall(dest)
+    except zipfile.BadZipFile as e:
+        return (False, f'Bad zip file: {e}')
+    except Exception as e:
+        return (False, f'Zip extraction failed: {e}')
+    return (True, None)

v13/my_solution/ramnfs/broker.c

@@ -0,0 +1,196 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <pthread.h>
+#include <errno.h>
+#include <signal.h>
+
+#define MAXF    16384
+#define PATHMAX 1024
+
+static char            g_paths[MAXF][PATHMAX];
+static int             g_fds[MAXF];
+static int             g_nf = 0;
+static pthread_mutex_t g_mu = PTHREAD_MUTEX_INITIALIZER;
+static int             g_dbg = 0;
+static int             g_keep = 0;
+
+static int idx_of(const char *p) {
+    for (int i = 0; i < g_nf; i++)
+        if (g_fds[i] >= 0 && strcmp(g_paths[i], p) == 0) return i;
+    return -1;
+}
+
+static int find_or_create(const char *path) {
+    int i = idx_of(path);
+    if (i >= 0) return g_fds[i];
+    if (g_nf >= MAXF) return -1;
+    int fd = memfd_create("ramnfs", 0);
+    if (fd < 0) return -1;
+    strncpy(g_paths[g_nf], path, PATHMAX - 1);
+    g_fds[g_nf] = fd;
+    g_nf++;
+    return fd;
+}
+
+static int send_fd(int sock, int fd, char status) {
+    struct msghdr msg = {0};
+    char b = status;
+    struct iovec io = {.iov_base = &b, .iov_len = 1};
+    msg.msg_iov = &io; msg.msg_iovlen = 1;
+    char cbuf[CMSG_SPACE(sizeof(int))];
+    memset(cbuf, 0, sizeof cbuf);
+    if (fd >= 0) {
+        msg.msg_control = cbuf; msg.msg_controllen = sizeof cbuf;
+        struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
+        c->cmsg_level = SOL_SOCKET; c->cmsg_type = SCM_RIGHTS;
+        c->cmsg_len = CMSG_LEN(sizeof(int));
+        memcpy(CMSG_DATA(c), &fd, sizeof(int));
+    }
+    return sendmsg(sock, &msg, 0);
+}
+
+static int readn(int fd, void *buf, int n) {
+    int g = 0;
+    while (g < n) {
+        int r = read(fd, (char *)buf + g, n - g);
+        if (r <= 0) return g;
+        g += r;
+    }
+    return g;
+}
+
+static void *handle_conn(void *arg) {
+    int c = (int)(intptr_t)arg;
+    char op = 0;
+    if (readn(c, &op, 1) != 1) goto done;
+    unsigned short len = 0;
+    if (readn(c, &len, 2) != 2) goto done;
+    if (len >= PATHMAX) len = PATHMAX - 1;
+    char path[PATHMAX] = {0};
+    if (readn(c, path, len) != (int)len) goto done;
+    path[len] = 0;
+
+    if (op == 'O') {
+        pthread_mutex_lock(&g_mu);
+        int existed = idx_of(path) >= 0;
+        int memfd = find_or_create(path);
+        pthread_mutex_unlock(&g_mu);
+        if (g_dbg) fprintf(stderr, "broker: OPEN %s %s\n", existed ? "existing" : "CREATE", path);
+        if (memfd < 0) { send_fd(c, -1, 'E'); goto done; }
+        char proc[64];
+        snprintf(proc, sizeof proc, "/proc/self/fd/%d", memfd);
+        int sendable = open(proc, O_RDWR);
+        send_fd(c, sendable, sendable >= 0 ? 'K' : 'E');
+        if (sendable >= 0) close(sendable);
+
+    } else if (op == 'S') {
+        pthread_mutex_lock(&g_mu);
+        int i = idx_of(path);
+        long long sz = 0; char st = 'E';
+        if (i >= 0) {
+            struct stat stt;
+            if (fstat(g_fds[i], &stt) == 0) { sz = stt.st_size; st = 'K'; }
+        }
+        pthread_mutex_unlock(&g_mu);
+        if (g_dbg && st == 'E') fprintf(stderr, "broker: STAT MISS %s\n", path);
+        write(c, &st, 1); write(c, &sz, 8);
+
+    } else if (op == 'U') {
+
+        size_t pl = strlen(path);
+        int is_rel = (pl >= 3 && strcmp(path + pl - 3, ".gz") == 0);
+        int retain = g_keep || is_rel;
+        pthread_mutex_lock(&g_mu);
+        int i = idx_of(path);
+        if (g_dbg) fprintf(stderr, "broker: UNLINK %s %s%s\n",
+                           i >= 0 ? "hit" : "miss", path, (i >= 0 && retain) ? " (RETAINED)" : "");
+        if (i >= 0 && !retain) { close(g_fds[i]); g_fds[i] = -1; g_paths[i][0] = 0; }
+        pthread_mutex_unlock(&g_mu);
+        char st = 'K'; write(c, &st, 1);
+
+    } else if (op == 'L') {
+
+        char pfx[PATHMAX]; strncpy(pfx, path, PATHMAX - 1); pfx[PATHMAX-1] = 0;
+        size_t pl = strlen(pfx);
+        if (pl > 0 && pfx[pl-1] == '/') pfx[--pl] = 0;
+
+        char **names = NULL; int cnt = 0;
+        pthread_mutex_lock(&g_mu);
+        for (int i = 0; i < g_nf; i++) {
+            if (g_fds[i] < 0) continue;
+            const char *p = g_paths[i];
+            if (strncmp(p, pfx, pl) != 0 || p[pl] != '/') continue;
+            const char *rest = p + pl + 1;
+            if (strchr(rest, '/') != NULL) continue;
+            names = realloc(names, (cnt + 1) * sizeof(char *));
+            names[cnt++] = strdup(rest);
+        }
+        pthread_mutex_unlock(&g_mu);
+
+        write(c, &cnt, 4);
+        for (int i = 0; i < cnt; i++) {
+            unsigned short nl = (unsigned short)strlen(names[i]);
+            write(c, &nl, 2); write(c, names[i], nl);
+            free(names[i]);
+        }
+        free(names);
+
+    } else if (op == 'P') {
+        fprintf(stderr, "shimlog: %s\n", path);
+    }
+done:
+    close(c);
+    return NULL;
+}
+
+static void dump_table(int sig) {
+    (void)sig;
+    fprintf(stderr, "=== BROKER DUMP: %d slots ===\n", g_nf);
+    for (int i = 0; i < g_nf; i++) {
+        if (g_fds[i] < 0) continue;
+        if (strstr(g_paths[i], "filelist") || strstr(g_paths[i], "stderr") || strstr(g_paths[i], "stdout")) {
+            fprintf(stderr, "DUMP %s CONTENT:\n", g_paths[i]);
+            off_t cur = lseek(g_fds[i], 0, SEEK_CUR);
+            lseek(g_fds[i], 0, SEEK_SET);
+            char buf[16384]; int r;
+            while ((r = read(g_fds[i], buf, sizeof buf)) > 0) fwrite(buf, 1, r, stderr);
+            lseek(g_fds[i], cur, SEEK_SET);
+            fprintf(stderr, "--- end filelist ---\n");
+        } else {
+            fprintf(stderr, "FILE %s\n", g_paths[i]);
+        }
+    }
+    fprintf(stderr, "=== END DUMP ===\n");
+}
+
+int main(int argc, char **argv) {
+    const char *sp = argc > 1 ? argv[1] : "/tmp/ramnfs.sock";
+    signal(SIGUSR1, dump_table);
+    g_dbg = getenv("RAMNFS_DEBUG") != NULL;
+    g_keep = getenv("RAMNFS_KEEP") != NULL;
+    unlink(sp);
+    int s = socket(AF_UNIX, SOCK_STREAM, 0);
+    struct sockaddr_un a = {0}; a.sun_family = AF_UNIX;
+    strncpy(a.sun_path, sp, sizeof a.sun_path - 1);
+    if (bind(s, (struct sockaddr *)&a, sizeof a) < 0) { perror("bind"); return 1; }
+    listen(s, 4096);
+    fprintf(stderr, "broker: listening on %s (pid %d)\n", sp, getpid());
+    for (;;) {
+        int c = accept(s, 0, 0);
+        if (c < 0) continue;
+        pthread_t t; pthread_attr_t attr;
+        pthread_attr_init(&attr);
+        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+        if (pthread_create(&t, &attr, handle_conn, (void *)(intptr_t)c) != 0)
+            handle_conn((void *)(intptr_t)c);
+        pthread_attr_destroy(&attr);
+    }
+}

v13/my_solution/ramnfs/shim.c

@@ -0,0 +1,761 @@
+#define _GNU_SOURCE
+#include <dlfcn.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <linux/stat.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <dirent.h>
+#include <errno.h>
+#include <pthread.h>
+
+static const char *g_sock   = NULL;
+static const char *g_prefix = NULL;
+static size_t      g_plen   = 0;
+static int         g_debug  = 0;
+
+static void dbg(const char *fmt, ...) {
+    if (!g_debug) return;
+    va_list ap; va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+    fflush(stderr);
+}
+
+#define SQLITE_REAL_DIR "/tmp/cado-sqlite"
+
+#define CWD_REAL_PREFIX "/tmp/ramnfs_cwd"
+#define PATHMAX 1024
+
+#define MAXDIRS 2048
+static char g_dirs[MAXDIRS][1024];
+static int  g_ndirs = 0;
+static pthread_mutex_t g_mu = PTHREAD_MUTEX_INITIALIZER;
+
+__attribute__((constructor))
+static void shim_init(void) {
+    const char *s = getenv("RAMNFS_SOCK");
+    const char *p = getenv("RAMNFS_PREFIX");
+    g_sock   = s ? s : "/tmp/ramnfs.sock";
+    g_prefix = p ? p : "/ramwork";
+    g_plen   = strlen(g_prefix);
+    g_debug  = getenv("RAMNFS_DEBUG") != NULL;
+
+    mkdir(SQLITE_REAL_DIR, 0777);
+}
+
+static void ensure_real_dir(const char *path) {
+    static int (*real_mkdir)(const char *, mode_t) = NULL;
+    if (!real_mkdir) real_mkdir = dlsym(RTLD_NEXT, "mkdir");
+    char tmp[PATHMAX]; strncpy(tmp, path, PATHMAX-1); tmp[PATHMAX-1]=0;
+    for (char *p = tmp+1; *p; p++) {
+        if (*p == '/') { *p=0; real_mkdir(tmp, 0755); *p='/'; }
+    }
+    real_mkdir(tmp, 0755);
+}
+
+static const char *real_to_virt_cwd(const char *real_cwd) {
+    static const char *pfx = CWD_REAL_PREFIX;
+    size_t plen = strlen(pfx);
+    if (strncmp(real_cwd, pfx, plen) == 0
+            && (real_cwd[plen] == '/' || real_cwd[plen] == '\0')) {
+        static __thread char buf[PATHMAX];
+        snprintf(buf, PATHMAX, "%s%s", g_prefix, real_cwd + plen);
+        return buf;
+    }
+    return NULL;
+}
+
+static const char *resolve_relpath(const char *path) {
+    static __thread char buf[PATHMAX];
+    if (!path) return path;
+    if (path[0] == '/') {
+
+        if (!strstr(path, "//")) return path;
+        size_t j = 0;
+        for (size_t i = 0; path[i] && j + 1 < PATHMAX; i++) {
+            if (path[i] == '/' && j > 0 && buf[j-1] == '/') continue;
+            buf[j++] = path[i];
+        }
+        buf[j] = 0;
+        return buf;
+    }
+    char cwd[PATHMAX];
+    if (!getcwd(cwd, sizeof cwd)) return path;
+    const char *virt = real_to_virt_cwd(cwd);
+    if (!virt) return path;
+    if (path[0] == '.' && path[1] == '\0') {
+        snprintf(buf, PATHMAX, "%s", virt);
+    } else {
+        snprintf(buf, PATHMAX, "%s/%s", virt, path);
+    }
+
+    size_t n = strlen(buf);
+    while (n > 1 && buf[n-1] == '.' && buf[n-2] == '/') { n -= 2; buf[n] = '\0'; }
+    while (n > 1 && buf[n-1] == '/') buf[--n] = '\0';
+    return buf;
+}
+
+static int is_ramnfs(const char *path) {
+    if (!path || !g_prefix || g_plen == 0) return 0;
+    return strncmp(path, g_prefix, g_plen) == 0
+        && (path[g_plen] == '/' || path[g_plen] == '\0');
+}
+
+static int looks_ramnfs(const char *path) {
+    if (!path) return 0;
+    if (path[0] == '/') path = resolve_relpath(path);
+    return is_ramnfs(path);
+}
+
+static int is_sqlite_file(const char *path) {
+    if (!path) return 0;
+    size_t n = strlen(path);
+
+    if (n >= 3 && strcmp(path + n - 3, ".db") == 0) return 1;
+    if (n >= 11 && strcmp(path + n - 11, ".db-journal") == 0) return 1;
+    if (n >= 7 && strcmp(path + n - 7, ".db-wal") == 0) return 1;
+    if (n >= 7 && strcmp(path + n - 7, ".db-shm") == 0) return 1;
+    return 0;
+}
+
+static const char *sqlite_real_path(const char *ramnfs_path) {
+    static char buf[PATHMAX];
+
+    const char *rest = ramnfs_path + g_plen;
+    snprintf(buf, sizeof buf, SQLITE_REAL_DIR "%s", rest);
+
+    char parent[PATHMAX];
+    strncpy(parent, buf, sizeof parent - 1);
+    char *slash = strrchr(parent, '/');
+    if (slash && slash != parent) {
+        *slash = 0;
+
+        static int (*real_mkdir)(const char*, mode_t) = NULL;
+        if (!real_mkdir) real_mkdir = dlsym(RTLD_NEXT, "mkdir");
+        if (real_mkdir) {
+
+            char tmp[PATHMAX];
+            strncpy(tmp, SQLITE_REAL_DIR, sizeof tmp - 1);
+            const char *p = rest + 1;
+            while (p && *p) {
+                const char *next = strchr(p, '/');
+                if (!next) break;
+                int len = next - rest;
+                snprintf(tmp, sizeof tmp, SQLITE_REAL_DIR "%.*s", len, rest);
+                real_mkdir(tmp, 0777);
+                p = next + 1;
+            }
+            real_mkdir(parent, 0777);
+        }
+    }
+    return buf;
+}
+
+static int readn(int fd, void *buf, int n) {
+    int g = 0;
+    while (g < n) { int r = read(fd,(char*)buf+g,n-g); if(r<=0) return g; g+=r; }
+    return g;
+}
+
+static int broker_connect(void) {
+
+    for (int attempt = 0; attempt < 200; attempt++) {
+        int s = socket(AF_UNIX, SOCK_STREAM, 0);
+        if (s >= 0) {
+            struct sockaddr_un a = {0}; a.sun_family = AF_UNIX;
+            strncpy(a.sun_path, g_sock, sizeof a.sun_path - 1);
+            if (connect(s, (struct sockaddr *)&a, sizeof a) == 0) return s;
+            close(s);
+        }
+        usleep(attempt < 20 ? 500 : 3000);
+    }
+    return -1;
+}
+
+static void broker_send_req(int s, char op, const char *path) {
+    unsigned short len = (unsigned short)strlen(path);
+    write(s, &op, 1); write(s, &len, 2); write(s, path, len);
+}
+
+static void blog(const char *fmt, ...) {
+    if (!g_debug) return;
+    char buf[1200];
+    va_list ap; va_start(ap, fmt);
+    vsnprintf(buf, sizeof buf, fmt, ap);
+    va_end(ap);
+    int s = broker_connect();
+    if (s < 0) return;
+    broker_send_req(s, 'P', buf);
+    close(s);
+}
+
+static int broker_open_fd(const char *path) {
+    int s = broker_connect(); if (s < 0) return -1;
+    broker_send_req(s, 'O', path);
+    char status = 0;
+    struct iovec iov = {.iov_base=&status,.iov_len=1};
+    char cbuf[CMSG_SPACE(sizeof(int))]; memset(cbuf,0,sizeof cbuf);
+    struct msghdr msg = {.msg_iov=&iov,.msg_iovlen=1,
+                         .msg_control=cbuf,.msg_controllen=sizeof cbuf};
+    int fd = -1;
+    if (recvmsg(s, &msg, 0) >= 1) {
+        struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
+        if (c && c->cmsg_type == SCM_RIGHTS) memcpy(&fd, CMSG_DATA(c), sizeof(int));
+    }
+    close(s);
+    return (status == 'K') ? fd : (fd >= 0 ? (close(fd),-1) : -1);
+}
+
+static int broker_stat(const char *path, long long *sz_out) {
+    int s = broker_connect(); if (s < 0) return 0;
+    broker_send_req(s, 'S', path);
+    char st = 0; long long sz = 0;
+    readn(s, &st, 1); readn(s, &sz, 8); close(s);
+    if (sz_out) *sz_out = sz;
+    return st == 'K';
+}
+
+static void broker_unlink_path(const char *path) {
+    int s = broker_connect(); if (s < 0) return;
+    broker_send_req(s, 'U', path);
+    char st; readn(s, &st, 1); close(s);
+}
+
+static char **broker_listdir(const char *dir, int *count_out) {
+    *count_out = 0;
+    int s = broker_connect(); if (s < 0) return NULL;
+    broker_send_req(s, 'L', dir);
+    int cnt = 0; readn(s, &cnt, 4);
+    if (cnt <= 0) { close(s); return NULL; }
+    char **names = calloc(cnt, sizeof(char *));
+    for (int i = 0; i < cnt; i++) {
+        unsigned short nl = 0; readn(s, &nl, 2);
+        names[i] = malloc(nl + 1);
+        readn(s, names[i], nl); names[i][nl] = 0;
+    }
+    close(s);
+    *count_out = cnt;
+    return names;
+}
+
+static void record_dir(const char *path) {
+    pthread_mutex_lock(&g_mu);
+    for (int i = 0; i < g_ndirs; i++)
+        if (strcmp(g_dirs[i], path) == 0) { pthread_mutex_unlock(&g_mu); return; }
+    if (g_ndirs < MAXDIRS) strncpy(g_dirs[g_ndirs++], path, 1023);
+    pthread_mutex_unlock(&g_mu);
+}
+
+static int is_known_dir(const char *path) {
+    if (strcmp(path, g_prefix) == 0) return 1;
+    pthread_mutex_lock(&g_mu);
+    for (int i = 0; i < g_ndirs; i++)
+        if (strcmp(g_dirs[i], path) == 0) { pthread_mutex_unlock(&g_mu); return 1; }
+    pthread_mutex_unlock(&g_mu);
+    return 0;
+}
+
+int open(const char *path, int flags, ...) {
+    static int (*real)(const char*,int,...) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "open");
+    path = resolve_relpath(path);
+    if (is_ramnfs(path)) {
+        if (is_sqlite_file(path)) {
+
+            const char *rpath = sqlite_real_path(path);
+            mode_t m = 0644;
+            if (flags & O_CREAT) { va_list v; va_start(v,flags); m=va_arg(v,mode_t); va_end(v); }
+            return real(rpath, flags, m);
+        }
+
+        size_t plen = strlen(path);
+        if (plen > g_plen && path[plen-1] == '/') { errno = EISDIR; return -1; }
+        if (is_known_dir(path)) { errno = EISDIR; return -1; }
+        if ((flags & O_CREAT) == 0) {
+            long long sz;
+            if (!broker_stat(path, &sz)) {
+                dbg("[shim] open FAIL path=%s flags=%d (ENOENT, not in broker)\n", path, flags);
+                errno = ENOENT; return -1;
+            }
+        }
+        int fd = broker_open_fd(path);
+        if (fd < 0) { dbg("[shim] open FAIL path=%s (EIO broker)\n", path); errno = EIO; return -1; }
+        if (flags & O_TRUNC) ftruncate(fd, 0);
+        if (flags & O_APPEND) lseek(fd, 0, SEEK_END);
+        else lseek(fd, 0, SEEK_SET);
+        return fd;
+    }
+    mode_t m = 0;
+    if (flags & O_CREAT) { va_list v; va_start(v,flags); m=va_arg(v,mode_t); va_end(v); }
+    return real(path, flags, m);
+}
+
+int open64(const char *path, int flags, ...) {
+    mode_t m = 0;
+    if (flags & O_CREAT) { va_list v; va_start(v,flags); m=va_arg(v,mode_t); va_end(v); }
+    return open(path, flags, m);
+}
+
+int openat(int dirfd, const char *path, int flags, ...) {
+    static int (*real)(int,const char*,int,...) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "openat");
+
+    if (path && (path[0] == '/' || dirfd == AT_FDCWD))
+        path = resolve_relpath(path);
+    if (path && path[0]=='/' && is_ramnfs(path)) {
+        mode_t m = 0;
+        if (flags & O_CREAT) { va_list v; va_start(v,flags); m=va_arg(v,mode_t); va_end(v); }
+        return open(path, flags, m);
+    }
+    mode_t m = 0;
+    if (flags & O_CREAT) { va_list v; va_start(v,flags); m=va_arg(v,mode_t); va_end(v); }
+    return real ? real(dirfd, path, flags, m) : (errno=ENOSYS,-1);
+}
+
+int openat64(int dirfd, const char *path, int flags, ...) {
+    mode_t m = 0;
+    if (flags & O_CREAT) { va_list v; va_start(v,flags); m=va_arg(v,mode_t); va_end(v); }
+    return openat(dirfd, path, flags, m);
+}
+
+FILE *fopen(const char *path, const char *mode) {
+    static FILE *(*real)(const char*,const char*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "fopen");
+    path = resolve_relpath(path);
+    if (is_ramnfs(path)) {
+        if (is_sqlite_file(path)) {
+            return real(sqlite_real_path(path), mode);
+        }
+        int flags;
+        if (mode[0]=='r' && !strchr(mode,'+'))       flags = O_RDONLY;
+        else if (mode[0]=='w' && !strchr(mode,'+'))  flags = O_WRONLY|O_CREAT|O_TRUNC;
+        else if (mode[0]=='a')                        flags = O_WRONLY|O_CREAT|O_APPEND;
+        else                                          flags = O_RDWR|O_CREAT;
+        int fd = open(path, flags, 0666);
+        if (fd < 0) return NULL;
+        char m2[8]={0}; strncpy(m2, mode, 7);
+        FILE *f = fdopen(fd, m2);
+        if (!f) close(fd);
+        return f;
+    }
+    return real(path, mode);
+}
+
+FILE *fopen64(const char *path, const char *mode) { return fopen(path, mode); }
+
+int creat(const char *path, mode_t mode) {
+    return open(path, O_WRONLY|O_CREAT|O_TRUNC, mode);
+}
+
+static void fill_stat_dir(struct stat *buf) {
+    memset(buf, 0, sizeof *buf);
+    buf->st_mode = S_IFDIR | 0755; buf->st_nlink = 2;
+}
+static void fill_stat_file(struct stat *buf, long long sz) {
+    memset(buf, 0, sizeof *buf);
+    buf->st_mode = S_IFREG | 0755; buf->st_nlink = 1; buf->st_size = sz;
+}
+
+int stat(const char *path, struct stat *buf) {
+    static int (*real)(const char*,struct stat*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "stat");
+    path = resolve_relpath(path);
+    if (is_ramnfs(path)) {
+        if (is_sqlite_file(path)) return real(sqlite_real_path(path), buf);
+        if (is_known_dir(path)) { fill_stat_dir(buf); return 0; }
+        long long sz = 0;
+        if (broker_stat(path, &sz)) { fill_stat_file(buf, sz); return 0; }
+        errno = ENOENT; return -1;
+    }
+    return real(path, buf);
+}
+
+int lstat(const char *path, struct stat *buf) { return stat(resolve_relpath(path), buf); }
+
+int stat64(const char *path, struct stat64 *buf) {
+    static int (*real)(const char*,struct stat64*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "stat64");
+    path = resolve_relpath(path);
+    if (is_ramnfs(path)) {
+        if (is_sqlite_file(path)) return real(sqlite_real_path(path), buf);
+        if (is_known_dir(path)) {
+            memset(buf, 0, sizeof *buf);
+            buf->st_mode = S_IFDIR | 0755; buf->st_nlink = 2; return 0;
+        }
+        long long sz = 0;
+        if (broker_stat(path, &sz)) {
+            memset(buf, 0, sizeof *buf);
+            buf->st_mode = S_IFREG | 0644; buf->st_nlink = 1;
+            buf->st_size = (off64_t)sz; return 0;
+        }
+        errno = ENOENT; return -1;
+    }
+    return real(path, buf);
+}
+int lstat64(const char *path, struct stat64 *buf) { return stat64(resolve_relpath(path), buf); }
+
+int fstatat(int dirfd, const char *path, struct stat *buf, int flags) {
+    static int (*real)(int,const char*,struct stat*,int) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "fstatat");
+    if (path && (path[0] == '/' || dirfd == AT_FDCWD)) path = resolve_relpath(path);
+    if (path && path[0]=='/' && is_ramnfs(path)) {
+        if (is_sqlite_file(path)) return real(AT_FDCWD, sqlite_real_path(path), buf, flags);
+        return stat(path, buf);
+    }
+    return real ? real(dirfd, path, buf, flags) : (errno=ENOSYS,-1);
+}
+
+int fstatat64(int dirfd, const char *path, struct stat64 *buf, int flags) {
+    static int (*real)(int,const char*,struct stat64*,int) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "fstatat64");
+    if (path && (path[0] == '/' || dirfd == AT_FDCWD)) path = resolve_relpath(path);
+    if (path && path[0]=='/' && is_ramnfs(path)) {
+        if (is_sqlite_file(path)) return real(AT_FDCWD, sqlite_real_path(path), buf, flags);
+        if (is_known_dir(path)) {
+            memset(buf, 0, sizeof *buf);
+            buf->st_mode = S_IFDIR | 0755; buf->st_nlink = 2;
+            return 0;
+        }
+        long long sz = 0;
+        if (broker_stat(path, &sz)) {
+            memset(buf, 0, sizeof *buf);
+            buf->st_mode = S_IFREG | 0644; buf->st_nlink = 1;
+            buf->st_size = (off64_t)sz;
+            return 0;
+        }
+        errno = ENOENT; return -1;
+    }
+    return real ? real(dirfd, path, buf, flags) : (errno=ENOSYS,-1);
+}
+
+int statx(int dirfd, const char *path, int flags, unsigned int mask,
+          struct statx *stxbuf) {
+    static int (*real)(int,const char*,int,unsigned,struct statx*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "statx");
+    if (path && (path[0] == '/' || dirfd == AT_FDCWD)) path = resolve_relpath(path);
+    if (path && path[0]=='/' && is_ramnfs(path)) {
+        if (is_sqlite_file(path)) return real(AT_FDCWD, sqlite_real_path(path), flags, mask, stxbuf);
+        if (is_known_dir(path)) {
+            memset(stxbuf, 0, sizeof *stxbuf);
+            stxbuf->stx_mode  = S_IFDIR | 0755;
+            stxbuf->stx_nlink = 2;
+            stxbuf->stx_mask  = STATX_BASIC_STATS;
+            return 0;
+        }
+        long long sz = 0;
+        if (broker_stat(path, &sz)) {
+            memset(stxbuf, 0, sizeof *stxbuf);
+            stxbuf->stx_mode  = S_IFREG | 0644;
+            stxbuf->stx_nlink = 1;
+            stxbuf->stx_size  = (unsigned long long)sz;
+            stxbuf->stx_mask  = STATX_BASIC_STATS;
+            return 0;
+        }
+        errno = ENOENT; return -1;
+    }
+    return real ? real(dirfd, path, flags, mask, stxbuf) : (errno=ENOSYS,-1);
+}
+
+int __xstat(int ver, const char *path, struct stat *buf) {
+    static int (*real)(int,const char*,struct stat*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "__xstat");
+    if (looks_ramnfs(path)) return stat(path, buf);
+    return real ? real(ver, path, buf) : (errno=ENOSYS,-1);
+}
+int __lxstat(int ver, const char *path, struct stat *buf) { return __xstat(ver,path,buf); }
+int __xstat64(int ver, const char *path, struct stat *buf) { return __xstat(ver,path,buf); }
+int __lxstat64(int ver, const char *path, struct stat *buf) { return __xstat(ver,path,buf); }
+
+int access(const char *path, int mode) {
+    static int (*real)(const char*,int) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "access");
+    path = resolve_relpath(path);
+    if (is_ramnfs(path)) {
+        if (is_sqlite_file(path)) return real(sqlite_real_path(path), mode);
+        if (is_known_dir(path)) return 0;
+        if (broker_stat(path, NULL)) return 0;
+        blog("ACCESS ramnfs MISS '%s' mode=%d", path, mode);
+        errno = ENOENT; return -1;
+    }
+    if (strstr(path, ".gz")) blog("ACCESS non-ramnfs gz '%s'", path);
+    int r = real(path, mode);
+    if (r != 0 && strstr(path, ".gz")) blog("ACCESS real FAIL '%s' errno=%d", path, errno);
+    return r;
+}
+
+int faccessat(int dirfd, const char *path, int mode, int flags) {
+    static int (*real)(int,const char*,int,int) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "faccessat");
+    if (looks_ramnfs(path)) return access(path, mode);
+    return real ? real(dirfd, path, mode, flags) : (errno=ENOSYS,-1);
+}
+
+int unlink(const char *path) {
+    static int (*real)(const char*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "unlink");
+    path = resolve_relpath(path);
+    if (is_ramnfs(path)) {
+        if (is_sqlite_file(path)) return real(sqlite_real_path(path));
+        broker_unlink_path(path); return 0;
+    }
+    return real(path);
+}
+
+int unlinkat(int dirfd, const char *path, int flags) {
+    static int (*real)(int,const char*,int) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "unlinkat");
+    if (looks_ramnfs(path)) return unlink(path);
+    return real ? real(dirfd, path, flags) : (errno=ENOSYS,-1);
+}
+
+int rename(const char *oldp, const char *newp) {
+    static int (*real)(const char*,const char*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "rename");
+
+    char old_buf[PATHMAX], new_buf[PATHMAX];
+    strncpy(old_buf, resolve_relpath(oldp), PATHMAX-1); old_buf[PATHMAX-1]=0; oldp=old_buf;
+    strncpy(new_buf, resolve_relpath(newp), PATHMAX-1); new_buf[PATHMAX-1]=0; newp=new_buf;
+    if (is_ramnfs(oldp) || is_ramnfs(newp)) {
+
+        if (is_sqlite_file(oldp) || is_sqlite_file(newp)) {
+            const char *ro = is_sqlite_file(oldp) ? sqlite_real_path(oldp) : oldp;
+            const char *rn = is_sqlite_file(newp) ? sqlite_real_path(newp) : newp;
+            return real(ro, rn);
+        }
+        int src = broker_open_fd(oldp);
+        int dst = broker_open_fd(newp);
+        if (src < 0 || dst < 0) {
+            if (src>=0) close(src); if (dst>=0) close(dst);
+            errno = EIO; return -1;
+        }
+        ftruncate(dst, 0); lseek(src, 0, SEEK_SET);
+        char buf[131072]; ssize_t r;
+        while ((r = read(src, buf, sizeof buf)) > 0) write(dst, buf, r);
+        close(src); close(dst);
+        broker_unlink_path(oldp);
+        return 0;
+    }
+    return real(oldp, newp);
+}
+
+int renameat(int od, const char *op, int nd, const char *np) {
+    if (looks_ramnfs(op)) return rename(op, np);
+    static int (*real)(int,const char*,int,const char*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "renameat");
+    return real ? real(od, op, nd, np) : (errno=ENOSYS,-1);
+}
+
+int symlink(const char *target, const char *linkpath) {
+    static int (*real)(const char*,const char*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "symlink");
+
+    char lp_buf[PATHMAX];
+    strncpy(lp_buf, resolve_relpath(linkpath), PATHMAX-1); lp_buf[PATHMAX-1]=0;
+    if (is_ramnfs(lp_buf)) {
+
+        char src_path[PATHMAX];
+        if (target[0] == '/') {
+            strncpy(src_path, target, PATHMAX-1); src_path[PATHMAX-1]=0;
+        } else {
+
+            strncpy(src_path, lp_buf, PATHMAX-1);
+            char *slash = strrchr(src_path, '/');
+            if (slash) { slash[1] = '\0'; strncat(src_path, target, PATHMAX-1-strlen(src_path)); }
+            else strncpy(src_path, target, PATHMAX-1);
+        }
+        if (!is_ramnfs(src_path)) { errno = EXDEV; return -1; }
+
+        int src = broker_open_fd(src_path);
+        int dst = broker_open_fd(lp_buf);
+        if (src < 0 || dst < 0) {
+            if (src>=0) close(src); if (dst>=0) close(dst);
+            errno = ENOENT; return -1;
+        }
+        ftruncate(dst, 0); lseek(src, 0, SEEK_SET);
+        char buf[131072]; ssize_t r;
+        while ((r = read(src, buf, sizeof buf)) > 0) write(dst, buf, r);
+        close(src); close(dst);
+        return 0;
+    }
+    return real ? real(target, linkpath) : (errno=ENOSYS,-1);
+}
+
+int symlinkat(const char *target, int newdirfd, const char *linkpath) {
+    if (looks_ramnfs(linkpath))
+        return symlink(target, linkpath);
+    static int (*real)(const char*,int,const char*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "symlinkat");
+    return real ? real(target, newdirfd, linkpath) : (errno=ENOSYS,-1);
+}
+
+int mkdir(const char *path, mode_t mode) {
+    static int (*real)(const char*,mode_t) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "mkdir");
+    path = resolve_relpath(path);
+    if (is_ramnfs(path)) { record_dir(path); return 0; }
+    return real(path, mode);
+}
+
+int mkdirat(int dirfd, const char *path, mode_t mode) {
+    static int (*real)(int,const char*,mode_t) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "mkdirat");
+    if (looks_ramnfs(path)) return mkdir(path, mode);
+    return real ? real(dirfd, path, mode) : (errno=ENOSYS,-1);
+}
+
+int rmdir(const char *path) {
+    static int (*real)(const char*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "rmdir");
+    if (looks_ramnfs(path)) return 0;
+    return real(path);
+}
+
+int chdir(const char *path) {
+    static int (*real)(const char*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "chdir");
+    if (path && path[0]=='/') path = resolve_relpath(path);
+    if (is_ramnfs(path)) {
+        char real_dir[PATHMAX];
+        const char *rest = path + g_plen;
+        snprintf(real_dir, PATHMAX, CWD_REAL_PREFIX "%s", rest);
+        ensure_real_dir(real_dir);
+        return real(real_dir);
+    }
+    return real(path);
+}
+
+int chmod(const char *path, mode_t mode) {
+    static int (*real)(const char*,mode_t) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "chmod");
+    path = resolve_relpath(path);
+    if (is_ramnfs(path)) {
+        if (is_sqlite_file(path)) return real(sqlite_real_path(path), mode);
+        return 0;
+    }
+    return real(path, mode);
+}
+
+int lchmod(const char *path, mode_t mode) { return chmod(path, mode); }
+
+int fchmodat(int dirfd, const char *path, mode_t mode, int flags) {
+    static int (*real)(int,const char*,mode_t,int) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "fchmodat");
+    if (looks_ramnfs(path)) return chmod(path, mode);
+    return real ? real(dirfd, path, mode, flags) : (errno=ENOSYS,-1);
+}
+
+int chown(const char *path, uid_t uid, gid_t gid) {
+    static int (*real)(const char*,uid_t,gid_t) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "chown");
+    if (looks_ramnfs(path)) return 0;
+    return real(path, uid, gid);
+}
+
+int lchown(const char *path, uid_t uid, gid_t gid) { return chown(path, uid, gid); }
+
+int truncate(const char *path, off_t len) {
+    static int (*real)(const char*,off_t) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "truncate");
+    path = resolve_relpath(path);
+    if (is_ramnfs(path)) {
+        if (is_sqlite_file(path)) return real(sqlite_real_path(path), len);
+        int fd = broker_open_fd(path);
+        if (fd < 0) { errno = ENOENT; return -1; }
+        int r = ftruncate(fd, len); close(fd); return r;
+    }
+    return real(path, len);
+}
+
+#define FAKEDIR_MAGIC 0x52414d46U
+
+typedef struct {
+    unsigned int magic;
+    char       **names;
+    int          count;
+    int          idx;
+    struct dirent64 de64;
+    struct dirent   de;
+} FakeDir;
+
+DIR *opendir(const char *name) {
+    static DIR *(*real)(const char*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "opendir");
+    name = resolve_relpath(name);
+    if (is_ramnfs(name)) {
+        long long sz;
+        if (broker_stat(name, &sz)) { errno = ENOTDIR; return NULL; }
+        record_dir(name);
+        int cnt = 0;
+        char **names = broker_listdir(name, &cnt);
+        FakeDir *fd = calloc(1, sizeof(FakeDir));
+        fd->magic = FAKEDIR_MAGIC;
+        fd->names = names; fd->count = cnt; fd->idx = 0;
+        return (DIR *)fd;
+    }
+    return real(name);
+}
+
+struct dirent *readdir(DIR *dirp) {
+    static struct dirent *(*real)(DIR*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "readdir");
+    if (dirp && ((FakeDir *)dirp)->magic == FAKEDIR_MAGIC) {
+        FakeDir *fd = (FakeDir *)dirp;
+        if (fd->idx >= fd->count) return NULL;
+        memset(&fd->de, 0, sizeof fd->de);
+        strncpy(fd->de.d_name, fd->names[fd->idx++], sizeof fd->de.d_name - 1);
+        fd->de.d_type = DT_REG;
+        return &fd->de;
+    }
+    return real(dirp);
+}
+
+struct dirent64 *readdir64(DIR *dirp) {
+    static struct dirent64 *(*real)(DIR*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "readdir64");
+    if (dirp && ((FakeDir *)dirp)->magic == FAKEDIR_MAGIC) {
+        FakeDir *fd = (FakeDir *)dirp;
+        if (fd->idx >= fd->count) return NULL;
+        memset(&fd->de64, 0, sizeof fd->de64);
+        strncpy(fd->de64.d_name, fd->names[fd->idx++], sizeof fd->de64.d_name - 1);
+        fd->de64.d_type = DT_REG;
+        return &fd->de64;
+    }
+    return real(dirp);
+}
+
+int closedir(DIR *dirp) {
+    static int (*real)(DIR*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "closedir");
+    if (dirp && ((FakeDir *)dirp)->magic == FAKEDIR_MAGIC) {
+        FakeDir *fd = (FakeDir *)dirp;
+        for (int i = 0; i < fd->count; i++) free(fd->names[i]);
+        free(fd->names); free(fd);
+        return 0;
+    }
+    return real(dirp);
+}
+
+int fstat(int fd, struct stat *buf) {
+    static int (*real)(int, struct stat*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "fstat");
+    int rc = real(fd, buf);
+    if (rc == 0 && S_ISREG(buf->st_mode) && buf->st_nlink == 0)
+        buf->st_nlink = 1;
+    return rc;
+}
+
+int fstat64(int fd, struct stat64 *buf) {
+    static int (*real)(int, struct stat64*) = NULL;
+    if (!real) real = dlsym(RTLD_NEXT, "fstat64");
+    int rc = real(fd, buf);
+    if (rc == 0 && S_ISREG(buf->st_mode) && buf->st_nlink == 0)
+        buf->st_nlink = 1;
+    return rc;
+}