| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * An unmounted mount tree that a file descriptor keeps alive is put and | |
| * vacated behind the root's back, so nothing may walk it under | |
| * namespace_sem: it can't be copied recursively and its propagation can't | |
| * be changed. The mount at its root alone can still be copied and that copy | |
| * is an ordinary mount. | |
| */ | |
| #define _GNU_SOURCE | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <sched.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <sys/mount.h> | |
| #include <sys/stat.h> | |
| #include <sys/syscall.h> | |
| #include <sys/wait.h> | |
| #include <unistd.h> | |
| #include <linux/mount.h> | |
| #include "../wrappers.h" | |
| #include "../../kselftest_harness.h" | |
| #ifndef __NR_mount_setattr | |
| #define __NR_mount_setattr 442 | |
| #endif | |
| #ifndef __NR_pidfd_open | |
| #define __NR_pidfd_open 434 | |
| #endif | |
| #define PATH_LEN 64 | |
| static inline int sys_mount_setattr(int dfd, const char *path, unsigned int flags, | |
| struct mount_attr *attr, size_t size) | |
| { | |
| return syscall(__NR_mount_setattr, dfd, path, flags, attr, size); | |
| } | |
| static inline int sys_pidfd_open(pid_t pid, unsigned int flags) | |
| { | |
| return syscall(__NR_pidfd_open, pid, flags); | |
| } | |
| static int write_file(const char *path, const char *s) | |
| { | |
| ssize_t n = -1; | |
| int fd; | |
| fd = open(path, O_WRONLY | O_CLOEXEC); | |
| if (fd >= 0) { | |
| n = write(fd, s, strlen(s)); | |
| close(fd); | |
| } | |
| return n == (ssize_t)strlen(s) ? 0 : -1; | |
| } | |
| static int touch(const char *path) | |
| { | |
| int fd; | |
| fd = open(path, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, 0644); | |
| if (fd < 0) | |
| return -1; | |
| close(fd); | |
| return 0; | |
| } | |
| /* Become root in a new user namespace with a private mount namespace. */ | |
| static int enter_userns(void) | |
| { | |
| uid_t uid = getuid(); | |
| gid_t gid = getgid(); | |
| char map[32]; | |
| if (unshare(CLONE_NEWUSER | CLONE_NEWNS)) | |
| return -1; | |
| if (write_file("/proc/self/setgroups", "deny") && errno != ENOENT) | |
| return -1; | |
| snprintf(map, sizeof(map), "0 %d 1", uid); | |
| if (write_file("/proc/self/uid_map", map)) | |
| return -1; | |
| snprintf(map, sizeof(map), "0 %d 1", gid); | |
| if (write_file("/proc/self/gid_map", map)) | |
| return -1; | |
| if (setgid(0) || setuid(0)) | |
| return -1; | |
| return mount("", "/", NULL, MS_REC | MS_PRIVATE, NULL); | |
| } | |
| /* A private mount namespace of our own, all mounts private. */ | |
| static int own_mntns(void) | |
| { | |
| if (unshare(CLONE_NEWNS)) | |
| return -1; | |
| return mount("", "/", NULL, MS_REC | MS_PRIVATE, NULL); | |
| } | |
| FIXTURE(unmounted_tree) { | |
| char dir[PATH_LEN]; | |
| }; | |
| FIXTURE_SETUP(unmounted_tree) | |
| { | |
| snprintf(self->dir, sizeof(self->dir), "/tmp/unmounted_tree.XXXXXX"); | |
| ASSERT_NE(mkdtemp(self->dir), NULL); | |
| if (enter_userns()) { | |
| rmdir(self->dir); | |
| SKIP(return, "test requires user namespaces"); | |
| } | |
| ASSERT_EQ(mount("tmpfs", self->dir, "tmpfs", 0, NULL), 0); | |
| } | |
| FIXTURE_TEARDOWN(unmounted_tree) | |
| { | |
| umount2(self->dir, MNT_DETACH); | |
| rmdir(self->dir); | |
| } | |
| /* A recursive copy of the mount @fd refers to must fail with EINVAL. */ | |
| static void assert_not_walked(struct __test_metadata *_metadata, int fd, | |
| const char *target) | |
| { | |
| char link[PATH_LEN]; | |
| int tfd; | |
| snprintf(link, sizeof(link), "/proc/self/fd/%d", fd); | |
| EXPECT_EQ(mount(link, target, NULL, MS_BIND | MS_REC, NULL), -1); | |
| EXPECT_EQ(errno, EINVAL); | |
| tfd = sys_open_tree(fd, "", AT_EMPTY_PATH | AT_RECURSIVE | OPEN_TREE_CLONE | | |
| OPEN_TREE_CLOEXEC); | |
| EXPECT_LT(tfd, 0); | |
| EXPECT_EQ(errno, EINVAL); | |
| if (tfd >= 0) | |
| close(tfd); | |
| } | |
| /* The mount @fd refers to can be copied on its own and mounted on @target. */ | |
| static void assert_root_copied(struct __test_metadata *_metadata, int fd, | |
| const char *target) | |
| { | |
| int tfd; | |
| tfd = sys_open_tree(fd, "", AT_EMPTY_PATH | OPEN_TREE_CLONE | OPEN_TREE_CLOEXEC); | |
| ASSERT_GE(tfd, 0); | |
| ASSERT_EQ(sys_move_mount(tfd, "", AT_FDCWD, target, MOVE_MOUNT_F_EMPTY_PATH), 0); | |
| close(tfd); | |
| ASSERT_EQ(umount2(target, MNT_DETACH), 0); | |
| } | |
| /* | |
| * A lazily unmounted bind mount of an nsfs file, kept alive by an fd, can't | |
| * be copied recursively anymore. Copying the mount itself still works and | |
| * so does copying a mounted bind mount of the same file. | |
| */ | |
| TEST_F(unmounted_tree, detached_nsfs_bind_not_walked) | |
| { | |
| char x[PATH_LEN], y[PATH_LEN], z[PATH_LEN], link[PATH_LEN]; | |
| int fd, tfd; | |
| snprintf(x, sizeof(x), "%s/x", self->dir); | |
| snprintf(y, sizeof(y), "%s/y", self->dir); | |
| snprintf(z, sizeof(z), "%s/z", self->dir); | |
| ASSERT_EQ(touch(x), 0); | |
| ASSERT_EQ(touch(y), 0); | |
| ASSERT_EQ(touch(z), 0); | |
| ASSERT_EQ(mount("/proc/self/ns/net", x, NULL, MS_BIND, NULL), 0); | |
| fd = open(x, O_PATH | O_CLOEXEC); | |
| ASSERT_GE(fd, 0); | |
| ASSERT_EQ(umount2(x, MNT_DETACH), 0); | |
| assert_not_walked(_metadata, fd, y); | |
| snprintf(link, sizeof(link), "/proc/self/fd/%d", fd); | |
| ASSERT_EQ(mount(link, y, NULL, MS_BIND, NULL), 0); | |
| ASSERT_EQ(umount2(y, MNT_DETACH), 0); | |
| assert_root_copied(_metadata, fd, y); | |
| /* opening it is fine too */ | |
| tfd = sys_open_tree(fd, "", AT_EMPTY_PATH | OPEN_TREE_CLOEXEC); | |
| ASSERT_GE(tfd, 0); | |
| close(tfd); | |
| close(fd); | |
| ASSERT_EQ(mount("/proc/self/ns/net", y, NULL, MS_BIND, NULL), 0); | |
| ASSERT_EQ(mount(y, z, NULL, MS_BIND | MS_REC, NULL), 0); | |
| tfd = sys_open_tree(AT_FDCWD, y, AT_RECURSIVE | OPEN_TREE_CLONE | OPEN_TREE_CLOEXEC); | |
| ASSERT_GE(tfd, 0); | |
| close(tfd); | |
| } | |
| /* Bind-mount the pidfd @pidfd on @target the way pidfd_bind_mount does. */ | |
| static int bind_pidfd(int pidfd, const char *target) | |
| { | |
| int tfd, ret; | |
| tfd = sys_open_tree(pidfd, "", AT_EMPTY_PATH | OPEN_TREE_CLONE | OPEN_TREE_CLOEXEC); | |
| if (tfd < 0) | |
| return -1; | |
| ret = sys_move_mount(tfd, "", AT_FDCWD, target, MOVE_MOUNT_F_EMPTY_PATH); | |
| close(tfd); | |
| return ret; | |
| } | |
| /* The same for a bind mount of a pidfd. */ | |
| TEST_F(unmounted_tree, detached_pidfs_bind_not_walked) | |
| { | |
| char x[PATH_LEN], y[PATH_LEN]; | |
| int pidfd, fd, tfd; | |
| snprintf(x, sizeof(x), "%s/x", self->dir); | |
| snprintf(y, sizeof(y), "%s/y", self->dir); | |
| ASSERT_EQ(touch(x), 0); | |
| ASSERT_EQ(touch(y), 0); | |
| pidfd = sys_pidfd_open(getpid(), 0); | |
| ASSERT_GE(pidfd, 0); | |
| ASSERT_EQ(bind_pidfd(pidfd, x), 0); | |
| fd = open(x, O_PATH | O_CLOEXEC); | |
| ASSERT_GE(fd, 0); | |
| ASSERT_EQ(umount2(x, MNT_DETACH), 0); | |
| assert_not_walked(_metadata, fd, y); | |
| assert_root_copied(_metadata, fd, y); | |
| close(fd); | |
| ASSERT_EQ(bind_pidfd(pidfd, y), 0); | |
| tfd = sys_open_tree(AT_FDCWD, y, AT_RECURSIVE | OPEN_TREE_CLONE | OPEN_TREE_CLOEXEC); | |
| ASSERT_GE(tfd, 0); | |
| close(tfd); | |
| close(pidfd); | |
| } | |
| /* What a child in its own mount namespace reports back. */ | |
| enum { | |
| CHILD_OK, | |
| CHILD_NS, /* could not set up the mount namespace */ | |
| CHILD_MOUNT, /* could not set up the mounts */ | |
| CHILD_PIPE, /* the parent went away */ | |
| CHILD_WALKED, /* the detached tree was copied recursively */ | |
| CHILD_ROOT_REFUSED, /* the mount at its root wasn't copied */ | |
| CHILD_STILL_MOUNTED, /* the copy survived the unlink of its mountpoint */ | |
| CHILD_ERRNO, /* refused, but not with EINVAL */ | |
| }; | |
| static const char *child_reason(int code) | |
| { | |
| static const char *const reasons[] = { | |
| [CHILD_OK] = "ok", | |
| [CHILD_NS] = "could not set up the mount namespace", | |
| [CHILD_MOUNT] = "could not set up the mounts", | |
| [CHILD_PIPE] = "the parent went away", | |
| [CHILD_WALKED] = "the detached tree was copied recursively", | |
| [CHILD_ROOT_REFUSED] = "the mount at its root wasn't copied", | |
| [CHILD_STILL_MOUNTED] = "the copy survived the unlink of its mountpoint", | |
| [CHILD_ERRNO] = "refused, but not with EINVAL", | |
| }; | |
| if (code < 0 || code >= (int)(sizeof(reasons) / sizeof(reasons[0]))) | |
| return "child died"; | |
| return reasons[code]; | |
| } | |
| struct child_args { | |
| const char *x; /* the nsfs bind mount goes here */ | |
| const char *s; /* a file to bind on top of it */ | |
| const char *y; /* a target to copy to */ | |
| }; | |
| /* | |
| * Run @fn in a child in a mount namespace of its own. Once the child | |
| * reports that its mounts are in place, unlink @victim here, where it is a | |
| * plain file, and let the child carry on. Returns what the child reported. | |
| */ | |
| static int run_child(struct __test_metadata *_metadata, | |
| int (*fn)(const struct child_args *, int, int), | |
| const struct child_args *a, const char *victim) | |
| { | |
| int to_parent[2], to_child[2], status; | |
| pid_t pid; | |
| char c; | |
| if (pipe(to_parent) || pipe(to_child)) | |
| return -1; | |
| pid = fork(); | |
| if (pid < 0) | |
| return -1; | |
| if (pid == 0) { | |
| close(to_parent[0]); | |
| close(to_child[1]); | |
| _exit(fn(a, to_parent[1], to_child[0])); | |
| } | |
| close(to_parent[1]); | |
| close(to_child[0]); | |
| if (read(to_parent[0], &c, 1) == 1) { | |
| /* not a mountpoint in this namespace, so the file can go */ | |
| EXPECT_EQ(unlink(victim), 0); | |
| EXPECT_EQ(write(to_child[1], "", 1), 1); | |
| } | |
| close(to_parent[0]); | |
| close(to_child[1]); | |
| if (waitpid(pid, &status, 0) != pid || !WIFEXITED(status)) | |
| return -1; | |
| return WEXITSTATUS(status); | |
| } | |
| /* | |
| * An nsfs bind mount on @x, an fd on it and a bind mount of @s on top. Once | |
| * the parent has unlinked @x underneath, the first mount is detached and the | |
| * second one, which stayed attached to it, has been vacated. The tree may | |
| * not be walked, the mount at its root may still be copied. | |
| */ | |
| static int vacant_child(const struct child_args *a, int to_parent, int from_parent) | |
| { | |
| char link[PATH_LEN]; | |
| int fd, tfd; | |
| char c; | |
| if (own_mntns()) | |
| return CHILD_NS; | |
| if (mount("/proc/self/ns/net", a->x, NULL, MS_BIND, NULL)) | |
| return CHILD_MOUNT; | |
| fd = open(a->x, O_PATH | O_CLOEXEC); | |
| if (fd < 0 || mount(a->s, a->x, NULL, MS_BIND, NULL)) | |
| return CHILD_MOUNT; | |
| if (write(to_parent, "", 1) != 1 || read(from_parent, &c, 1) != 1) | |
| return CHILD_PIPE; | |
| tfd = sys_open_tree(fd, "", AT_EMPTY_PATH | AT_RECURSIVE | OPEN_TREE_CLONE | | |
| OPEN_TREE_CLOEXEC); | |
| if (tfd >= 0) { | |
| close(tfd); | |
| return CHILD_WALKED; | |
| } | |
| if (errno != EINVAL) | |
| return CHILD_ERRNO; | |
| snprintf(link, sizeof(link), "/proc/self/fd/%d", fd); | |
| if (!mount(link, a->y, NULL, MS_BIND | MS_REC, NULL)) | |
| return CHILD_WALKED; | |
| if (errno != EINVAL) | |
| return CHILD_ERRNO; | |
| tfd = sys_open_tree(fd, "", AT_EMPTY_PATH | OPEN_TREE_CLONE | OPEN_TREE_CLOEXEC); | |
| if (tfd < 0) | |
| return CHILD_ROOT_REFUSED; | |
| close(tfd); | |
| /* the last reference on the detached mount collects the vacant one */ | |
| close(fd); | |
| return CHILD_OK; | |
| } | |
| /* | |
| * unlink() of the child's mountpoint from here, where it is a plain file, | |
| * detaches the child's nsfs bind mount with the mount on top left attached | |
| * to it. The mount on top loses its last reference right there and is | |
| * vacated. The child must not be able to walk that tree. | |
| */ | |
| TEST_F(unmounted_tree, vacant_child_not_copied) | |
| { | |
| char x[PATH_LEN], s[PATH_LEN], y[PATH_LEN]; | |
| struct child_args a = { .x = x, .s = s, .y = y }; | |
| int ret; | |
| snprintf(x, sizeof(x), "%s/x", self->dir); | |
| snprintf(s, sizeof(s), "%s/s", self->dir); | |
| snprintf(y, sizeof(y), "%s/y", self->dir); | |
| ASSERT_EQ(touch(x), 0); | |
| ASSERT_EQ(touch(s), 0); | |
| ASSERT_EQ(touch(y), 0); | |
| ret = run_child(_metadata, vacant_child, &a, x); | |
| ASSERT_EQ(ret, CHILD_OK) | |
| TH_LOG("child: %s", child_reason(ret)); | |
| } | |
| /* | |
| * An nsfs bind mount on @x, lazily unmounted but kept alive by an fd, and a | |
| * copy of it on @y. That copy is a mount like any other: once the parent has | |
| * unlinked @y underneath, it is unmounted and its attributes can't be changed | |
| * anymore. A copy that took the flag along is only unhooked, stays in the | |
| * namespace and still takes the change. | |
| */ | |
| static int ordinary_copy(const struct child_args *a, int to_parent, int from_parent) | |
| { | |
| struct mount_attr attr = { | |
| .attr_set = MOUNT_ATTR_NOSUID, | |
| }; | |
| char link[PATH_LEN]; | |
| int fd, fdy; | |
| char c; | |
| if (own_mntns()) | |
| return CHILD_NS; | |
| if (mount("/proc/self/ns/net", a->x, NULL, MS_BIND, NULL)) | |
| return CHILD_MOUNT; | |
| fd = open(a->x, O_PATH | O_CLOEXEC); | |
| if (fd < 0 || umount2(a->x, MNT_DETACH)) | |
| return CHILD_MOUNT; | |
| snprintf(link, sizeof(link), "/proc/self/fd/%d", fd); | |
| if (mount(link, a->y, NULL, MS_BIND, NULL)) | |
| return CHILD_MOUNT; | |
| fdy = open(a->y, O_PATH | O_CLOEXEC); | |
| if (fdy < 0) | |
| return CHILD_MOUNT; | |
| if (write(to_parent, "", 1) != 1 || read(from_parent, &c, 1) != 1) | |
| return CHILD_PIPE; | |
| if (!sys_mount_setattr(fdy, "", AT_EMPTY_PATH, &attr, sizeof(attr))) | |
| return CHILD_STILL_MOUNTED; | |
| if (errno != EINVAL) | |
| return CHILD_ERRNO; | |
| close(fdy); | |
| close(fd); | |
| return CHILD_OK; | |
| } | |
| /* | |
| * A copy of a detached nsfs bind mount must not take after its source and | |
| * read as unmounted. unlink() of its mountpoint from here unmounts it like | |
| * any other mount, so the child can't change its attributes anymore. | |
| */ | |
| TEST_F(unmounted_tree, copy_of_detached_bind_is_ordinary) | |
| { | |
| char x[PATH_LEN], y[PATH_LEN]; | |
| struct child_args a = { .x = x, .y = y }; | |
| int ret; | |
| snprintf(x, sizeof(x), "%s/x", self->dir); | |
| snprintf(y, sizeof(y), "%s/y", self->dir); | |
| ASSERT_EQ(touch(x), 0); | |
| ASSERT_EQ(touch(y), 0); | |
| ret = run_child(_metadata, ordinary_copy, &a, y); | |
| ASSERT_EQ(ret, CHILD_OK) | |
| TH_LOG("child: %s", child_reason(ret)); | |
| } | |
| /* | |
| * mount_setattr() may change the propagation of a detached tree while that | |
| * tree is still the root of an anonymous mount namespace, but not once the | |
| * tree has been dissolved and only a second fd keeps its root alive. | |
| */ | |
| TEST_F(unmounted_tree, detached_tree_setattr_refused) | |
| { | |
| struct mount_attr attr = { | |
| .propagation = MS_SHARED, | |
| }; | |
| char a[PATH_LEN], b[PATH_LEN]; | |
| int tfd, fd; | |
| snprintf(a, sizeof(a), "%s/a", self->dir); | |
| snprintf(b, sizeof(b), "%s/a/b", self->dir); | |
| ASSERT_EQ(mkdir(a, 0755), 0); | |
| ASSERT_EQ(mount("tmpfs", a, "tmpfs", 0, NULL), 0); | |
| ASSERT_EQ(mkdir(b, 0755), 0); | |
| ASSERT_EQ(mount("tmpfs", b, "tmpfs", 0, NULL), 0); | |
| tfd = sys_open_tree(AT_FDCWD, self->dir, AT_RECURSIVE | OPEN_TREE_CLONE | | |
| OPEN_TREE_CLOEXEC); | |
| ASSERT_GE(tfd, 0); | |
| ASSERT_EQ(sys_mount_setattr(tfd, "", AT_EMPTY_PATH | AT_RECURSIVE, &attr, sizeof(attr)), 0); | |
| attr.propagation = MS_PRIVATE; | |
| ASSERT_EQ(sys_mount_setattr(tfd, "", AT_EMPTY_PATH | AT_RECURSIVE, &attr, sizeof(attr)), 0); | |
| /* a second reference on the root, then dissolve the tree */ | |
| fd = sys_open_tree(tfd, "", AT_EMPTY_PATH | OPEN_TREE_CLOEXEC); | |
| ASSERT_GE(fd, 0); | |
| close(tfd); | |
| attr.propagation = MS_SHARED; | |
| ASSERT_EQ(sys_mount_setattr(fd, "", AT_EMPTY_PATH | AT_RECURSIVE, &attr, sizeof(attr)), -1); | |
| ASSERT_EQ(errno, EINVAL); | |
| attr.propagation = MS_PRIVATE; | |
| ASSERT_EQ(sys_mount_setattr(fd, "", AT_EMPTY_PATH, &attr, sizeof(attr)), -1); | |
| ASSERT_EQ(errno, EINVAL); | |
| close(fd); | |
| } | |
| TEST_HARNESS_MAIN |