path: root/tools/testing/selftests/filesystems/freeze/shared_bdev_test.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Freezing a block device that several superblocks share.
 *
 * erofs claims its blob devices with the filesystem type as the holder, so
 * several erofs superblocks can share a blob. Merge two images from a common
 * layer and a layer of their own, put the common layer on a device-mapper
 * device and mount both. A suspend of that device has to freeze each of the
 * two superblocks exactly once and the resume has to thaw both, also while
 * mounts of one of them come and go. erofs is read-only, so the freezes and
 * thaws don't write to the suspended device.
 */
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <ftw.h>
#include <linux/dm-ioctl.h>
#include <linux/fs.h>
#include <sched.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/sysmacros.h>
#include <sys/wait.h>
#include <unistd.h>

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

#define NR_CHURN 100

enum { M12, M13, L1, L2, L3, NR_IMGS };

static const char *const img_names[NR_IMGS] = { "m12", "m13", "l1", "l2", "l3" };

FIXTURE(shared_bdev) {
	char dir[64];
	char a[96];
	char b[96];
	char dm[96];
	char name[32];
	char src_a[32];
	char src_b[32];
	char opts_a[256];
	char opts_b[256];
	int loop[NR_IMGS];
	int fd_a;
	int fd_b;
	dev_t dmdev;
	bool dm_created;
	bool suspended;
	bool mounted_a;
	bool mounted_b;
};

static int dm_ioctl(unsigned long cmd, const char *name, uint32_t flags, dev_t *dev)
{
	struct dm_ioctl dmi = {
		.version = { DM_VERSION_MAJOR, 0, 0 },
		.data_size = sizeof(dmi),
		.data_start = sizeof(dmi),
		.flags = flags,
	};
	int fd, ret = 0;

	strncpy(dmi.name, name, sizeof(dmi.name) - 1);
	fd = open("/dev/mapper/control", O_RDWR | O_CLOEXEC);
	if (fd < 0)
		return -errno;
	if (ioctl(fd, cmd, &dmi))
		ret = -errno;
	else if (dev)
		*dev = makedev((dmi.dev >> 8) & 0xfff,
			       (dmi.dev & 0xff) | ((dmi.dev >> 12) & 0xfff00));
	close(fd);
	return ret;
}

/* Create @name as a linear mapping of all of @backing and make it live. */
static int dm_create_linear(const char *name, dev_t backing, uint64_t sectors,
			    dev_t *dev)
{
	struct {
		struct dm_ioctl dmi;
		struct dm_target_spec spec;
		char params[64];
	} __attribute__((aligned(8))) t = {};
	int fd, ret;

	ret = dm_ioctl(DM_DEV_CREATE, name, 0, NULL);
	if (ret)
		return ret;

	t.dmi.version[0] = DM_VERSION_MAJOR;
	t.dmi.data_size = sizeof(t);
	t.dmi.data_start = sizeof(t.dmi);
	t.dmi.target_count = 1;
	strncpy(t.dmi.name, name, sizeof(t.dmi.name) - 1);
	t.spec.length = sectors;
	strcpy(t.spec.target_type, "linear");
	snprintf(t.params, sizeof(t.params), "%u:%u 0", major(backing), minor(backing));

	fd = open("/dev/mapper/control", O_RDWR | O_CLOEXEC);
	if (fd >= 0) {
		ret = ioctl(fd, DM_TABLE_LOAD, &t) ? -errno : 0;
		close(fd);
	} else {
		ret = -errno;
	}
	/* Resuming makes the loaded table live. */
	if (!ret)
		ret = dm_ioctl(DM_DEV_SUSPEND, name, 0, dev);
	if (ret)
		dm_ioctl(DM_DEV_REMOVE, name, 0, NULL);
	return ret;
}

static int suspend(FIXTURE_DATA(shared_bdev) *self)
{
	int ret = dm_ioctl(DM_DEV_SUSPEND, self->name, DM_SUSPEND_FLAG, NULL);

	if (!ret)
		self->suspended = true;
	return ret;
}

static int resume(FIXTURE_DATA(shared_bdev) *self)
{
	int ret = dm_ioctl(DM_DEV_SUSPEND, self->name, 0, NULL);

	if (!ret)
		self->suspended = false;
	return ret;
}

/* Drop one freeze with FITHAW; EINVAL if the superblock isn't frozen. */
static bool fithaw(int fd)
{
	return !ioctl(fd, FITHAW, 0);
}

static int write_file(const char *path, const char *val)
{
	ssize_t len = strlen(val);
	int fd, ret = 0;

	fd = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
	if (fd < 0)
		return -1;
	if (write(fd, val, len) != len)
		ret = -1;
	close(fd);
	return ret;
}

static int check_file(const char *path, const char *val)
{
	char buf[32] = {};
	int fd;

	fd = open(path, O_RDONLY | O_CLOEXEC);
	if (fd < 0)
		return -1;
	if (read(fd, buf, sizeof(buf) - 1) < 0)
		buf[0] = '\0';
	close(fd);
	return strcmp(buf, val) ? -1 : 0;
}

static int rm_one(const char *path, const struct stat *st, int type, struct FTW *ftw)
{
	return remove(path);
}

static int mount_b(FIXTURE_DATA(shared_bdev) *self)
{
	int ret = mount(self->src_b, self->b, "erofs", MS_RDONLY, self->opts_b);

	if (!ret)
		self->mounted_b = true;
	return ret;
}

static void shared_bdev_cleanup(FIXTURE_DATA(shared_bdev) *self)
{
	if (self->suspended)
		resume(self);
	if (self->fd_a >= 0)
		close(self->fd_a);
	if (self->fd_b >= 0)
		close(self->fd_b);
	if (self->mounted_a)
		umount2(self->a, MNT_DETACH);
	umount2(self->b, MNT_DETACH);
	if (self->dm_created)
		dm_ioctl(DM_DEV_REMOVE, self->name, 0, NULL);
	for (int i = 0; i < NR_IMGS; i++) {
		if (self->loop[i] >= 0)
			loop_clear(self->loop[i]);
	}
	nftw(self->dir, rm_one, 16, FTW_DEPTH | FTW_PHYS);
}

/* Two layers of their own, a common one, and two images merged from them. */
static int make_images(const char *dir)
{
	static const char *const files[][2] = {
		{ "src-l1/d1/f1", "one\n" },
		{ "src-l2/f2", "two\n" },
		{ "src-l3/f3", "three\n" },
	};
	char path[160], cmd[512];

	for (int i = 0; i < 3; i++) {
		snprintf(path, sizeof(path), "%s/src-l%d", dir, i + 1);
		if (mkdir(path, 0755))
			return -1;
	}
	snprintf(path, sizeof(path), "%s/src-l1/d1", dir);
	if (mkdir(path, 0755))
		return -1;
	for (int i = 0; i < 3; i++) {
		snprintf(path, sizeof(path), "%s/%s", dir, files[i][0]);
		if (write_file(path, files[i][1]))
			return -1;
	}

	/* Chunk-based layers can be referenced by the merged images. */
	snprintf(cmd, sizeof(cmd),
		 "cd %s && (for l in l1 l2 l3; do "
		 "mkfs.erofs --chunksize=4096 -Enoinline_data $l src-$l || exit 1; done && "
		 "mkfs.erofs m12 l1 l2 && mkfs.erofs m13 l1 l3) >/dev/null 2>&1", dir);
	return system(cmd) ? -1 : 0;
}

FIXTURE_SETUP(shared_bdev)
{
	struct stat img, lst, st;
	char path[160], dev[32];
	int fd;

	for (int i = 0; i < NR_IMGS; i++)
		self->loop[i] = -1;
	self->fd_a = -1;
	self->fd_b = -1;
	self->dm_created = false;
	self->suspended = false;
	self->mounted_a = false;
	self->mounted_b = false;

	if (geteuid() != 0)
		SKIP(return, "test requires CAP_SYS_ADMIN");
	if (access("/dev/loop-control", R_OK | W_OK))
		SKIP(return, "test requires loop devices");
	if (access("/dev/mapper/control", R_OK | W_OK))
		SKIP(return, "test requires device-mapper");

	ASSERT_EQ(unshare(CLONE_NEWNS), 0);
	ASSERT_EQ(mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL), 0);

	snprintf(self->dir, sizeof(self->dir), "/tmp/shared_bdev.XXXXXX");
	ASSERT_NE(mkdtemp(self->dir), NULL);
	snprintf(self->a, sizeof(self->a), "%s/a", self->dir);
	snprintf(self->b, sizeof(self->b), "%s/b", self->dir);
	snprintf(self->name, sizeof(self->name), "shared_bdev_%d", getpid());
	/* The harness doesn't run the teardown when the setup fails. */
	ASSERT_EQ(mkdir(self->a, 0700), 0)
		shared_bdev_cleanup(self);
	ASSERT_EQ(mkdir(self->b, 0700), 0)
		shared_bdev_cleanup(self);

	if (make_images(self->dir)) {
		shared_bdev_cleanup(self);
		SKIP(return, "mkfs.erofs failed, is missing or can't merge images");
	}

	for (int i = 0; i < NR_IMGS; i++) {
		snprintf(path, sizeof(path), "%s/%s", self->dir, img_names[i]);
		fd = open(path, O_RDWR | O_CLOEXEC);
		ASSERT_GE(fd, 0)
			shared_bdev_cleanup(self);
		self->loop[i] = loop_bind(fd);
		if (i == L1) {
			ASSERT_EQ(fstat(fd, &img), 0)
				shared_bdev_cleanup(self);
		}
		close(fd);
		ASSERT_GE(self->loop[i], 0)
			shared_bdev_cleanup(self);
	}

	/* The common layer goes on a device-mapper device. */
	snprintf(dev, sizeof(dev), "/dev/loop%d", self->loop[L1]);
	ASSERT_EQ(stat(dev, &lst), 0)
		shared_bdev_cleanup(self);
	ASSERT_EQ(dm_create_linear(self->name, lst.st_rdev, img.st_size >> 9, &self->dmdev), 0)
		shared_bdev_cleanup(self);
	self->dm_created = true;
	snprintf(self->dm, sizeof(self->dm), "/dev/dm-%u", minor(self->dmdev));
	if (stat(self->dm, &st) || st.st_rdev != self->dmdev) {
		snprintf(self->dm, sizeof(self->dm), "%s/dm", self->dir);
		ASSERT_EQ(mknod(self->dm, S_IFBLK | 0600, self->dmdev), 0)
			shared_bdev_cleanup(self);
	}

	snprintf(self->src_a, sizeof(self->src_a), "/dev/loop%d", self->loop[M12]);
	snprintf(self->src_b, sizeof(self->src_b), "/dev/loop%d", self->loop[M13]);
	snprintf(self->opts_a, sizeof(self->opts_a), "device=%s,device=/dev/loop%d",
		 self->dm, self->loop[L2]);
	snprintf(self->opts_b, sizeof(self->opts_b), "device=%s,device=/dev/loop%d",
		 self->dm, self->loop[L3]);

	if (mount(self->src_a, self->a, "erofs", MS_RDONLY, self->opts_a)) {
		if (errno == ENODEV) {
			shared_bdev_cleanup(self);
			SKIP(return, "kernel lacks erofs");
		}
		ASSERT_EQ(errno, 0)
			shared_bdev_cleanup(self);
	}
	self->mounted_a = true;
	ASSERT_EQ(mount_b(self), 0)
		shared_bdev_cleanup(self);

	/* Both read through the shared blob. */
	snprintf(path, sizeof(path), "%s/d1/f1", self->a);
	ASSERT_EQ(check_file(path, "one\n"), 0)
		shared_bdev_cleanup(self);
	snprintf(path, sizeof(path), "%s/f2", self->a);
	ASSERT_EQ(check_file(path, "two\n"), 0)
		shared_bdev_cleanup(self);
	snprintf(path, sizeof(path), "%s/d1/f1", self->b);
	ASSERT_EQ(check_file(path, "one\n"), 0)
		shared_bdev_cleanup(self);
	snprintf(path, sizeof(path), "%s/f3", self->b);
	ASSERT_EQ(check_file(path, "three\n"), 0)
		shared_bdev_cleanup(self);

	self->fd_a = open(self->a, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
	ASSERT_GE(self->fd_a, 0)
		shared_bdev_cleanup(self);
	self->fd_b = open(self->b, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
	ASSERT_GE(self->fd_b, 0)
		shared_bdev_cleanup(self);
}

FIXTURE_TEARDOWN(shared_bdev)
{
	shared_bdev_cleanup(self);
}

TEST_F(shared_bdev, suspend_freezes_each_once)
{
	ASSERT_EQ(suspend(self), 0);

	/* One FITHAW drops each freeze, a second one finds nothing frozen. */
	ASSERT_TRUE(fithaw(self->fd_a));
	ASSERT_FALSE(fithaw(self->fd_a));
	ASSERT_EQ(errno, EINVAL);
	ASSERT_TRUE(fithaw(self->fd_b));
	ASSERT_FALSE(fithaw(self->fd_b));
	ASSERT_EQ(errno, EINVAL);

	/* The resume finds nothing left to thaw and still thaws the device. */
	ASSERT_EQ(resume(self), 0);
	ASSERT_EQ(suspend(self), 0);
	ASSERT_EQ(resume(self), 0);
}

TEST_F(shared_bdev, resume_thaws_all)
{
	ASSERT_EQ(suspend(self), 0);
	ASSERT_EQ(resume(self), 0);

	ASSERT_FALSE(fithaw(self->fd_a));
	ASSERT_EQ(errno, EINVAL);
	ASSERT_FALSE(fithaw(self->fd_b));
	ASSERT_EQ(errno, EINVAL);
}

TEST_F(shared_bdev, unmounted_sharer)
{
	close(self->fd_b);
	self->fd_b = -1;
	ASSERT_EQ(umount2(self->b, 0), 0);
	self->mounted_b = false;

	/* Only the remaining superblock is frozen, once. */
	ASSERT_EQ(suspend(self), 0);
	ASSERT_TRUE(fithaw(self->fd_a));
	ASSERT_FALSE(fithaw(self->fd_a));
	ASSERT_EQ(errno, EINVAL);
	ASSERT_EQ(resume(self), 0);

	/* The blob can be claimed again. */
	ASSERT_EQ(mount_b(self), 0);
}

TEST_F(shared_bdev, flushbuf)
{
	int fd = open(self->dm, O_RDONLY | O_CLOEXEC);

	ASSERT_GE(fd, 0);
	/* BLKFLSBUF syncs every superblock that uses the device. */
	ASSERT_EQ(ioctl(fd, BLKFLSBUF, 0), 0);
	close(fd);
}

#ifdef __NR_ustat
/* struct ustat is not exported through UAPI, mirror include/linux/types.h. */
struct ustat_buf {
	int		f_tfree;
	unsigned long	f_tinode;
	char		f_fname[6];
	char		f_fpack[6];
	char		pad[64];
};

TEST_F(shared_bdev, ustat)
{
	struct ustat_buf buf;

	/* ustat() stops at the first superblock it can lock... */
	ASSERT_EQ(syscall(__NR_ustat, (unsigned int)self->dmdev, &buf), 0);

	/* ...and the walks after it still reach both. */
	ASSERT_EQ(suspend(self), 0);
	ASSERT_TRUE(fithaw(self->fd_a));
	ASSERT_TRUE(fithaw(self->fd_b));
	ASSERT_EQ(resume(self), 0);
}
#endif

TEST_F(shared_bdev, churn)
{
	int status;
	pid_t pid;

	close(self->fd_b);
	self->fd_b = -1;
	ASSERT_EQ(umount2(self->b, 0), 0);
	self->mounted_b = false;

	pid = fork();
	ASSERT_GE(pid, 0);
	if (pid == 0) {
		/* A mount while the device is frozen is refused with EBUSY. */
		for (int i = 0; i < NR_CHURN; i++) {
			if (!mount(self->src_b, self->b, "erofs", MS_RDONLY, self->opts_b)) {
				if (umount2(self->b, 0))
					_exit(1);
			} else if (errno != EBUSY) {
				_exit(2);
			}
		}
		_exit(0);
	}

	for (int i = 0; i < NR_CHURN; i++) {
		ASSERT_EQ(suspend(self), 0);
		ASSERT_EQ(resume(self), 0);
	}
	ASSERT_EQ(waitpid(pid, &status, 0), pid);
	ASSERT_TRUE(WIFEXITED(status));
	ASSERT_EQ(WEXITSTATUS(status), 0);

	/* Nothing is left frozen and the blob can be claimed again. */
	ASSERT_FALSE(fithaw(self->fd_a));
	ASSERT_EQ(errno, EINVAL);
	ASSERT_EQ(mount_b(self), 0);
}

TEST_HARNESS_MAIN