// SPDX-License-Identifier: GPL-2.0
/*
 * A mount namespace file bind-mounted on top of the mount that is moved
 * onto a shared mount isn't copied to the peers and slaves. The mount that
 * already sits at the destination in a slave has to end up on top of the
 * propagated copy, not below the root of the mount namespace file where no
 * path walk ever finds it.
 */
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <sched.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/wait.h>

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

#define DIR_LEN 64
#define PATH_LEN 128

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 create_file(const char *path, const char *s)
{
	ssize_t n = -1;
	int fd;

	fd = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
	if (fd >= 0) {
		n = write(fd, s, strlen(s));
		close(fd);
	}
	return n == (ssize_t)strlen(s) ? 0 : -1;
}

/* the first bytes of the file at @path, "" if it can't be read */
static const char *read_file(const char *path, char *buf, size_t len)
{
	ssize_t n = -1;
	int fd;

	fd = open(path, O_RDONLY | O_CLOEXEC);
	if (fd >= 0) {
		n = read(fd, buf, len - 1);
		close(fd);
	}
	buf[n > 0 ? n : 0] = '\0';
	return buf;
}

/* 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);
}

FIXTURE(overmount_ns_file) {
	char dir[DIR_LEN];
	pid_t child;
};

FIXTURE_SETUP(overmount_ns_file)
{
	self->child = -1;
	snprintf(self->dir, sizeof(self->dir), "/tmp/overmount_ns_file.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(overmount_ns_file)
{
	if (self->child > 0) {
		kill(self->child, SIGKILL);
		waitpid(self->child, NULL, 0);
	}
	umount2(self->dir, MNT_DETACH);
	rmdir(self->dir);
}

/*
 * A is a shared tmpfs and B its slave with Q, a bind mount of a file, on
 * B/file. S is a bind mount of a file with N, a bind mount of a newer mount
 * namespace's file, on top of it. S is moved onto A/file. Its copy S' lands
 * on B/file below Q, without N. B/file keeps reading Q and once Q is
 * unmounted it reads S'.
 */
TEST_F(overmount_ns_file, existing_mount_stays_on_top)
{
	char a[PATH_LEN], b[PATH_LEN], s[PATH_LEN], p[PATH_LEN], buf[16];
	int fd, pfd[2];
	char c;

	snprintf(a, sizeof(a), "%s/A", self->dir);
	snprintf(b, sizeof(b), "%s/B", self->dir);
	snprintf(s, sizeof(s), "%s/s", self->dir);
	ASSERT_EQ(mkdir(a, 0755), 0);
	ASSERT_EQ(mkdir(b, 0755), 0);
	ASSERT_EQ(mkdir(s, 0755), 0);

	/* A shared, B its slave, Q on B/file */
	ASSERT_EQ(mount("tmpfs", a, "tmpfs", 0, NULL), 0);
	ASSERT_EQ(mount(NULL, a, NULL, MS_SHARED, NULL), 0);
	snprintf(p, sizeof(p), "%s/A/file", self->dir);
	ASSERT_EQ(create_file(p, "A"), 0);
	ASSERT_EQ(mount(a, b, NULL, MS_BIND, NULL), 0);
	ASSERT_EQ(mount(NULL, b, NULL, MS_SLAVE, NULL), 0);
	snprintf(p, sizeof(p), "%s/Q", self->dir);
	ASSERT_EQ(create_file(p, "Q"), 0);
	snprintf(b, sizeof(b), "%s/B/file", self->dir);
	ASSERT_EQ(mount(p, b, NULL, MS_BIND, NULL), 0);

	/* S on s/f, pinned by a file descriptor before N goes on top */
	ASSERT_EQ(mount("tmpfs", s, "tmpfs", 0, NULL), 0);
	snprintf(p, sizeof(p), "%s/s/f", self->dir);
	ASSERT_EQ(create_file(p, "f"), 0);
	snprintf(s, sizeof(s), "%s/s/S", self->dir);
	ASSERT_EQ(create_file(s, "S"), 0);
	ASSERT_EQ(mount(s, p, NULL, MS_BIND, NULL), 0);
	fd = open(p, O_PATH | O_CLOEXEC);
	ASSERT_GE(fd, 0);

	/* a newer mount namespace whose file can be bound */
	ASSERT_EQ(pipe(pfd), 0);
	self->child = fork();
	ASSERT_GE(self->child, 0);
	if (self->child == 0) {
		close(pfd[0]);
		if (unshare(CLONE_NEWNS) || write(pfd[1], "r", 1) != 1)
			_exit(1);
		pause();
		_exit(0);
	}
	close(pfd[1]);
	ASSERT_EQ(read(pfd[0], &c, 1), 1);
	close(pfd[0]);
	snprintf(s, sizeof(s), "/proc/%d/ns/mnt", self->child);
	ASSERT_EQ(mount(s, p, NULL, MS_BIND, NULL), 0);

	ASSERT_STREQ(read_file(b, buf, sizeof(buf)), "Q");

	snprintf(a, sizeof(a), "%s/A/file", self->dir);
	ASSERT_EQ(sys_move_mount(fd, "", AT_FDCWD, a, MOVE_MOUNT_F_EMPTY_PATH), 0);
	close(fd);

	/* Q is still on top of the copy in B and can be unmounted */
	EXPECT_STREQ(read_file(b, buf, sizeof(buf)), "Q");
	EXPECT_EQ(umount2(b, 0), 0);
	EXPECT_STREQ(read_file(b, buf, sizeof(buf)), "S");
}

TEST_HARNESS_MAIN