path: root/tools/testing/selftests/filesystems/mount_cycle/locked_handle_test.c

// SPDX-License-Identifier: GPL-2.0
/*
 * may_decode_fh() refuses a file handle below a mount with locked children
 * to root in a user namespace. That has to hold while the mount is lazily
 * unmounted and its children, the locked ones too, are taken off it.
 */
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <sched.h>
#include <stdatomic.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/wait.h>

#include "../../kselftest_harness.h"

#ifndef OPEN_TREE_CLONE
#define OPEN_TREE_CLONE		1
#endif
#ifndef OPEN_TREE_CLOEXEC
#define OPEN_TREE_CLOEXEC	O_CLOEXEC
#endif
#ifndef AT_RECURSIVE
#define AT_RECURSIVE		0x8000
#endif

#define DIR_LEN		64
#define PATH_LEN	128

#define ROUNDS		100	/* lazy umounts raced per test */
#define RACERS		3	/* threads in open_by_handle_at() */
#define EXTRA_MOUNTS	64	/* make umount_tree() hold mount_lock longer */
#define MAX_DELAY_US	3000	/* before the umount */
#define TAIL_US		2000	/* after it */

struct handle {
	struct file_handle fh;
	unsigned char buf[MAX_HANDLE_SZ];
};

/* exit codes of the child */
enum {
	CHILD_OK,
	CHILD_SETUP,
	CHILD_DECODED,		/* decoded past a locked child */
	CHILD_MOUNTED,		/* not refused while mounted */
	CHILD_UNMOUNTED,	/* not refused once unmounted */
	CHILD_ALLOWED,		/* refused where nothing is locked */
	CHILD_NOUSERNS,		/* no user namespace to be had */
};

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;
}

/* 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];

	prctl(PR_SET_DUMPABLE, 1);
	/* EINVAL: no USER_NS, ENOSPC: user.max_user_namespaces is 0, EPERM: an LSM */
	if (unshare(CLONE_NEWUSER | CLONE_NEWNS))
		return errno == EINVAL || errno == ENOSPC || errno == EPERM ?
		       CHILD_NOUSERNS : CHILD_SETUP;
	if (write_file("/proc/self/setgroups", "deny") && errno != ENOENT)
		return CHILD_SETUP;
	snprintf(map, sizeof(map), "0 %d 1", uid);
	if (write_file("/proc/self/uid_map", map))
		return CHILD_SETUP;
	snprintf(map, sizeof(map), "0 %d 1", gid);
	if (write_file("/proc/self/gid_map", map))
		return CHILD_SETUP;
	if (setgid(0) || setuid(0))
		return CHILD_SETUP;
	if (mount("", "/", NULL, MS_REC | MS_PRIVATE, NULL))
		return CHILD_SETUP;
	return CHILD_OK;
}

static int get_handle(const char *path, struct handle *h)
{
	int mntid;

	h->fh.handle_bytes = MAX_HANDLE_SZ;
	return name_to_handle_at(AT_FDCWD, path, &h->fh, &mntid, 0);
}

static int decode(int dfd, struct handle *h)
{
	return open_by_handle_at(dfd, &h->fh, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
}

struct race {
	int dfd;
	struct handle *h;
	atomic_int go;
	atomic_int stop;
	atomic_int won;		/* the first decoded descriptor */
};

static void *racer(void *arg)
{
	struct race *r = arg;

	while (!atomic_load(&r->go))
		;
	while (!atomic_load(&r->stop)) {
		int none = -1;
		int fd;

		fd = decode(r->dfd, r->h);
		if (fd < 0)
			continue;
		if (!atomic_compare_exchange_strong(&r->won, &none, fd))
			close(fd);
	}
	return NULL;
}

/* stop the @n racers started so far and wait for them, they spin on @r */
static void stop_racers(struct race *r, pthread_t *th, int n)
{
	int i;

	atomic_store(&r->stop, 1);
	atomic_store(&r->go, 1);	/* one still waiting for the start sees stop next */
	for (i = 0; i < n; i++)
		pthread_join(th[i], NULL);
}

/*
 * Bind @h recursively at @w, or take a detached copy of it, and race
 * open_by_handle_at() of @inner against the lazy umount. The decoded
 * descriptor, if there was one, is left in @won.
 */
static int race_round(const char *h, const char *w, struct handle *inner,
		      bool dissolve, int *won)
{
	struct race r = { .h = inner, .won = -1 };
	pthread_t th[RACERS];
	int treefd = -1, fd, i;

	if (dissolve) {
		treefd = syscall(__NR_open_tree, AT_FDCWD, h,
				 OPEN_TREE_CLONE | AT_RECURSIVE | OPEN_TREE_CLOEXEC);
		if (treefd < 0)
			return CHILD_SETUP;
		/* an ordinary descriptor on the copy, treefd's close dissolves it */
		r.dfd = openat(treefd, ".", O_RDONLY | O_DIRECTORY | O_CLOEXEC);
	} else {
		if (mount(h, w, NULL, MS_BIND | MS_REC, NULL))
			return CHILD_SETUP;
		r.dfd = open(w, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
	}
	if (r.dfd < 0)
		return CHILD_SETUP;

	fd = decode(r.dfd, inner);
	if (fd >= 0 || errno != EPERM) {
		if (fd >= 0)
			close(fd);
		return CHILD_MOUNTED;
	}

	for (i = 0; i < RACERS; i++) {
		if (pthread_create(&th[i], NULL, racer, &r)) {
			stop_racers(&r, th, i);
			return CHILD_SETUP;
		}
	}
	atomic_store(&r.go, 1);
	usleep(rand() % MAX_DELAY_US);
	if (dissolve)
		close(treefd);
	else if (umount2(w, MNT_DETACH)) {
		stop_racers(&r, th, RACERS);
		return CHILD_SETUP;
	}
	usleep(TAIL_US);
	stop_racers(&r, th, RACERS);

	fd = decode(r.dfd, inner);
	if (fd >= 0) {
		close(fd);
		return CHILD_UNMOUNTED;
	}
	close(r.dfd);
	*won = atomic_load(&r.won);
	return CHILD_OK;
}

static int race_child(const char *h, const char *w, struct handle *inner,
		      bool dissolve)
{
	int ret, won, i;

	srand(getpid());
	ret = enter_userns();
	if (ret)
		return ret;
	for (i = 0; i < ROUNDS; i++) {
		ret = race_round(h, w, inner, dissolve, &won);
		if (ret)
			return ret;
		if (won >= 0)
			return CHILD_DECODED;
	}
	return CHILD_OK;
}

/* a bind without locked children decodes while mounted and not after */
static int allowed_child(const char *plain, const char *w, struct handle *h)
{
	int dfd, fd, ret;

	ret = enter_userns();
	if (ret)
		return ret;
	if (mount(plain, w, NULL, MS_BIND | MS_REC, NULL))
		return CHILD_SETUP;
	dfd = open(w, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
	if (dfd < 0)
		return CHILD_SETUP;
	fd = decode(dfd, h);
	if (fd < 0)
		return CHILD_ALLOWED;
	close(fd);
	if (umount2(w, MNT_DETACH))
		return CHILD_SETUP;
	fd = decode(dfd, h);
	if (fd >= 0) {
		close(fd);
		return CHILD_UNMOUNTED;
	}
	return errno == EPERM ? CHILD_OK : CHILD_UNMOUNTED;
}

FIXTURE(locked_handle) {
	char base[DIR_LEN];
	char h[PATH_LEN];		/* the tree with the covered directory */
	char plain[PATH_LEN];		/* a tree with no mount in it */
	char w[PATH_LEN];		/* where the child binds either */
	struct handle inner;		/* h/top/secret/inner, covered */
	struct handle uncovered;	/* plain/inner */
};

FIXTURE_SETUP(locked_handle)
{
	char p[PATH_LEN], e[PATH_LEN];
	int i;

	if (geteuid())
		SKIP(return, "test requires root");

	snprintf(self->base, sizeof(self->base), "/tmp/locked_handle.XXXXXX");
	ASSERT_NE(mkdtemp(self->base), NULL);
	ASSERT_EQ(unshare(CLONE_NEWNS), 0);
	ASSERT_EQ(mount("", "/", NULL, MS_REC | MS_PRIVATE, NULL), 0);
	ASSERT_EQ(mount("tmpfs", self->base, "tmpfs", 0, NULL), 0);

	snprintf(self->h, sizeof(self->h), "%s/h", self->base);
	snprintf(self->plain, sizeof(self->plain), "%s/plain", self->base);
	snprintf(self->w, sizeof(self->w), "%s/w", self->base);
	ASSERT_EQ(mkdir(self->h, 0755), 0);
	ASSERT_EQ(mkdir(self->plain, 0755), 0);
	ASSERT_EQ(mkdir(self->w, 0755), 0);
	snprintf(p, sizeof(p), "%s/plain/inner", self->base);
	ASSERT_EQ(mkdir(p, 0755), 0);
	ASSERT_EQ(get_handle(p, &self->uncovered), 0);

	/* the handle is for this filesystem */
	ASSERT_EQ(mount("tmpfs", self->h, "tmpfs", 0, NULL), 0);
	snprintf(p, sizeof(p), "%s/h/top", self->base);
	ASSERT_EQ(mkdir(p, 0755), 0);
	snprintf(p, sizeof(p), "%s/h/top/secret", self->base);
	ASSERT_EQ(mkdir(p, 0755), 0);
	snprintf(p, sizeof(p), "%s/h/top/secret/inner", self->base);
	ASSERT_EQ(mkdir(p, 0755), 0);
	ASSERT_EQ(get_handle(p, &self->inner), 0);
	snprintf(e, sizeof(e), "%s/h/empty", self->base);
	ASSERT_EQ(mkdir(e, 0755), 0);

	/* cover it, and some more so the umount takes longer */
	snprintf(p, sizeof(p), "%s/h/top/secret", self->base);
	ASSERT_EQ(mount("tmpfs", p, "tmpfs", 0, NULL), 0);
	for (i = 0; i < EXTRA_MOUNTS; i++) {
		snprintf(p, sizeof(p), "%s/h/c%d", self->base, i);
		ASSERT_EQ(mkdir(p, 0755), 0);
		ASSERT_EQ(mount(e, p, NULL, MS_BIND, NULL), 0);
	}
}

FIXTURE_TEARDOWN(locked_handle)
{
	umount2(self->base, MNT_DETACH);
	rmdir(self->base);
}

static int wait_child(pid_t pid)
{
	int status;

	if (waitpid(pid, &status, 0) != pid || !WIFEXITED(status))
		return -1;
	return WEXITSTATUS(status);
}

TEST_F(locked_handle, lazy_umount)
{
	pid_t pid;
	int ret;

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		_exit(race_child(self->h, self->w, &self->inner, false));
	ret = wait_child(pid);
	TH_LOG("child exit code %d", ret);
	if (ret == CHILD_NOUSERNS)
		SKIP(return, "no user namespaces");
	EXPECT_EQ(ret, CHILD_OK);
}

TEST_F(locked_handle, dissolve)
{
	pid_t pid;
	int ret;

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		_exit(race_child(self->h, self->w, &self->inner, true));
	ret = wait_child(pid);
	TH_LOG("child exit code %d", ret);
	if (ret == CHILD_NOUSERNS)
		SKIP(return, "no user namespaces");
	EXPECT_EQ(ret, CHILD_OK);
}

TEST_F(locked_handle, allowed_use)
{
	pid_t pid;
	int ret;

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0)
		_exit(allowed_child(self->plain, self->w, &self->uncovered));
	ret = wait_child(pid);
	TH_LOG("child exit code %d", ret);
	if (ret == CHILD_NOUSERNS)
		SKIP(return, "no user namespaces");
	EXPECT_EQ(ret, CHILD_OK);
}

TEST_HARNESS_MAIN