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")