diff --git a/tools/linuxfs/preload/dircache.c b/tools/linuxfs/preload/dircache.c index 7d6cffd124..296faa616b 100644 --- a/tools/linuxfs/preload/dircache.c +++ b/tools/linuxfs/preload/dircache.c @@ -22,8 +22,12 @@ #define MAX_LISTINGS 16 #define MAX_ENTRIES 100000 #define MAX_HANDLES 64 +#define MAX_UP 32 #define FUSE_MAGIC 0x65735546 #define WATCHED (IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO | IN_DELETE_SELF | IN_MOVE_SELF | IN_ONLYDIR) +#define ABOVE (IN_DELETE_SELF | IN_MOVE_SELF | IN_ONLYDIR | IN_MASK_ADD) +#define GONE (IN_DELETE_SELF | IN_MOVE_SELF | IN_IGNORED) +#define LINKED (IN_DELETE_SELF | IN_MOVE_SELF | IN_DONT_FOLLOW | IN_MASK_ADD) #if __SIZEOF_POINTER__ == 8 @@ -42,10 +46,14 @@ struct listing { int refs; int detached; int wd; + int up[MAX_UP], nup; + int blind; size_t n, cap; struct entry *e; char *recs; size_t len; + char *where; + int folds; }; struct handle { @@ -55,6 +63,8 @@ struct handle { size_t pos; int fd; int wd; + int up[MAX_UP], nup; + int blind; int dirty; char *path; struct dirent64 out; @@ -147,6 +157,7 @@ static void destroy(struct listing *l) { for (size_t i = 0; i < l->n; i++) free(l->e[i].name); free(l->e); free(l->recs); + free(l->where); free(l); } @@ -155,15 +166,26 @@ static void unref(struct listing *l) { } +static int under(const int *up, int nup, int wd) { + for (int i = 0; i < nup; i++) + if (up[i] == wd) return 1; + return 0; +} + static void release(int wd) { if (wd < 0 || notify < 0) return; for (int i = 0; i < MAX_LISTINGS; i++) - if (table[i] && table[i]->wd == wd) return; + if (table[i] && (table[i]->wd == wd || under(table[i]->up, table[i]->nup, wd))) return; for (int i = 0; i < high_water; i++) - if (handles[i] && handles[i]->wd == wd) return; + if (handles[i] && (handles[i]->wd == wd || under(handles[i]->up, handles[i]->nup, wd))) return; inotify_rm_watch(notify, wd); } +static void let_go(int wd, const int *up, int nup) { + release(wd); + for (int i = 0; i < nup; i++) release(up[i]); +} + static void detach(struct listing *l) { __atomic_sub_fetch(&cached_listings, 1, __ATOMIC_RELEASE); l->detached = 1; @@ -172,17 +194,32 @@ static void detach(struct listing *l) { static void drop(int slot) { struct listing *l = table[slot]; - int wd = l->wd; + int wd = l->wd, up[MAX_UP], nup = l->nup; + memcpy(up, l->up, sizeof(up)); table[slot] = NULL; detach(l); - release(wd); + let_go(wd, up, nup); } -static void changed(int wd) { +static void changed(int wd, uint32_t mask) { + int gone = (mask & GONE) != 0; for (int i = 0; i < MAX_LISTINGS; i++) - if (table[i] && (table[i]->wd == wd || wd < 0)) drop(i); + if (table[i] && (table[i]->wd == wd || wd < 0 || (gone && under(table[i]->up, table[i]->nup, wd)))) drop(i); for (int i = 0; i < high_water; i++) - if (handles[i] && (handles[i]->wd == wd || wd < 0)) __atomic_store_n(&handles[i]->dirty, 1, __ATOMIC_RELAXED); + if (handles[i] && (handles[i]->wd == wd || wd < 0 || (gone && under(handles[i]->up, handles[i]->nup, wd)))) + __atomic_store_n(&handles[i]->dirty, 1, __ATOMIC_RELAXED); +} + +static void forget_below(const char *path) { + if (path == NULL || path[0] != '/') return; + size_t n = strlen(path); + while (n > 1 && path[n - 1] == '/') n--; + for (int i = 0; i < MAX_LISTINGS; i++) { + struct listing *l = table[i]; + if (l == NULL || l->where == NULL) continue; + int prefix = l->folds ? strncasecmp(l->where, path, n) == 0 : strncmp(l->where, path, n) == 0; + if (prefix && (l->where[n] == '/' || l->where[n] == 0)) drop(i); + } } static void pump(struct expect *x, int nx) { @@ -194,7 +231,7 @@ static void pump(struct expect *x, int nx) { if (n <= 0) { if (n < 0 && errno != EAGAIN && errno != EINTR) { notify = -2; - changed(-1); + changed(-1, 0); } break; } @@ -202,7 +239,7 @@ static void pump(struct expect *x, int nx) { struct inotify_event *ev = (struct inotify_event *)p; p += sizeof(*ev) + ev->len; if (ev->mask & IN_Q_OVERFLOW) { - changed(-1); + changed(-1, 0); continue; } int k = 0; @@ -212,21 +249,21 @@ static void pump(struct expect *x, int nx) { for (int i = 0; i < high_water; i++) if (handles[i] && handles[i]->wd == ev->wd) __atomic_store_n(&handles[i]->dirty, 1, __ATOMIC_RELAXED); } else { - changed(ev->wd); + changed(ev->wd, ev->mask); } } } errno = saved; } -static int watch(const char *path) { +static int watch(const char *path, uint32_t mask) { if (notify == -1) notify = inotify_init1(IN_NONBLOCK | IN_CLOEXEC); if (notify < 0) { notify = -2; return -1; } int saved = errno; - int wd = inotify_add_watch(notify, path, WATCHED); + int wd = inotify_add_watch(notify, path, mask); errno = saved; return wd; } @@ -257,10 +294,11 @@ static void install(struct listing *l) { int slot = find(l->dev, l->ino); if (slot >= 0) { struct listing *old = table[slot]; - int old_wd = old->wd; + int old_wd = old->wd, up[MAX_UP], nup = old->nup; + memcpy(up, old->up, sizeof(up)); table[slot] = l; detach(old); - if (old_wd != l->wd) release(old_wd); + let_go(old_wd, up, nup); return; } int victim = -1; @@ -387,11 +425,47 @@ static DIR *hit(const struct stat *st, struct handle *h, long long now) { return NULL; } +static int above(struct handle *h, const char *path) { + char up[PATH_MAX]; + size_t n = strlen(path); + while (n > 1 && path[n - 1] == '/') n--; + if (n >= sizeof(up)) return 0; + memcpy(up, path, n); + up[n] = 0; + size_t root = (size_t)(strstr(path, "/steamapps") - path) + 10; + for (size_t i = 1; i <= n; i++) { + if (up[i] != '/' && up[i] != 0) continue; + char at = up[i]; + up[i] = 0; + int wd = i < n ? watch(up, ABOVE) : h->wd; + int link = watch(up, LINKED); + up[i] = at; + if (link < 0) h->blind = 1; + else if (link != wd) { + h->blind = 1; + release(link); + } + if (i == n) break; + if (wd < 0 && i < root) { + h->blind = 1; + continue; + } + if (wd < 0) return 0; + if (wd == h->wd || under(h->up, h->nup, wd)) continue; + if (h->nup == MAX_UP) { + release(wd); + return 0; + } + h->up[h->nup++] = wd; + } + return 1; +} + static int track(struct handle *h, const char *path) { pthread_mutex_lock(&lock); - h->wd = watch(path); - DIR *d = h->wd >= 0 ? wrap(h) : NULL; - if (d == NULL && h->wd >= 0) release(h->wd); + h->wd = watch(path, WATCHED); + DIR *d = h->wd >= 0 && above(h, path) ? wrap(h) : NULL; + if (d == NULL) let_go(h->wd, h->up, h->nup); pthread_mutex_unlock(&lock); return d != NULL; } @@ -404,6 +478,10 @@ static void filling(struct handle *h, DIR *real, const struct stat *st, long lon h->fill->filled = now; h->fill->used = now; h->fill->wd = h->wd; + memcpy(h->fill->up, h->up, sizeof(h->up)); + h->fill->nup = h->nup; + h->fill->blind = h->blind; + h->fill->where = strdup(h->path); } } @@ -411,7 +489,7 @@ static void untrack(struct handle *h) { pthread_mutex_lock(&lock); int i = registered((DIR *)h); if (i >= 0) __atomic_store_n(&handles[i], NULL, __ATOMIC_RELEASE); - release(h->wd); + let_go(h->wd, h->up, h->nup); pthread_mutex_unlock(&lock); } @@ -454,11 +532,27 @@ static void abandon(struct handle *h) { h->fill = NULL; } +static int folds(const char *path, const struct stat *st) { + char swapped[PATH_MAX]; + struct stat b; + const char *at = strstr(path, "/steamapps"); + size_t n = strlen(path); + if (at == NULL || n >= sizeof(swapped)) return 0; + memcpy(swapped, path, n + 1); + for (char *c = swapped + (at - path); *c; c++) + if ((*c >= 'a' && *c <= 'z') || (*c >= 'A' && *c <= 'Z')) *c ^= 0x20; + int saved = errno; + int same_dir = stat(swapped, &b) == 0 && b.st_dev == st->st_dev && b.st_ino == st->st_ino; + errno = saved; + return same_dir; +} + static void finish(struct handle *h) { struct listing *l = h->fill; struct stat st; h->fill = NULL; int current = stat(h->path, &st) == 0 && same(l, &st); + if (current) l->folds = folds(h->path, &st); pthread_mutex_lock(&lock); if (!changing) pump(NULL, 0); if (current && !__atomic_load_n(&h->dirty, __ATOMIC_RELAXED)) install(l); @@ -536,7 +630,7 @@ int closedir(DIR *d) { if (h) { __atomic_store_n(&handles[i], NULL, __ATOMIC_RELEASE); if (h->snap) unref(h->snap); - release(h->wd); + let_go(h->wd, h->up, h->nup); } pthread_mutex_unlock(&lock); if (h == NULL) return next_closedir(d); @@ -658,6 +752,11 @@ static int patch(struct side *s, int what, uint32_t event, int ok, int error, co copy->filled = l->filled; copy->used = l->used; copy->wd = l->wd; + memcpy(copy->up, l->up, sizeof(l->up)); + copy->nup = l->nup; + copy->blind = l->blind; + copy->where = l->where ? strdup(l->where) : NULL; + copy->folds = l->folds; copy->detached = 0; stamp(copy, &s->before); table[slot] = copy; @@ -738,6 +837,7 @@ int bl_dircache_create(int dirfd, const char *path, int flags, mode_t mode, struct expect x; \ pthread_mutex_lock(&lock); \ int nx = patch(&s, what, event, r == 0, saved, what == ADDED ? path : NULL, &x); \ + if (r == 0 && what == REMOVED) forget_below(path); \ pthread_mutex_unlock(&lock); \ end(&x, nx); \ pthread_mutex_unlock(&oplock); \ @@ -770,6 +870,7 @@ ONE_PATH(remove, REMOVED, IN_DELETE, next_remove(path)) if (track_a && strcmp(a.dir, b.dir) == 0) b.known = stat(b.dir, &b.before) == 0; \ nx += patch(&b, ADDED, event, r == 0, saved, to, &x[nx]); \ } \ + if (r == 0 && gone) { forget_below(from); forget_below(to); } \ pthread_mutex_unlock(&lock); \ end(x, nx); \ pthread_mutex_unlock(&oplock); \ @@ -784,8 +885,62 @@ TWO_PATHS(rename, 1, IN_MOVED_TO, next_rename) TWO_PATHS(link, 0, IN_CREATE, link_or_lock) TWO_PATHS(symlink, 0, IN_CREATE, next_symlink) +static int named(const struct listing *l, const char *name) { + for (size_t i = 0; i < l->n; i++) + if (strcasecmp(l->e[i].name, name) == 0) return 1; + return 0; +} + +static int folded_match(const char *where, const char *dir) { + const char *at = strstr(where, "/steamapps"); + if (at == NULL) return 0; + size_t n = (size_t)(at - where); + return strncmp(where, dir, n) == 0 && strcasecmp(where + n, dir + n) == 0; +} + +static int same_dir(const struct listing *l, const char *dir) { + struct stat st; + int saved = errno; + int same = stat(dir, &st) == 0 && st.st_dev == l->dev && st.st_ino == l->ino; + errno = saved; + return same; +} + +static int listed_absent(const char *dir, const char *name, long long now) { + for (int i = 0; i < MAX_LISTINGS; i++) { + struct listing *l = table[i]; + if (l == NULL || l->where == NULL || l->blind || now - l->filled >= DIR_TTL_NS) continue; + if (strcmp(l->where, dir) == 0) return !named(l, name); + if (l->folds && folded_match(l->where, dir)) return same_dir(l, dir) && !named(l, name); + } + return 0; +} + +int bl_dircache_absent(const char *path) __attribute__((visibility("hidden"))); +int bl_dircache_absent(const char *path) { + struct side s; + if (!watching(path) || !split(path, &s)) return 0; + for (const char *c = s.name; *c; c++) + if ((unsigned char)*c >= 0x80) return 0; + long long now = now_ns(); + pthread_mutex_lock(&lock); + int absent = 0; + if (!changing) { + pump(NULL, 0); + absent = listed_absent(s.dir, s.name, now); + } + pthread_mutex_unlock(&lock); + return absent; +} + #else +int bl_dircache_absent(const char *path) __attribute__((visibility("hidden"))); +int bl_dircache_absent(const char *path) { + (void)path; + return 0; +} + int bl_dircache_create(int dirfd, const char *path, int flags, mode_t mode, int (*real)(int, const char *, int, mode_t)) __attribute__((visibility("hidden"))); int bl_dircache_create(int dirfd, const char *path, int flags, mode_t mode, diff --git a/tools/linuxfs/preload/pathcache.c b/tools/linuxfs/preload/pathcache.c index 928fd7d24d..59f2cbf069 100644 --- a/tools/linuxfs/preload/pathcache.c +++ b/tools/linuxfs/preload/pathcache.c @@ -111,6 +111,8 @@ char *bl_cached_realpath(const char *path, char *resolved, char *(*real)(const c return strdup(out); } +int bl_dircache_absent(const char *path) __attribute__((weak, visibility("hidden"))); + static int cached_access(const char *path, int mode, int flags, int (*check)(const char *, int, int)) { unsigned h; int hit; @@ -122,6 +124,10 @@ static int cached_access(const char *path, int mode, int flags, int (*check)(con hit = find(path, KIND_ACCESS, mode, flags, h) != NULL; pthread_mutex_unlock(&lock); if (hit) return 0; + if (bl_dircache_absent && bl_dircache_absent(path)) { + errno = ENOENT; + return -1; + } result = check(path, mode, flags); if (result == 0) { pthread_mutex_lock(&lock); diff --git a/tools/tests/test_dircache_preload.py b/tools/tests/test_dircache_preload.py index 50ad24d5f7..42db6817ce 100644 --- a/tools/tests/test_dircache_preload.py +++ b/tools/tests/test_dircache_preload.py @@ -3,6 +3,7 @@ from pathlib import Path import shutil import subprocess import tempfile +import threading import unittest PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload" @@ -10,6 +11,7 @@ PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload" FAKE = r""" #define _GNU_SOURCE #include +#include #include #include #include @@ -17,9 +19,11 @@ FAKE = r""" #include #include #include +#include #include int real_opendirs; +int real_accesses; static void coarse(const char *path, struct stat *st) { if (getenv("COARSE") && strstr(path, "/fuse/") && S_ISDIR(st->st_mode)) { @@ -32,6 +36,17 @@ static void coarse(const char *path, struct stat *st) { int stat(const char *path, struct stat *st) { static int (*next)(const char *, struct stat *); if (!next) next = dlsym(RTLD_NEXT, "stat"); + char folded[4096]; + const char *fold = getenv("FOLD"); + const char *upper = fold ? strstr(path, "/STEAMAPPS") : NULL; + if (!upper && fold && !strcmp(fold, "all")) upper = strcasestr(path, "/steamapps/"); + if (upper && strlen(path) < sizeof(folded)) { + strcpy(folded, path); + memcpy(folded + (upper - path) + 1, "steamapps", 9); + if (!strcmp(fold, "all")) + for (char *c = folded + (upper - path); *c; c++) if (*c >= 'A' && *c <= 'Z') *c += 'a' - 'A'; + path = folded; + } int r = next(path, st); if (r == 0) coarse(path, st); return r; @@ -61,6 +76,16 @@ int fstatfs(int fd, struct statfs *out) { return r; } +int inotify_add_watch(int fd, const char *path, uint32_t mask) { + static int (*next)(int, const char *, uint32_t); + if (!next) next = dlsym(RTLD_NEXT, "inotify_add_watch"); + if (getenv("NOFOLLOW_FAIL") && (mask & IN_DONT_FOLLOW)) { + errno = ENOSPC; + return -1; + } + return next(fd, path, mask); +} + int statfs(const char *path, struct statfs *out) { static int (*next)(const char *, struct statfs *); if (!next) next = dlsym(RTLD_NEXT, "statfs"); @@ -82,6 +107,13 @@ DIR *opendir(const char *path) { return next(path); } +int faccessat(int dirfd, const char *path, int mode, int flags) { + static int (*next)(int, const char *, int, int); + if (!next) next = dlsym(RTLD_NEXT, "faccessat"); + if (strstr(path, "/fuse/")) real_accesses++; + return next(dirfd, path, mode, flags); +} + DIR *fdopendir(int fd) { static DIR *(*next)(int); if (!next) next = dlsym(RTLD_NEXT, "fdopendir"); @@ -94,6 +126,7 @@ PROGRAM = r""" #define _GNU_SOURCE #include #include +#include #include #include #include @@ -171,6 +204,7 @@ static void stress(const char *dir) { int main(int argc, char **argv) { int *opens = dlsym(RTLD_DEFAULT, "real_opendirs"); + int *accesses = dlsym(RTLD_DEFAULT, "real_accesses"); for (int i = 1; i < argc; i++) { const char *op = argv[i], *a = argv[i + 1]; if (!strcmp(op, "list")) { list(a); i++; } @@ -178,6 +212,14 @@ int main(int argc, char **argv) { else if (!strcmp(op, "create")) { close(open(a, O_WRONLY | O_CREAT, 0644)); i++; } else if (!strcmp(op, "sneak")) { close((int)syscall(SYS_openat, AT_FDCWD, a, O_WRONLY | O_CREAT, 0644)); i++; } else if (!strcmp(op, "sneak-unlink")) { syscall(SYS_unlinkat, AT_FDCWD, a, 0); i++; } + else if (!strcmp(op, "sneak-rename")) { syscall(SYS_renameat, AT_FDCWD, a, AT_FDCWD, argv[i + 2]); i += 2; } + else if (!strcmp(op, "sneak-mkdir")) { syscall(SYS_mkdirat, AT_FDCWD, a, 0755); i++; } + else if (!strcmp(op, "pause")) { + char line[16]; + printf("ready\n"); + fflush(stdout); + if (!fgets(line, sizeof(line), stdin)) return 1; + } else if (!strcmp(op, "unlink")) { unlink(a); i++; } else if (!strcmp(op, "remove")) { remove(a); i++; } else if (!strcmp(op, "mkdir")) { mkdir(a, 0755); i++; } @@ -246,6 +288,12 @@ int main(int argc, char **argv) { waitpid(child, NULL, 0); i += 2; } + else if (!strcmp(op, "access")) { + int r = access(a, F_OK); + printf("%d %d\n", r, r ? errno : 0); + i++; + } + else if (!strcmp(op, "accesses")) printf("%d\n", accesses ? *accesses : -1); else if (!strcmp(op, "opens")) printf("%d\n", opens ? *opens : -1); } return 0; @@ -284,13 +332,39 @@ class DirCachePreloadTest(unittest.TestCase): for name in ("a.bundle", "b.bundle"): (self.staging / name).touch() - def run_program(self, *args, program=None, env=None): + def environment(self, env): environment = dict(os.environ, LD_PRELOAD="%s:%s" % (self.cache, self.fake)) environment.update(env or {}) - result = subprocess.run([str(program or self.steam), *map(str, args)], env=environment, + return environment + + def run_program(self, *args, program=None, env=None): + result = subprocess.run([str(program or self.steam), *map(str, args)], env=self.environment(env), capture_output=True, text=True, check=True, timeout=60) return result.stdout.splitlines() + def run_paused(self, *args, between, env=None): + probe = subprocess.Popen([str(self.steam), *map(str, args)], env=self.environment(env), text=True, + stdin=subprocess.PIPE, stdout=subprocess.PIPE) + timer = threading.Timer(60, probe.kill) + timer.start() + try: + before = [] + for line in probe.stdout: + if line == "ready\n": + break + before.append(line.rstrip("\n")) + else: + self.fail("the probe stopped before it was ready") + between() + after, _ = probe.communicate("go\n", timeout=60) + finally: + timer.cancel() + if probe.poll() is None: + probe.kill() + probe.communicate() + self.assertEqual(0, probe.returncode) + return before + after.splitlines() + def test_repeated_listings_read_the_directory_once(self): out = self.run_program("list", self.staging, "list", self.staging, "list", self.staging, "opens") self.assertEqual(["a.bundle,b.bundle"] * 3 + ["1"], out) @@ -399,6 +473,208 @@ class DirCachePreloadTest(unittest.TestCase): outside.mkdir() self.assertEqual("2", self.run_program("list", outside, "list", outside, "opens")[-1]) + def test_missing_names_are_answered_from_the_listing(self): + s = self.staging + out = self.run_program("list", s, "access", s / "x.bundle", "access", s / "y/z.bundle", + "access", s / "c.bundle", "accesses", "access", s / "a.bundle", "accesses", "opens") + self.assertEqual(["-1 2", "-1 2", "-1 2", "1", "0 0", "2", "1"], out[1:]) + + def test_a_name_that_differs_only_in_case_is_asked_of_the_filesystem(self): + s = self.staging + out = self.run_program("list", s, "access", s / "A.BUNDLE", "accesses") + self.assertEqual(["-1 2", "1"], out[1:]) + + def test_misses_before_the_client_lists_a_directory_reach_the_filesystem(self): + s = self.staging + out = self.run_program("access", s / "x.bundle", "access", s / "y.bundle", "accesses", "opens") + self.assertEqual(["-1 2", "-1 2", "2", "0"], out) + + def test_names_created_after_a_miss_are_found(self): + s = self.staging + out = self.run_program("list", s, "access", s / "x.bundle", "create", s / "x.bundle", "access", s / "x.bundle", + "access", s / "y.bundle", "sneak", s / "y.bundle", "access", s / "y.bundle", + "rename", s / "y.bundle", s / "w.bundle", "access", s / "w.bundle", + "mkdir", s / "sub", "access", s / "sub", + env={"COARSE": "1"}) + self.assertEqual(["-1 2", "0 0", "-1 2", "0 0", "0 0", "0 0"], out[1:]) + + def test_a_differently_cased_directory_reaches_the_filesystem_when_case_matters(self): + s = self.staging + upper = Path(str(s).replace("downloading", "DOWNLOADING")) + out = self.run_program("list", s, "access", upper / "x.bundle", "accesses") + self.assertEqual(["-1 2", "1"], out[1:]) + + def test_a_differently_cased_directory_uses_the_listing_when_the_filesystem_folds_case(self): + s = self.staging + upper = Path(str(s).replace("downloading", "DOWNLOADING")) + out = self.run_program("list", s, "access", upper / "x.bundle", "access", upper / "A.BUNDLE", "accesses", + env={"FOLD": "all"}) + self.assertEqual(["-1 2", "-1 2", "1"], out[1:]) + + def test_a_case_sensitive_folder_below_a_folding_steamapps_reaches_the_filesystem(self): + s = self.staging + upper = self.lib / "DOWNLOADING" / s.name + upper.mkdir(parents=True) + (upper / "x.bundle").write_bytes(b"") + out = self.run_program("list", s, "access", upper / "x.bundle", "access", upper / "y.bundle", "accesses", + env={"FOLD": "1"}) + self.assertEqual(["0 0", "-1 2", "2"], out[1:]) + + def test_a_differently_cased_folder_above_steamapps_reaches_the_filesystem(self): + s = self.staging + top = self.lib.parent.parent + other = top.parent / top.name.swapcase() / s.relative_to(top) + self.assertNotEqual(top.name, top.name.swapcase()) + other.mkdir(parents=True) + (other / "x.bundle").write_bytes(b"") + out = self.run_program("list", s, "access", other / "x.bundle", "accesses", env={"FOLD": "all"}) + self.assertEqual(["0 0", "1"], out[1:]) + + def test_a_differently_cased_sibling_of_a_folded_listing_reaches_the_filesystem(self): + s = self.staging + (self.lib.parent / "STEAMAPPS").symlink_to("steamapps") + (self.lib / "DOWNLOADING").symlink_to("downloading") + other = self.lib / "Downloading" / s.name + other.mkdir(parents=True) + (other / "x.bundle").touch() + out = self.run_program("list", s, "access", other / "x.bundle", "accesses") + self.assertEqual("0 0", out[1]) + + def test_a_listing_is_dropped_when_a_folder_above_it_is_renamed(self): + s = self.staging + parent = s.parent + moved = parent.parent / "downloading.old" + out = self.run_program("list", s, "rename", parent, moved, "mkdir", parent, "mkdir", s, + "sneak", s / "x.bundle", "access", s / "x.bundle", "accesses") + self.assertEqual(["0 0", "1"], out[1:]) + + def test_a_listing_is_dropped_when_another_process_renames_a_folder_above_it(self): + s = self.staging + parent = s.parent + + def swap(): + parent.rename(parent.parent / "downloading.old") + s.mkdir(parents=True) + (s / "x.bundle").touch() + + out = self.run_paused("list", s, "pause", "access", s / "x.bundle", "accesses", between=swap) + self.assertEqual(["0 0", "1"], out[1:]) + + def test_a_listing_is_dropped_when_another_process_renames_the_library_above_steamapps(self): + s = self.staging + root = self.lib.parent + + def swap(): + root.rename(root.parent / "fuse.old") + s.mkdir(parents=True) + (s / "x.bundle").touch() + + out = self.run_paused("list", s, "pause", "access", s / "x.bundle", "accesses", between=swap) + self.assertEqual(["0 0", "1"], out[1:]) + + def test_a_repointed_symlink_above_a_listing_does_not_hide_files(self): + s = self.staging + real = self.lib / "dl-a" + s.parent.rename(real) + s.parent.symlink_to(real.name) + other = self.lib / "dl-b" / s.name + other.mkdir(parents=True) + (other / "x.bundle").touch() + + def repoint(): + link = self.lib / "downloading.new" + link.symlink_to("dl-b") + link.replace(s.parent) + + out = self.run_paused("list", s, "pause", "access", s / "x.bundle", between=repoint) + self.assertEqual("0 0", out[1]) + + def test_a_symlink_check_that_cannot_be_watched_does_not_hide_files(self): + s = self.staging + real = self.lib / "dl-a" + s.parent.rename(real) + s.parent.symlink_to(real.name) + other = self.lib / "dl-b" / s.name + other.mkdir(parents=True) + (other / "x.bundle").touch() + + def repoint(): + link = self.lib / "downloading.new" + link.symlink_to("dl-b") + link.replace(s.parent) + + out = self.run_paused("list", s, "pause", "access", s / "x.bundle", between=repoint, env={"NOFOLLOW_FAIL": "1"}) + self.assertEqual("0 0", out[1]) + + def test_an_unreadable_folder_above_steamapps_does_not_hide_files(self): + s = self.staging + root = self.lib.parent + moved = root.parent / "fuse.old" + root.chmod(0o311) + self.addCleanup(lambda: moved.chmod(0o755) if moved.exists() else root.chmod(0o755)) + if os.access(root, os.R_OK): + self.skipTest("folder permissions are not enforced here") + + def swap(): + root.rename(moved) + s.mkdir(parents=True) + (s / "x.bundle").touch() + + out = self.run_paused("list", s, "pause", "access", s / "x.bundle", between=swap) + self.assertEqual("0 0", out[1]) + + def test_a_listing_is_dropped_when_another_process_removes_a_folder_above_it(self): + deep = self.staging / "deep" + deep.mkdir() + parent = self.staging.parent + + def swap(): + self.staging.rename(self.lib / "moved") + parent.rmdir() + deep.mkdir(parents=True) + (deep / "x.bundle").touch() + + out = self.run_paused("list", deep, "pause", "access", deep / "x.bundle", "accesses", between=swap) + self.assertEqual(["", "0 0", "1"], out) + + def test_a_listing_is_dropped_when_a_folder_above_it_is_renamed_around_the_cache(self): + s = self.staging + parent = s.parent + out = self.run_program("list", s, "sneak-rename", parent, parent.parent / "downloading.old", + "sneak-mkdir", parent, "sneak-mkdir", s, "sneak", s / "x.bundle", + "access", s / "x.bundle", "accesses") + self.assertEqual(["0 0", "1"], out[1:]) + + def test_changes_in_a_cached_folder_above_keep_the_listing_below(self): + s = self.staging + parent = s.parent + + def churn(): + (parent / "z").touch() + (parent / "z").unlink() + (parent / "sibling").mkdir() + (parent / "sibling").rmdir() + + out = self.run_paused("list", parent, "list", s, "pause", "list", parent, "list", s, + "access", s / "x.bundle", "accesses", "opens", between=churn) + self.assertEqual([s.name, "a.bundle,b.bundle", s.name, "a.bundle,b.bundle", "-1 2", "0", "3"], out) + + def test_misses_outside_the_client_or_fuse_steamapps_reach_the_filesystem(self): + s = self.staging + other = self.run_program("list", s, "access", s / "x.bundle", "access", s / "y.bundle", "accesses", + program=self.other) + self.assertEqual(["-1 2", "-1 2", "2"], other[1:]) + outside = self.lib.parent / "elsewhere" + outside.mkdir() + out = self.run_program("list", outside, "access", outside / "x", "access", outside / "y", "accesses") + self.assertEqual(["-1 2", "-1 2", "2"], out[1:]) + + def test_misses_reach_the_filesystem_when_turned_off(self): + s = self.staging + out = self.run_program("list", s, "access", s / "x.bundle", "access", s / "y.bundle", "accesses", + env={"BL_NO_DIR_CACHE": "1"}) + self.assertEqual(["-1 2", "-1 2", "2"], out[1:]) + def test_can_be_turned_off(self): out = self.run_program("list", self.staging, "list", self.staging, "opens", env={"BL_NO_DIR_CACHE": "1"}) self.assertEqual("2", out[-1])