| // SPDX-License-Identifier: GPL-2.0 | |
| #define _GNU_SOURCE | |
| #define __SANE_USERSPACE_TYPES__ | |
| #include <dirent.h> | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <limits.h> | |
| #include <net/if.h> | |
| #include <sched.h> | |
| #include <signal.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <time.h> | |
| #include <unistd.h> | |
| #include <sys/ioctl.h> | |
| #include <sys/mount.h> | |
| #include <sys/socket.h> | |
| #include <sys/stat.h> | |
| #include <sys/syscall.h> | |
| #include <sys/xattr.h> | |
| #include "kselftest_harness.h" | |
| #include "wrappers.h" | |
| TEST(kernfs_listxattr) | |
| { | |
| ssize_t len; | |
| int fd; | |
| /* Read-only file that can never have any extended attributes set. | |
| * However, on systems with SELinux enabled, security.selinux xattr | |
| * may be present. Skip the content check if any xattrs are found. | |
| */ | |
| fd = open("/sys/kernel/warn_count", O_RDONLY | O_CLOEXEC); | |
| ASSERT_GE(fd, 0); | |
| len = flistxattr(fd, NULL, 0); | |
| ASSERT_GE(len, 0); | |
| if (len > 0) { | |
| close(fd); | |
| SKIP(return, "xattrs present on /sys/kernel/warn_count, skipping xattr content check"); | |
| } | |
| EXPECT_EQ(close(fd), 0); | |
| } | |
| TEST(kernfs_getxattr) | |
| { | |
| int fd; | |
| char buf[1]; | |
| /* Read-only file that can never have any extended attributes set. */ | |
| fd = open("/sys/kernel/warn_count", O_RDONLY | O_CLOEXEC); | |
| ASSERT_GE(fd, 0); | |
| ASSERT_LT(fgetxattr(fd, "user.foo", buf, sizeof(buf)), 0); | |
| ASSERT_EQ(errno, ENODATA); | |
| EXPECT_EQ(close(fd), 0); | |
| } | |
| /* | |
| * Exercise the kernfs dentry cache: lookup, revalidation of positive and | |
| * negative dentries, readdir and namespace tagging. | |
| * | |
| * These drive kernfs from kernel context rather than VFS create/unlink, | |
| * which is what ->d_revalidate() exists for: writing cgroup.subtree_control | |
| * adds and removes files in every child cgroup with no VFS operation | |
| * touching those names. | |
| */ | |
| #define CG_SCRATCH "kernfs_selftest" | |
| #define TEST_IFNAME "kfstest0" | |
| /* | |
| * Controllers that add a file to each child cgroup when enabled. The probe | |
| * file must be owned by the controller: cgroup_base_files[] entries such as | |
| * cpu.stat exist in every cgroup regardless, and every file the cpu | |
| * controller does own is behind a Kconfig symbol, so cpu is not usable here. | |
| */ | |
| static const struct { | |
| const char *name; | |
| const char *probe_file; | |
| } controllers[] = { | |
| { "memory", "memory.current" }, | |
| { "pids", "pids.current" }, | |
| }; | |
| static int find_cgroup2_root(char *buf, size_t len) | |
| { | |
| char line[PATH_MAX * 2]; | |
| FILE *f; | |
| int ret = -1; | |
| f = fopen("/proc/self/mounts", "re"); | |
| if (!f) | |
| return -1; | |
| while (fgets(line, sizeof(line), f)) { | |
| char mnt[PATH_MAX], type[64]; | |
| /* Octal escaping can expand a path fourfold; bound both %s. */ | |
| if (sscanf(line, "%*s %4095s %63s", mnt, type) != 2) | |
| continue; | |
| if (strcmp(type, "cgroup2")) | |
| continue; | |
| if (strlen(mnt) >= len) | |
| break; | |
| strcpy(buf, mnt); | |
| ret = 0; | |
| break; | |
| } | |
| fclose(f); | |
| return ret; | |
| } | |
| static int write_file(const char *path, const char *val) | |
| { | |
| ssize_t len = strlen(val); | |
| int fd, ret; | |
| fd = open(path, O_WRONLY | O_CLOEXEC); | |
| if (fd < 0) | |
| return -1; | |
| ret = write(fd, val, len) == len ? 0 : -1; | |
| close(fd); | |
| return ret; | |
| } | |
| static bool file_has_word(const char *path, const char *word) | |
| { | |
| char buf[4096], *tok, *save; | |
| bool found = false; | |
| ssize_t n; | |
| int fd; | |
| fd = open(path, O_RDONLY | O_CLOEXEC); | |
| if (fd < 0) | |
| return false; | |
| n = read(fd, buf, sizeof(buf) - 1); | |
| close(fd); | |
| if (n < 0) | |
| return false; | |
| buf[n] = '\0'; | |
| for (tok = strtok_r(buf, "\n ", &save); tok; | |
| tok = strtok_r(NULL, "\n ", &save)) { | |
| if (!strcmp(tok, word)) { | |
| found = true; | |
| break; | |
| } | |
| } | |
| return found; | |
| } | |
| static bool path_is_mounted(const char *path) | |
| { | |
| char line[PATH_MAX * 2]; | |
| bool found = false; | |
| FILE *f; | |
| f = fopen("/proc/self/mounts", "re"); | |
| if (!f) | |
| return false; | |
| while (fgets(line, sizeof(line), f)) { | |
| char mnt[PATH_MAX]; | |
| if (sscanf(line, "%*s %4095s", mnt) != 1) | |
| continue; | |
| if (!strcmp(mnt, path)) { | |
| found = true; | |
| break; | |
| } | |
| } | |
| fclose(f); | |
| return found; | |
| } | |
| /* Shared by the stress tests below. */ | |
| static bool stress_deadline(const struct timespec *end) | |
| { | |
| struct timespec now; | |
| clock_gettime(CLOCK_MONOTONIC, &now); | |
| return now.tv_sec > end->tv_sec || | |
| (now.tv_sec == end->tv_sec && now.tv_nsec >= end->tv_nsec); | |
| } | |
| FIXTURE(kernfs_cgroup) | |
| { | |
| char scratch[PATH_MAX]; /* <cg2>/kernfs_selftest.<pid> */ | |
| char child[PATH_MAX]; /* <scratch>/child */ | |
| char probe[PATH_MAX]; /* child's controller file */ | |
| char scratch_sc[PATH_MAX]; /* scratch's cgroup.subtree_control */ | |
| char root_sc[PATH_MAX]; /* root's cgroup.subtree_control */ | |
| char enable[32]; /* "+<controller>" */ | |
| char disable[32]; /* "-<controller>" */ | |
| char mnt[PATH_MAX]; /* our own mount, if we made one */ | |
| bool mounted; | |
| bool enabled_at_root; | |
| }; | |
| /* A cgroup stays busy briefly after its last task exits. */ | |
| static void rmdir_retry(const char *path) | |
| { | |
| int i; | |
| for (i = 0; i < 500; i++) { | |
| if (!rmdir(path) || errno != EBUSY) | |
| return; | |
| usleep(10000); | |
| } | |
| } | |
| /* | |
| * Undo whatever SETUP managed to do. The harness skips TEARDOWN after a | |
| * failed or skipped SETUP, so SETUP must call this before returning early. | |
| */ | |
| static void kernfs_cgroup_undo(FIXTURE_DATA(kernfs_cgroup) *self) | |
| { | |
| rmdir_retry(self->child); | |
| rmdir(self->scratch); | |
| if (self->enabled_at_root) | |
| write_file(self->root_sc, self->disable); | |
| if (self->mounted) { | |
| umount2(self->mnt, MNT_DETACH); | |
| rmdir(self->mnt); | |
| } | |
| self->enabled_at_root = false; | |
| self->mounted = false; | |
| } | |
| FIXTURE_SETUP(kernfs_cgroup) | |
| { | |
| char root[PATH_MAX], ctl[PATH_MAX]; | |
| const char *probe_file = NULL; | |
| size_t i; | |
| if (geteuid()) | |
| SKIP(return, "test needs to run as root"); | |
| /* | |
| * A private mount namespace stops our mounts leaking, but does not | |
| * isolate the cgroup hierarchy: cgroup2 has one default hierarchy | |
| * however many times it is mounted. The scratch cgroups live in the | |
| * host's and must be removed, not discarded with the namespace. | |
| */ | |
| if (unshare(CLONE_NEWNS)) | |
| SKIP(return, "unshare(CLONE_NEWNS): %s", strerror(errno)); | |
| if (mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL)) | |
| SKIP(return, "make / private: %s", strerror(errno)); | |
| /* Use an existing cgroup2 mount if there is one, else make our own. */ | |
| if (find_cgroup2_root(root, sizeof(root))) { | |
| strcpy(self->mnt, "/tmp/kernfs_selftest_cg2.XXXXXX"); | |
| if (!mkdtemp(self->mnt)) | |
| SKIP(return, "mkdtemp: %s", strerror(errno)); | |
| if (mount("none", self->mnt, "cgroup2", 0, NULL)) { | |
| rmdir(self->mnt); | |
| SKIP(return, "mount cgroup2: %s", strerror(errno)); | |
| } | |
| self->mounted = true; | |
| strcpy(root, self->mnt); | |
| } | |
| snprintf(self->root_sc, sizeof(self->root_sc), | |
| "%s/cgroup.subtree_control", root); | |
| snprintf(ctl, sizeof(ctl), "%s/cgroup.controllers", root); | |
| /* Named after our pid so we cannot collide with anything else. */ | |
| snprintf(self->scratch, sizeof(self->scratch), "%s/%s.%d", root, | |
| CG_SCRATCH, getpid()); | |
| snprintf(self->child, sizeof(self->child), "%s/child", self->scratch); | |
| snprintf(self->scratch_sc, sizeof(self->scratch_sc), | |
| "%s/cgroup.subtree_control", self->scratch); | |
| for (i = 0; i < ARRAY_SIZE(controllers); i++) { | |
| if (!file_has_word(ctl, controllers[i].name)) | |
| continue; | |
| snprintf(self->enable, sizeof(self->enable), "+%s", | |
| controllers[i].name); | |
| snprintf(self->disable, sizeof(self->disable), "-%s", | |
| controllers[i].name); | |
| probe_file = controllers[i].probe_file; | |
| /* | |
| * A controller must be in the root's subtree_control before | |
| * it appears in our scratch cgroup. Note if we enabled it, | |
| * so it can be put back. | |
| */ | |
| self->enabled_at_root = !file_has_word(self->root_sc, | |
| controllers[i].name); | |
| if (self->enabled_at_root && | |
| write_file(self->root_sc, self->enable)) { | |
| self->enabled_at_root = false; | |
| probe_file = NULL; | |
| continue; | |
| } | |
| break; | |
| } | |
| if (!probe_file) { | |
| kernfs_cgroup_undo(self); | |
| SKIP(return, "no usable cgroup2 controller"); | |
| } | |
| snprintf(self->probe, sizeof(self->probe), "%s/%s", self->child, | |
| probe_file); | |
| /* | |
| * Only an unusable environment may skip. A scratch cgroup named | |
| * after our own pid should always be creatable, so failing to make | |
| * one is a result -- skipping would let a broken kernel look green. | |
| */ | |
| if (mkdir(self->scratch, 0755)) { | |
| int err = errno; | |
| kernfs_cgroup_undo(self); | |
| if (err == EROFS || err == EACCES || err == EPERM) | |
| SKIP(return, "mkdir %s: %s", self->scratch, | |
| strerror(err)); | |
| ASSERT_EQ(err, 0) TH_LOG("mkdir %s: %s", self->scratch, | |
| strerror(err)); | |
| } | |
| if (mkdir(self->child, 0755)) { | |
| int err = errno; | |
| kernfs_cgroup_undo(self); | |
| ASSERT_EQ(err, 0) TH_LOG("mkdir %s: %s", self->child, | |
| strerror(err)); | |
| } | |
| /* | |
| * The tests below need the probe file to appear and disappear with | |
| * the controller, so it must be absent now, before anything enables | |
| * it in the scratch cgroup. Skip rather than fail: a probe file that | |
| * is already there means the table names one the controller does not | |
| * own, not that the kernel is broken. | |
| */ | |
| if (!access(self->probe, F_OK)) { | |
| kernfs_cgroup_undo(self); | |
| SKIP(return, "%s is not owned by the %s controller", | |
| probe_file, self->enable + 1); | |
| } | |
| } | |
| FIXTURE_TEARDOWN(kernfs_cgroup) | |
| { | |
| write_file(self->scratch_sc, self->disable); | |
| kernfs_cgroup_undo(self); | |
| } | |
| /* | |
| * Walking already-cached dentries must not invalidate them. Spurious | |
| * invalidation is not merely slow: d_invalidate() calls detach_mounts(), so | |
| * an unrelated lookup would silently tear down any mount below. | |
| */ | |
| TEST_F(kernfs_cgroup, path_walk_does_not_invalidate) | |
| { | |
| char src[] = "/tmp/kernfs_selftest_bind.XXXXXX"; | |
| char sub[PATH_MAX], probe[PATH_MAX]; | |
| int i; | |
| snprintf(sub, sizeof(sub), "%s/sub", self->child); | |
| ASSERT_EQ(mkdir(sub, 0755), 0); | |
| if (!mkdtemp(src)) { | |
| rmdir(sub); | |
| SKIP(return, "mkdtemp: %s", strerror(errno)); | |
| } | |
| if (mount(src, sub, NULL, MS_BIND, NULL)) { | |
| int err = errno; | |
| rmdir(sub); | |
| rmdir(src); | |
| SKIP(return, "bind mount onto a cgroup dir: %s", strerror(err)); | |
| } | |
| ASSERT_TRUE(path_is_mounted(sub)); | |
| /* Walk a sibling path through the same directory, repeatedly. */ | |
| snprintf(probe, sizeof(probe), "%s/cgroup.procs", self->child); | |
| for (i = 0; i < 8; i++) { | |
| int fd = open(probe, O_RDONLY | O_CLOEXEC); | |
| if (fd >= 0) | |
| close(fd); | |
| } | |
| EXPECT_TRUE(path_is_mounted(sub)); | |
| umount2(sub, MNT_DETACH); | |
| rmdir(sub); | |
| rmdir(src); | |
| } | |
| /* | |
| * A cached negative dentry must be invalidated when the kernel creates the | |
| * name behind the dcache's back. That is what kernfs_dir_changed() and | |
| * kernfs_elem_dir::rev are for. | |
| */ | |
| TEST_F(kernfs_cgroup, negative_dentry_invalidated_by_kernel_create) | |
| { | |
| struct stat st; | |
| /* Caches a negative dentry for the probe file. */ | |
| ASSERT_EQ(stat(self->probe, &st), -1); | |
| ASSERT_EQ(errno, ENOENT); | |
| /* The kernel now creates it, with no VFS operation on that name. */ | |
| ASSERT_EQ(write_file(self->scratch_sc, self->enable), 0); | |
| EXPECT_EQ(stat(self->probe, &st), 0); | |
| } | |
| /* The mirror image: a cached positive dentry must go when the node does. */ | |
| TEST_F(kernfs_cgroup, positive_dentry_invalidated_by_kernel_remove) | |
| { | |
| struct stat st; | |
| ASSERT_EQ(write_file(self->scratch_sc, self->enable), 0); | |
| /* Caches a positive dentry. */ | |
| ASSERT_EQ(stat(self->probe, &st), 0); | |
| ASSERT_EQ(write_file(self->scratch_sc, self->disable), 0); | |
| ASSERT_EQ(stat(self->probe, &st), -1); | |
| EXPECT_EQ(errno, ENOENT); | |
| } | |
| /* Opening a removed node fails; it never returns stale content. */ | |
| TEST_F(kernfs_cgroup, open_after_rmdir_fails) | |
| { | |
| char path[PATH_MAX]; | |
| char buf[64]; | |
| int fd; | |
| snprintf(path, sizeof(path), "%s/cgroup.procs", self->child); | |
| fd = open(path, O_RDONLY | O_CLOEXEC); | |
| ASSERT_GE(fd, 0); | |
| ASSERT_EQ(rmdir(self->child), 0); | |
| /* Lookup by path must fail. */ | |
| EXPECT_EQ(open(path, O_RDONLY | O_CLOEXEC), -1); | |
| EXPECT_EQ(errno, ENOENT); | |
| /* | |
| * An fd held across removal must fail rather than return stale | |
| * content. rmdir() deactivates the node before it returns, so | |
| * kernfs_seq_start() fails to get an active reference. | |
| */ | |
| EXPECT_LT(read(fd, buf, sizeof(buf)), 0); | |
| EXPECT_EQ(errno, ENODEV); | |
| EXPECT_EQ(close(fd), 0); | |
| ASSERT_EQ(mkdir(self->child, 0755), 0); | |
| } | |
| /* readdir returns every entry exactly once. */ | |
| TEST_F(kernfs_cgroup, readdir_no_duplicates) | |
| { | |
| char names[512][NAME_MAX + 1]; | |
| struct dirent *de; | |
| int n = 0, i, j; | |
| DIR *d; | |
| ASSERT_EQ(write_file(self->scratch_sc, self->enable), 0); | |
| d = opendir(self->child); | |
| ASSERT_NE(d, NULL); | |
| while ((de = readdir(d))) { | |
| if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) | |
| continue; | |
| ASSERT_LT(n, (int)ARRAY_SIZE(names)); | |
| strncpy(names[n], de->d_name, NAME_MAX); | |
| names[n][NAME_MAX] = '\0'; | |
| n++; | |
| } | |
| closedir(d); | |
| ASSERT_GT(n, 0); | |
| for (i = 0; i < n; i++) | |
| for (j = i + 1; j < n; j++) | |
| EXPECT_STRNE(names[i], names[j]); | |
| } | |
| #define RESUME_DIRS 24 | |
| /* | |
| * Resuming at an entry that has gone must carry on after it, never before. | |
| * Take a cookie for every entry, then remove each one, seek to its cookie | |
| * and read the rest; nothing already reported may come back. | |
| */ | |
| TEST_F(kernfs_cgroup, readdir_resume_at_removed_entry) | |
| { | |
| /* The cgroup's own control files are listed alongside ours. */ | |
| char names[128][NAME_MAX + 1]; | |
| long pos[128]; | |
| char path[PATH_MAX]; | |
| struct dirent *de; | |
| int n = 0, i, j; | |
| DIR *d; | |
| for (i = 0; i < RESUME_DIRS; i++) { | |
| snprintf(path, sizeof(path), "%s/e%02d", self->scratch, i); | |
| ASSERT_EQ(mkdir(path, 0755), 0); | |
| } | |
| /* Record the cookie before reading each entry, with its name. */ | |
| d = opendir(self->scratch); | |
| ASSERT_NE(d, NULL); | |
| while (1) { | |
| long here = telldir(d); | |
| de = readdir(d); | |
| if (!de) | |
| break; | |
| if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) | |
| continue; | |
| ASSERT_LT(n, (int)ARRAY_SIZE(pos)); | |
| pos[n] = here; | |
| strncpy(names[n], de->d_name, NAME_MAX); | |
| names[n][NAME_MAX] = '\0'; | |
| n++; | |
| } | |
| closedir(d); | |
| ASSERT_GT(n, 1); | |
| for (i = 0; i < n; i++) { | |
| /* Only the directories we made can be removed and put back. */ | |
| if (strncmp(names[i], "e", 1)) | |
| continue; | |
| snprintf(path, sizeof(path), "%s/%s", self->scratch, names[i]); | |
| ASSERT_EQ(rmdir(path), 0); | |
| /* Reopen so the seek has to reach the kernel. */ | |
| d = opendir(self->scratch); | |
| ASSERT_NE(d, NULL); | |
| seekdir(d, pos[i]); | |
| while ((de = readdir(d))) { | |
| if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) | |
| continue; | |
| for (j = 0; j < i; j++) | |
| ASSERT_STRNE(de->d_name, names[j]) | |
| TH_LOG("resuming at %s (gone) went back to %s", | |
| names[i], names[j]); | |
| } | |
| closedir(d); | |
| ASSERT_EQ(mkdir(path, 0755), 0); | |
| } | |
| for (i = 0; i < RESUME_DIRS; i++) { | |
| snprintf(path, sizeof(path), "%s/e%02d", self->scratch, i); | |
| EXPECT_EQ(rmdir(path), 0); | |
| } | |
| } | |
| #define CHURN_ROUNDS 400 | |
| #define CHURN_BUFSZ 512 /* small, so a listing takes several calls */ | |
| /* | |
| * The files appear at the end of the enabling write and go at the start of | |
| * the disabling one, so the window where they exist is the short one. | |
| */ | |
| #define CHURN_DWELL_ON 2000 | |
| #define CHURN_DWELL_OFF 200 | |
| struct kernfs_dirent64 { | |
| unsigned long long d_ino; | |
| long long d_off; | |
| unsigned short d_reclen; | |
| unsigned char d_type; | |
| char d_name[]; | |
| }; | |
| /* | |
| * The same resume, but inside one getdents(2) call. rmdir(2) cannot reach | |
| * that window because iterate_dir() holds the listed directory's i_rwsem | |
| * for the whole listing; cgroup.subtree_control can, having no VFS | |
| * operation on the names it adds and removes. The files that are not the | |
| * controller's stay throughout, so each must appear exactly once. | |
| * | |
| * A stress test: it has not been seen to catch the ordering bug, and is | |
| * here to keep the unlocked window under load for lockdep and KASAN. | |
| */ | |
| TEST_F(kernfs_cgroup, readdir_resume_vs_internal_remove) | |
| { | |
| char buf[CHURN_BUFSZ] __attribute__((aligned(8))); | |
| char stable[128][NAME_MAX + 1]; | |
| int nstable = 0, i, r; | |
| int withctl = 0, without = 0; | |
| int seen[128], status; | |
| pid_t churner; | |
| DIR *d; | |
| /* With the controller off, whatever is left is what must persist. */ | |
| ASSERT_EQ(write_file(self->scratch_sc, self->disable), 0); | |
| d = opendir(self->child); | |
| ASSERT_NE(d, NULL); | |
| for (;;) { | |
| struct dirent *de = readdir(d); | |
| if (!de) | |
| break; | |
| if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) | |
| continue; | |
| ASSERT_LT(nstable, (int)ARRAY_SIZE(stable)); | |
| strncpy(stable[nstable], de->d_name, NAME_MAX); | |
| stable[nstable][NAME_MAX] = '\0'; | |
| nstable++; | |
| } | |
| closedir(d); | |
| ASSERT_GT(nstable, 0); | |
| churner = fork(); | |
| ASSERT_GE(churner, 0); | |
| if (churner == 0) { | |
| for (;;) { | |
| if (write_file(self->scratch_sc, self->enable)) | |
| _exit(10); | |
| usleep(CHURN_DWELL_ON); | |
| if (write_file(self->scratch_sc, self->disable)) | |
| _exit(11); | |
| usleep(CHURN_DWELL_OFF); | |
| } | |
| } | |
| for (r = 0; r < CHURN_ROUNDS; r++) { | |
| int fd = open(self->child, O_RDONLY | O_DIRECTORY); | |
| int extra = 0; | |
| int n; | |
| ASSERT_GE(fd, 0); | |
| memset(seen, 0, sizeof(seen)); | |
| while ((n = syscall(SYS_getdents64, fd, buf, sizeof(buf))) > 0) { | |
| int off = 0; | |
| while (off < n) { | |
| struct kernfs_dirent64 *de = (void *)(buf + off); | |
| bool known = false; | |
| off += de->d_reclen; | |
| for (i = 0; i < nstable; i++) | |
| if (!strcmp(de->d_name, stable[i])) { | |
| seen[i]++; | |
| known = true; | |
| } | |
| if (!known && strcmp(de->d_name, ".") && | |
| strcmp(de->d_name, "..")) | |
| extra++; | |
| } | |
| } | |
| ASSERT_GE(n, 0); | |
| EXPECT_EQ(close(fd), 0); | |
| if (extra) | |
| withctl++; | |
| else | |
| without++; | |
| for (i = 0; i < nstable; i++) | |
| ASSERT_EQ(seen[i], 1) | |
| TH_LOG("round %d: %s seen %d times", | |
| r, stable[i], seen[i]); | |
| } | |
| /* The churn must have been running, or the listings prove nothing. */ | |
| EXPECT_EQ(kill(churner, SIGKILL), 0); | |
| ASSERT_EQ(waitpid(churner, &status, 0), churner); | |
| ASSERT_TRUE(WIFSIGNALED(status) && WTERMSIG(status) == SIGKILL) | |
| TH_LOG("churner exited on its own: status %d", status); | |
| /* | |
| * They also have to have overlapped it. How much depends on the | |
| * machine, so say the race could not be arranged rather than fail. | |
| */ | |
| if (!withctl || !without) | |
| SKIP(return, "listings did not span the churn: %d with, %d without", | |
| withctl, without); | |
| } | |
| /* | |
| * A telldir() cookie must resolve back to the same entry after seekdir(). | |
| * kernfs encodes the cookie as the node's name hash, so this covers | |
| * kernfs_dir_pos() as well as plain iteration. | |
| */ | |
| TEST_F(kernfs_cgroup, readdir_seekdir_roundtrip) | |
| { | |
| char names[512][NAME_MAX + 1]; | |
| struct dirent *de; | |
| long pos[512]; | |
| int n = 0, i; | |
| DIR *d; | |
| ASSERT_EQ(write_file(self->scratch_sc, self->enable), 0); | |
| d = opendir(self->child); | |
| ASSERT_NE(d, NULL); | |
| /* Record the cookie *before* reading each entry, with its name. */ | |
| while (1) { | |
| long here = telldir(d); | |
| de = readdir(d); | |
| if (!de) | |
| break; | |
| if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) | |
| continue; | |
| ASSERT_LT(n, (int)ARRAY_SIZE(pos)); | |
| pos[n] = here; | |
| strncpy(names[n], de->d_name, NAME_MAX); | |
| names[n][NAME_MAX] = '\0'; | |
| n++; | |
| } | |
| ASSERT_GT(n, 0); | |
| /* Seeking back to a cookie must land on the entry it was taken at. */ | |
| for (i = 0; i < n; i++) { | |
| seekdir(d, pos[i]); | |
| de = readdir(d); | |
| ASSERT_NE(de, NULL); | |
| EXPECT_STREQ(de->d_name, names[i]); | |
| } | |
| closedir(d); | |
| } | |
| #define STRESS_SECS 2 | |
| #define STRESS_DIRS 4 | |
| #define STRESS_READERS 4 | |
| /* | |
| * Hammer lookup against creation and removal. Revalidation holds no lock | |
| * against the writers, so what makes it safe is that every answer it can | |
| * give is one the caller already handles: a reader must only ever see | |
| * success or an errno meaning "it went away", never garbage or a hang. | |
| */ | |
| TEST_F(kernfs_cgroup, lookup_vs_create_remove_stress) | |
| { | |
| pid_t pids[STRESS_DIRS + STRESS_READERS]; | |
| struct timespec end; | |
| int i, status, n = 0; | |
| clock_gettime(CLOCK_MONOTONIC, &end); | |
| end.tv_sec += STRESS_SECS; | |
| for (i = 0; i < STRESS_DIRS; i++) { | |
| pid_t pid = fork(); | |
| ASSERT_GE(pid, 0); | |
| if (pid == 0) { | |
| char dir[PATH_MAX]; | |
| snprintf(dir, sizeof(dir), "%s/s%d", self->scratch, i); | |
| while (!stress_deadline(&end)) { | |
| if (mkdir(dir, 0755) && errno != EEXIST) | |
| _exit(10); | |
| if (rmdir(dir) && errno != ENOENT && | |
| errno != EBUSY) | |
| _exit(11); | |
| } | |
| _exit(0); | |
| } | |
| pids[n++] = pid; | |
| } | |
| for (i = 0; i < STRESS_READERS; i++) { | |
| pid_t pid = fork(); | |
| ASSERT_GE(pid, 0); | |
| if (pid == 0) { | |
| /* Start each reader on a different directory. */ | |
| unsigned int seq = i; | |
| while (!stress_deadline(&end)) { | |
| int which = seq++ % STRESS_DIRS; | |
| char path[PATH_MAX]; | |
| struct stat st; | |
| int fd; | |
| snprintf(path, sizeof(path), | |
| "%s/s%d/cgroup.procs", | |
| self->scratch, which); | |
| if (stat(path, &st) && errno != ENOENT && | |
| errno != ENODEV) | |
| _exit(20); | |
| fd = open(path, O_RDONLY | O_CLOEXEC); | |
| if (fd < 0) { | |
| if (errno != ENOENT && errno != ENODEV) | |
| _exit(21); | |
| } else { | |
| close(fd); | |
| } | |
| if (access(path, F_OK) && errno != ENOENT && | |
| errno != ENODEV) | |
| _exit(22); | |
| } | |
| _exit(0); | |
| } | |
| pids[n++] = pid; | |
| } | |
| for (i = 0; i < n; i++) { | |
| ASSERT_EQ(waitpid(pids[i], &status, 0), pids[i]); | |
| ASSERT_TRUE(WIFEXITED(status)); | |
| EXPECT_EQ(WEXITSTATUS(status), 0); | |
| } | |
| for (i = 0; i < STRESS_DIRS; i++) { | |
| char dir[PATH_MAX]; | |
| snprintf(dir, sizeof(dir), "%s/s%d", self->scratch, i); | |
| rmdir_retry(dir); | |
| } | |
| } | |
| struct kernfs_handle { | |
| struct file_handle h; | |
| unsigned char buf[MAX_HANDLE_SZ]; | |
| }; | |
| static int kernfs_encode(const char *path, struct kernfs_handle *fh) | |
| { | |
| int mount_id; | |
| memset(fh, 0, sizeof(*fh)); | |
| fh->h.handle_bytes = sizeof(fh->buf); | |
| return name_to_handle_at(AT_FDCWD, path, &fh->h, &mount_id, 0); | |
| } | |
| /* | |
| * Skip only where file handles do not work at all. ENOENT must still | |
| * fail: mkdir leaves a negative dentry cached, so the name resolves only | |
| * after ->d_revalidate() drops it. The encode tests revalidation too. | |
| */ | |
| static bool fh_unsupported(int err) | |
| { | |
| return err == EOPNOTSUPP || err == EPERM || err == ENOSYS; | |
| } | |
| /* | |
| * Decoding a file needs CAP_DAC_READ_SEARCH in the initial user | |
| * namespace. Probe once so the tests skip instead of fail. | |
| */ | |
| static bool fh_can_decode(int mfd, struct kernfs_handle *fh) | |
| { | |
| int fd = open_by_handle_at(mfd, &fh->h, O_PATH); | |
| if (fd < 0) | |
| return errno != EPERM; | |
| close(fd); | |
| return true; | |
| } | |
| /* | |
| * A file handle reaches a node without a lookup through its parent. A | |
| * live node must decode. A removed one must not, because | |
| * kernfs_find_and_get_node_by_id() refuses inactive nodes. | |
| * | |
| * Use O_PATH: opening a removed node fails with ENODEV, which would hide | |
| * what is being tested. | |
| */ | |
| TEST_F(kernfs_cgroup, exportfs_decode_and_stale) | |
| { | |
| char victim[PATH_MAX], procs[PATH_MAX]; | |
| struct kernfs_handle fh; | |
| struct stat st; | |
| int mfd, fd; | |
| snprintf(victim, sizeof(victim), "%s/fh", self->scratch); | |
| snprintf(procs, sizeof(procs), "%s/cgroup.procs", victim); | |
| ASSERT_EQ(mkdir(victim, 0755), 0); | |
| /* Any fd on the filesystem identifies it to open_by_handle_at(). */ | |
| mfd = open(self->scratch, O_RDONLY | O_DIRECTORY | O_CLOEXEC); | |
| ASSERT_GE(mfd, 0); | |
| if (kernfs_encode(procs, &fh)) { | |
| int err = errno; | |
| close(mfd); | |
| rmdir(victim); | |
| ASSERT_TRUE(fh_unsupported(err)) | |
| TH_LOG("name_to_handle_at: %s", strerror(err)); | |
| SKIP(return, "name_to_handle_at: %s", strerror(err)); | |
| } | |
| if (!fh_can_decode(mfd, &fh)) { | |
| close(mfd); | |
| rmdir(victim); | |
| SKIP(return, "open_by_handle_at: no CAP_DAC_READ_SEARCH"); | |
| } | |
| fd = open_by_handle_at(mfd, &fh.h, O_PATH); | |
| ASSERT_GE(fd, 0); | |
| EXPECT_EQ(fstat(fd, &st), 0); | |
| EXPECT_EQ(st.st_nlink, 1); | |
| EXPECT_EQ(close(fd), 0); | |
| ASSERT_EQ(rmdir(victim), 0); | |
| fd = open_by_handle_at(mfd, &fh.h, O_PATH); | |
| EXPECT_LT(fd, 0); | |
| if (fd >= 0) | |
| close(fd); | |
| else | |
| EXPECT_EQ(errno, ESTALE); | |
| EXPECT_EQ(close(mfd), 0); | |
| } | |
| #define FH_STRESS_SECS 2 | |
| #define FH_DECODE_CAP 10000 | |
| /* | |
| * Decode file handles while the node is being removed. A decode must | |
| * answer with a usable handle or ESTALE, never garbage and never a hang. | |
| * | |
| * The link count is checked too. An inode that reaches the inode hash | |
| * after the removal cleared link counts keeps the 1 it was born with, so | |
| * it never gets an IN_DELETE_SELF. This has not been seen to fire: it | |
| * needs the decode to stall between the lookup by id and the hash insert, | |
| * and nothing there blocks. It is kept because it is cheap and only | |
| * looks once the directory is gone, so it cannot fail falsely. | |
| */ | |
| TEST_F(kernfs_cgroup, exportfs_decode_vs_rmdir_stress) | |
| { | |
| int mfd, bad = 0, rounds = 0; | |
| struct timespec end; | |
| mfd = open(self->scratch, O_RDONLY | O_DIRECTORY | O_CLOEXEC); | |
| ASSERT_GE(mfd, 0); | |
| clock_gettime(CLOCK_MONOTONIC, &end); | |
| end.tv_sec += FH_STRESS_SECS; | |
| while (!stress_deadline(&end)) { | |
| char victim[PATH_MAX], procs[PATH_MAX]; | |
| int last = -1, fd, i; | |
| struct kernfs_handle fh; | |
| struct stat st; | |
| pid_t pid; | |
| snprintf(victim, sizeof(victim), "%s/fh%d", self->scratch, | |
| rounds++); | |
| snprintf(procs, sizeof(procs), "%s/cgroup.procs", victim); | |
| if (mkdir(victim, 0755)) | |
| break; | |
| if (kernfs_encode(procs, &fh)) { | |
| int err = errno; | |
| rmdir(victim); | |
| ASSERT_TRUE(fh_unsupported(err)) | |
| TH_LOG("name_to_handle_at: %s", strerror(err)); | |
| SKIP(goto out, "name_to_handle_at: %s", strerror(err)); | |
| } | |
| if (rounds == 1 && !fh_can_decode(mfd, &fh)) { | |
| rmdir(victim); | |
| SKIP(goto out, | |
| "open_by_handle_at: no CAP_DAC_READ_SEARCH"); | |
| } | |
| pid = fork(); | |
| ASSERT_GE(pid, 0); | |
| if (pid == 0) { | |
| rmdir_retry(victim); | |
| _exit(0); | |
| } | |
| /* | |
| * Decode until the removal deactivates the node. Keep the | |
| * last one that worked: it ran closest to the removal. | |
| */ | |
| for (i = 0; i < FH_DECODE_CAP; i++) { | |
| fd = open_by_handle_at(mfd, &fh.h, O_PATH); | |
| if (fd < 0) | |
| break; | |
| if (last >= 0) | |
| close(last); | |
| last = fd; | |
| } | |
| ASSERT_EQ(waitpid(pid, NULL, 0), pid); | |
| if (last >= 0) { | |
| if (access(victim, F_OK) && errno == ENOENT && | |
| !fstat(last, &st) && st.st_nlink != 0) | |
| bad++; | |
| close(last); | |
| } | |
| rmdir(victim); | |
| } | |
| EXPECT_EQ(bad, 0) | |
| TH_LOG("%d of %d rounds decoded a removed node whose inode kept its link count", | |
| bad, rounds); | |
| out: | |
| close(mfd); | |
| } | |
| /* | |
| * sysfs is namespace tagged (KERNFS_NS) and supports rename; cgroup2 does | |
| * neither. Run in a private netns with its own sysfs so the host is | |
| * untouched. | |
| */ | |
| FIXTURE(kernfs_netns) | |
| { | |
| char mnt[PATH_MAX]; | |
| char net[PATH_MAX]; | |
| bool mounted; | |
| }; | |
| FIXTURE_SETUP(kernfs_netns) | |
| { | |
| if (geteuid()) | |
| SKIP(return, "test needs to run as root"); | |
| if (unshare(CLONE_NEWNS | CLONE_NEWNET)) | |
| SKIP(return, "unshare(CLONE_NEWNS|CLONE_NEWNET): %s", | |
| strerror(errno)); | |
| /* Don't let our sysfs mount escape into the parent namespace. */ | |
| ASSERT_EQ(mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL), 0); | |
| strcpy(self->mnt, "/tmp/kernfs_selftest_sysfs.XXXXXX"); | |
| if (!mkdtemp(self->mnt)) | |
| SKIP(return, "mkdtemp: %s", strerror(errno)); | |
| if (mount("none", self->mnt, "sysfs", 0, NULL)) { | |
| rmdir(self->mnt); | |
| SKIP(return, "mount sysfs: %s", strerror(errno)); | |
| } | |
| self->mounted = true; | |
| snprintf(self->net, sizeof(self->net), "%s/class/net", self->mnt); | |
| } | |
| FIXTURE_TEARDOWN(kernfs_netns) | |
| { | |
| if (self->mounted) | |
| umount2(self->mnt, MNT_DETACH); | |
| rmdir(self->mnt); | |
| } | |
| /* | |
| * sysfs must show this network namespace's interfaces, not the parent's. | |
| * | |
| * Do not assume a fresh netns contains only "lo": fallback tunnel devices | |
| * (tunl0, sit0, gre0, ...) are created in every namespace unless | |
| * net.core.fb_tunnels_only_for_init_net is set, so which names appear | |
| * depends on the modules the host has. Check the set instead -- | |
| * if_nametoindex() resolves in the current netns, so every name sysfs shows | |
| * must resolve there, and the counts must agree. | |
| * | |
| * Count only symlinks. Not every entry is a device: bonding adds a | |
| * bonding_masters attribute to /sys/class/net in every namespace. | |
| */ | |
| TEST_F(kernfs_netns, ns_tag_isolates_class_net) | |
| { | |
| struct if_nameindex *idx, *i; | |
| bool found_lo = false; | |
| int n = 0, want = 0; | |
| struct dirent *de; | |
| DIR *d; | |
| d = opendir(self->net); | |
| ASSERT_NE(d, NULL); | |
| while ((de = readdir(d))) { | |
| if (de->d_type != DT_LNK) | |
| continue; | |
| EXPECT_NE(if_nametoindex(de->d_name), 0u) | |
| TH_LOG("%s is not in this netns", de->d_name); | |
| if (!strcmp(de->d_name, "lo")) | |
| found_lo = true; | |
| n++; | |
| } | |
| closedir(d); | |
| idx = if_nameindex(); | |
| ASSERT_NE(idx, NULL); | |
| for (i = idx; i->if_index; i++) | |
| want++; | |
| if_freenameindex(idx); | |
| EXPECT_TRUE(found_lo); | |
| EXPECT_EQ(n, want); | |
| } | |
| /* | |
| * After a rename the old name must stop resolving and the new one must | |
| * start, even though both dentries are already cached. | |
| */ | |
| TEST_F(kernfs_netns, rename_is_revalidated) | |
| { | |
| char old_path[PATH_MAX], new_path[PATH_MAX]; | |
| struct ifreq ifr = {}; | |
| struct stat st; | |
| int sk; | |
| snprintf(old_path, sizeof(old_path), "%s/lo", self->net); | |
| snprintf(new_path, sizeof(new_path), "%s/%s", self->net, TEST_IFNAME); | |
| /* Warm both dentries: one positive, one negative. */ | |
| ASSERT_EQ(stat(old_path, &st), 0); | |
| ASSERT_EQ(stat(new_path, &st), -1); | |
| ASSERT_EQ(errno, ENOENT); | |
| sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0); | |
| ASSERT_GE(sk, 0); | |
| strcpy(ifr.ifr_name, "lo"); | |
| strcpy(ifr.ifr_newname, TEST_IFNAME); | |
| if (ioctl(sk, SIOCSIFNAME, &ifr)) { | |
| close(sk); | |
| SKIP(return, "SIOCSIFNAME: %s", strerror(errno)); | |
| } | |
| close(sk); | |
| EXPECT_EQ(stat(old_path, &st), -1); | |
| EXPECT_EQ(errno, ENOENT); | |
| EXPECT_EQ(stat(new_path, &st), 0); | |
| } | |
| static int netdev_rename(const char *from, const char *to) | |
| { | |
| struct ifreq ifr = {}; | |
| int sk, ret; | |
| sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0); | |
| if (sk < 0) | |
| return -1; | |
| strncpy(ifr.ifr_name, from, IFNAMSIZ - 1); | |
| strncpy(ifr.ifr_newname, to, IFNAMSIZ - 1); | |
| ret = ioctl(sk, SIOCSIFNAME, &ifr); | |
| close(sk); | |
| return ret; | |
| } | |
| /* | |
| * Bounded by a count, not by time: every rename is logged and not rate | |
| * limited, so a timed loop would flood the kernel log. | |
| */ | |
| #define RENAME_FLIPS 200 | |
| #define RENAME_READERS 4 | |
| /* | |
| * Rename an interface while other tasks look up the names it moves | |
| * between. This renames its /sys/class/net entry through | |
| * kernfs_rename_ns() with the parent unchanged. | |
| * | |
| * The renamer checks what is certain: SIOCSIFNAME returns once the rename | |
| * is done and nothing else renames here, so the new name must resolve and | |
| * the old must not. The readers cannot check that, because the name can | |
| * move between their two lstat() calls. They only check that a lookup | |
| * returns success or ENOENT, and keep the lock busy while renames run. | |
| * | |
| * lstat() not stat(): /sys/class/net/<dev> is a symlink and is renamed | |
| * before the directory it points at, so the two are not atomic. | |
| */ | |
| TEST_F(kernfs_netns, rename_vs_lookup_stress) | |
| { | |
| char old_path[PATH_MAX], new_path[PATH_MAX]; | |
| pid_t pids[RENAME_READERS]; | |
| int i, status, n = 0, bad = 0; | |
| struct stat st; | |
| int done[2]; | |
| snprintf(old_path, sizeof(old_path), "%s/lo", self->net); | |
| snprintf(new_path, sizeof(new_path), "%s/%s", self->net, TEST_IFNAME); | |
| if (netdev_rename("lo", TEST_IFNAME)) | |
| SKIP(return, "SIOCSIFNAME: %s", strerror(errno)); | |
| if (netdev_rename(TEST_IFNAME, "lo")) | |
| SKIP(return, "SIOCSIFNAME back: %s", strerror(errno)); | |
| /* Readers run until the renamer closes the write end. */ | |
| ASSERT_EQ(pipe2(done, O_NONBLOCK | O_CLOEXEC), 0); | |
| for (i = 0; i < RENAME_READERS; i++) { | |
| pid_t pid = fork(); | |
| ASSERT_GE(pid, 0); | |
| if (pid == 0) { | |
| struct stat rst; | |
| char c; | |
| close(done[1]); | |
| while (read(done[0], &c, 1) < 0 && errno == EAGAIN) { | |
| if (lstat(old_path, &rst) && errno != ENOENT) | |
| _exit(20); | |
| if (lstat(new_path, &rst) && errno != ENOENT) | |
| _exit(21); | |
| } | |
| _exit(0); | |
| } | |
| pids[n++] = pid; | |
| } | |
| close(done[0]); | |
| for (i = 0; i < RENAME_FLIPS; i++) { | |
| if (netdev_rename("lo", TEST_IFNAME)) | |
| break; | |
| if (lstat(new_path, &st) || !lstat(old_path, &st)) { | |
| bad++; | |
| break; | |
| } | |
| if (netdev_rename(TEST_IFNAME, "lo")) | |
| break; | |
| if (lstat(old_path, &st) || !lstat(new_path, &st)) { | |
| bad++; | |
| break; | |
| } | |
| } | |
| close(done[1]); | |
| for (i = 0; i < n; i++) { | |
| ASSERT_EQ(waitpid(pids[i], &status, 0), pids[i]); | |
| ASSERT_TRUE(WIFEXITED(status)); | |
| EXPECT_EQ(WEXITSTATUS(status), 0); | |
| } | |
| EXPECT_EQ(bad, 0) | |
| TH_LOG("a completed rename left the wrong name resolving"); | |
| /* Leave the interface as the fixture found it. */ | |
| netdev_rename(TEST_IFNAME, "lo"); | |
| } | |
| TEST_HARNESS_MAIN |