From e9e0186e664a2a70901ef336836770850fde76fd Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Thu, 29 Oct 2026 07:25:39 -0400 Subject: [PATCH] perf(fex): answer raw stat, readlink and statx syscalls through the proot fast path (#1757) * perf(fex): answer raw stat, readlink and statx syscalls through the proot fast path FEX issues newfstatat, readlinkat and statx as raw syscall() calls, which skipped the libc wrappers the fast path hooks and fell through to ptrace. Route them through libblfastpath the same way raw openat already is, and keep the fast path's own /proc/self/exe lookup off the hooked syscall(). * test(fex): keep the raw lookup test passing on kernels without statx --- tools/linuxfs/preload/robust.c | 18 +++++++ tools/proot/fastpath/fastpath.c | 8 ++-- tools/tests/test_openat2_preload.py | 74 +++++++++++++++++++++++++++-- 3 files changed, 93 insertions(+), 7 deletions(-) diff --git a/tools/linuxfs/preload/robust.c b/tools/linuxfs/preload/robust.c index e156e82c54..fa4cebaf76 100644 --- a/tools/linuxfs/preload/robust.c +++ b/tools/linuxfs/preload/robust.c @@ -49,6 +49,7 @@ static int openat2_missing; static int (*next_fstatat)(int, const char *, bl_stat *, int); static int (*next_openat)(int, const char *, int, ...); static ssize_t (*next_readlinkat)(int, const char *, char *, size_t); +static int (*next_statx)(int, const char *, int, unsigned int, struct statx *); static int find_fastpath(struct dl_phdr_info *info, size_t size, void *name) { (void)size; @@ -68,6 +69,7 @@ __attribute__((constructor)) static void find_fastpath_calls(void) { next_fstatat = (int (*)(int, const char *, bl_stat *, int))dlsym(fastpath, BL_FSTATAT_NAME); next_openat = (int (*)(int, const char *, int, ...))dlsym(fastpath, "openat"); next_readlinkat = (ssize_t (*)(int, const char *, char *, size_t))dlsym(fastpath, "readlinkat"); + next_statx = (int (*)(int, const char *, int, unsigned int, struct statx *))dlsym(fastpath, "statx"); } } @@ -92,6 +94,13 @@ static long path_readlink(int dirfd, const char *path, char *buf, size_t size) { return next_readlinkat(dirfd, path, buf, size); } +static long path_statx(int dirfd, const char *path, int flags, unsigned int mask, struct statx *out) { + if (!next_statx) { + return real_syscall(SYS_statx, (long)dirfd, (long)path, (long)flags, (long)mask, (long)out); + } + return next_statx(dirfd, path, flags, mask, out); +} + void *dlopen(const char *filename, int flags) { if (!real_dlopen) { real_dlopen = (void *(*)(const char *, int))dlsym(RTLD_NEXT, "dlopen"); @@ -372,6 +381,15 @@ long syscall(long number, ...) { if (number == SYS_openat) { return path_open((int)args[0], (const char *)args[1], (int)args[2], args[3]); } + if (number == BL_SYS_FSTATAT) { + return path_stat((int)args[0], (const char *)args[1], (bl_stat *)args[2], (int)args[3]); + } + if (number == SYS_readlinkat) { + return path_readlink((int)args[0], (const char *)args[1], (char *)args[2], (size_t)args[3]); + } + if (number == SYS_statx) { + return path_statx((int)args[0], (const char *)args[1], (int)args[2], (unsigned int)args[3], (struct statx *)args[4]); + } if (number == SYS_execveat && execveat_is_execve(args)) { return real_syscall(SYS_execve, args[1], args[2], args[3]); } diff --git a/tools/proot/fastpath/fastpath.c b/tools/proot/fastpath/fastpath.c index ec1562bdfa..f768fb073c 100644 --- a/tools/proot/fastpath/fastpath.c +++ b/tools/proot/fastpath/fastpath.c @@ -141,12 +141,14 @@ static int traced_by_match(const char *key) { return found; } -static long init_sys(long nr, long a, long b, long c) { +static long init_sys4(long nr, long a, long b, long c, long d) { static long (*real_syscall)(long, ...); if (!real_syscall) real_syscall = (long (*)(long, ...))dlsym(RTLD_NEXT, "syscall"); - return real_syscall(nr, a, b, c); + return real_syscall(nr, a, b, c, d); } +static long init_sys(long nr, long a, long b, long c) { return init_sys4(nr, a, b, c, 0); } + static int program_32bit(const char *prog, int scripts) { char head[256]; long fd = init_sys(SYS_openat, AT_FDCWD, (long)prog, O_RDONLY | O_CLOEXEC); @@ -504,7 +506,7 @@ static long own_exe(char *g) { memcpy(g, exe_text, n + 1); return n; } - long t = syscall(SYS_readlinkat, AT_FDCWD, "/proc/self/exe", g, PATH_MAX - 1); + long t = init_sys4(SYS_readlinkat, AT_FDCWD, (long)"/proc/self/exe", (long)g, PATH_MAX - 1); if (t <= 0 || t >= PATH_MAX - 1) return FP_SLOW; g[t] = 0; static pthread_mutex_t exe_lock = PTHREAD_MUTEX_INITIALIZER; diff --git a/tools/tests/test_openat2_preload.py b/tools/tests/test_openat2_preload.py index eb27bcc7eb..72ede3d24e 100644 --- a/tools/tests/test_openat2_preload.py +++ b/tools/tests/test_openat2_preload.py @@ -94,7 +94,7 @@ COUNTER = r""" #include #include -static int opens, stats, links; +static int opens, stats, links, statxs; int openat(int dirfd, const char *path, int flags, ...) { va_list args; @@ -120,8 +120,13 @@ ssize_t readlinkat(int dirfd, const char *path, char *buf, size_t size) { return ((ssize_t (*)(int, const char *, char *, size_t))dlsym(RTLD_NEXT, "readlinkat"))(dirfd, path, buf, size); } +int statx(int dirfd, const char *path, int flags, unsigned int mask, struct statx *out) { + statxs++; + return ((int (*)(int, const char *, int, unsigned int, struct statx *))dlsym(RTLD_NEXT, "statx"))(dirfd, path, flags, mask, out); +} + __attribute__((destructor)) static void report(void) { - fprintf(stderr, "calls %d %d %d\n", opens, stats, links); + fprintf(stderr, "calls %d %d %d %d\n", opens, stats, links, statxs); } """ @@ -141,6 +146,40 @@ int main(int argc, char **argv) { } """ +RAW_LOOKUP = r""" +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include + +#ifdef SYS_newfstatat +#define RAW_FSTATAT SYS_newfstatat +#else +#define RAW_FSTATAT SYS_fstatat64 +#endif + +int main(int argc, char **argv) { + struct stat st; + struct statx sx; + char link[64] = ""; + if (syscall(RAW_FSTATAT, AT_FDCWD, argv[1], &st, 0) != 0) return 1; + if (syscall(RAW_FSTATAT, AT_FDCWD, argv[2], &st, 0) != -1 || errno != ENOENT) return 2; + long n = syscall(SYS_readlinkat, AT_FDCWD, argv[3], link, sizeof(link) - 1); + if (n <= 0) return 3; + sx.stx_size = 0; + long found = syscall(SYS_statx, AT_FDCWD, argv[1], 0, STATX_SIZE, &sx); + int have_statx = !(found == -1 && errno == ENOSYS); + if (have_statx && found != 0) return 4; + long missing = syscall(SYS_statx, AT_FDCWD, argv[2], 0, STATX_SIZE, &sx); + if (have_statx && (missing != -1 || errno != ENOENT)) return 5; + printf("%lld %.*s %llu\n", (long long)st.st_size, (int)n, link, (unsigned long long)sx.stx_size); + return 0; +} +""" + O_PATH = getattr(os, "O_PATH", 0o10000000) # (dirfd: r = the tree, o = "/"), flags, path, expected: a path in the tree, an errno name, or "proc" for a file outside it. @@ -268,6 +307,14 @@ class Openat2PreloadTest(unittest.TestCase): cls.raw = subprocess.run([str(cls.tmp / "raw_open"), str(tree / "etc/hostname"), str(tree / "missing")], capture_output=True, text=True, timeout=60, env=dict(os.environ, LD_PRELOAD="%s:%s" % (cls.lib, cls.tmp / "fp/libblfastpath.so"))) + lookup = cls.tmp / "raw_lookup.c" + lookup.write_text(RAW_LOOKUP) + subprocess.run(["cc", "-O2", "-Wall", "-Werror", "-o", str(cls.tmp / "raw_lookup"), str(lookup)], check=True) + cls.lookup_args = [str(tree / "etc/hostname"), str(tree / "missing"), str(tree / "etc/alternatives/hn")] + cls.lookup_plain = subprocess.run([str(cls.tmp / "raw_lookup"), *cls.lookup_args], capture_output=True, text=True, + timeout=60, env=dict(os.environ, LD_PRELOAD=str(cls.lib))) + cls.lookup = subprocess.run([str(cls.tmp / "raw_lookup"), *cls.lookup_args], capture_output=True, text=True, timeout=60, + env=dict(os.environ, LD_PRELOAD="%s:%s" % (cls.lib, cls.tmp / "fp/libblfastpath.so"))) (cls.tmp / "real").mkdir() subprocess.run(["cc", "-O2", "-Wall", "-Werror", "-fPIC", "-shared", "-pthread", "-o", str(cls.tmp / "real/libblfastpath.so"), str(FASTPATH), "-ldl"], check=True) @@ -279,6 +326,14 @@ class Openat2PreloadTest(unittest.TestCase): LD_PRELOAD="%s:%s" % (cls.lib, cls.tmp / "real/libblfastpath.so"))) except subprocess.TimeoutExpired: cls.fex = None + (cls.tmp / "fex-lookup").mkdir() + shutil.copy(cls.tmp / "raw_lookup", cls.tmp / "fex-lookup/FEX") + try: + cls.fex_lookup = subprocess.run([str(cls.tmp / "fex-lookup/FEX"), *cls.lookup_args], capture_output=True, text=True, + timeout=20, env=dict(os.environ, PROOT_FP_ROOT="/", PROOT_FP_KEY="test", + LD_PRELOAD="%s:%s" % (cls.lib, cls.tmp / "real/libblfastpath.so"))) + except subprocess.TimeoutExpired: + cls.fex_lookup = None @classmethod def tearDownClass(cls): @@ -295,12 +350,23 @@ class Openat2PreloadTest(unittest.TestCase): def test_the_walk_asks_the_fast_path_when_it_is_loaded(self): self.assertEqual(self.counted, self.preload) - self.assertTrue(all(n > 0 for n in self.calls), self.calls) + self.assertTrue(all(n > 0 for n in self.calls[:3]), self.calls) def test_a_raw_openat_syscall_asks_the_fast_path_too(self): self.assertEqual(self.raw.returncode, 0, self.raw.stderr) self.assertEqual(self.raw.stdout, "inside\n") - self.assertEqual(self.raw.stderr.split("calls ")[-1].split(), ["2", "0", "0"]) + self.assertEqual(self.raw.stderr.split("calls ")[-1].split(), ["2", "0", "0", "0"]) + + def test_raw_stat_readlink_and_statx_syscalls_ask_the_fast_path(self): + self.assertEqual(self.lookup_plain.returncode, 0, self.lookup_plain.stderr) + self.assertEqual(self.lookup.returncode, 0, self.lookup.stderr) + self.assertEqual(self.lookup.stdout, self.lookup_plain.stdout) + self.assertEqual(self.lookup.stderr.split("calls ")[-1].split(), ["0", "2", "1", "2"]) + + def test_raw_lookups_in_fex_answer_through_the_real_fast_path(self): + self.assertIsNotNone(self.fex_lookup, "hung") + self.assertEqual(self.fex_lookup.returncode, 0, self.fex_lookup.stderr) + self.assertEqual(self.fex_lookup.stdout, self.lookup_plain.stdout) def test_a_first_raw_openat_in_fex_does_not_wait_on_the_fast_path_starting(self): self.assertIsNotNone(self.fex, "hung")