Add tests that files on pseudo filesystems can't be used as storage: - a procfs file attached read-only to a loop device - sysfs files attached read-only and read-write to a loop device - a sysfs file behind a lower-only overlayfs attached to a loop device - a sysfs file as the backing file of a usb mass storage gadget LUN - a sysfs file as the source of a file-backed erofs mount
And make sure that a memfd and another loop device still work as loop backing files and that loop refuses a backing file that isn't open for reading. Signed-off-by: Christian Brauner (Amutable) <[email protected]> --- tools/testing/selftests/filesystems/.gitignore | 1 + tools/testing/selftests/filesystems/Makefile | 2 +- tools/testing/selftests/filesystems/config | 9 + .../selftests/filesystems/pseudo_backing_test.c | 274 +++++++++++++++++++++ 4 files changed, 285 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/filesystems/.gitignore b/tools/testing/selftests/filesystems/.gitignore index cf79000e4092..8df38eabb125 100644 --- a/tools/testing/selftests/filesystems/.gitignore +++ b/tools/testing/selftests/filesystems/.gitignore @@ -7,3 +7,4 @@ kernfs_test idmapped_tmpfile ustat_test rw_hint_test +pseudo_backing_test diff --git a/tools/testing/selftests/filesystems/Makefile b/tools/testing/selftests/filesystems/Makefile index fbd5c27505ef..0ebb9005bcd2 100644 --- a/tools/testing/selftests/filesystems/Makefile +++ b/tools/testing/selftests/filesystems/Makefile @@ -2,7 +2,7 @@ CFLAGS += $(KHDR_INCLUDES) TEST_GEN_PROGS := devpts_pts anon_inode_test kernfs_test fclog ustat_test rw_hint_test -TEST_GEN_PROGS += idmapped_tmpfile +TEST_GEN_PROGS += idmapped_tmpfile pseudo_backing_test TEST_GEN_PROGS_EXTENDED := dnotify_test include ../lib.mk diff --git a/tools/testing/selftests/filesystems/config b/tools/testing/selftests/filesystems/config index 9f45bc493a30..228196160d29 100644 --- a/tools/testing/selftests/filesystems/config +++ b/tools/testing/selftests/filesystems/config @@ -6,3 +6,12 @@ CONFIG_NET=y CONFIG_NET_NS=y CONFIG_INET=y CONFIG_SYSFS=y +CONFIG_BLK_DEV_LOOP=y +CONFIG_OVERLAY_FS=y +CONFIG_TMPFS=y +CONFIG_CONFIGFS_FS=y +CONFIG_USB_GADGET=y +CONFIG_USB_CONFIGFS=y +CONFIG_USB_CONFIGFS_MASS_STORAGE=y +CONFIG_EROFS_FS=y +CONFIG_EROFS_FS_BACKED_BY_FILE=y diff --git a/tools/testing/selftests/filesystems/pseudo_backing_test.c b/tools/testing/selftests/filesystems/pseudo_backing_test.c new file mode 100644 index 000000000000..bc8e17ab8e6e --- /dev/null +++ b/tools/testing/selftests/filesystems/pseudo_backing_test.c @@ -0,0 +1,274 @@ +// SPDX-License-Identifier: GPL-2.0 +#define _GNU_SOURCE + +#include <errno.h> +#include <fcntl.h> +#include <limits.h> +#include <sched.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <linux/loop.h> +#include <linux/magic.h> +#include <sys/ioctl.h> +#include <sys/mman.h> +#include <sys/mount.h> +#include <sys/stat.h> +#include <sys/vfs.h> + +#include "kselftest_harness.h" +#include "wrappers.h" + +/* + * Put @fd behind a free loop device. The device is set up with + * LO_FLAGS_AUTOCLEAR and goes away again when it is closed here. + */ +static int loop_attach(int fd, bool rw, char *dev, size_t len) +{ + struct loop_config cfg = {}; + int ctl, nr, lfd, ret = 0; + + ctl = open("/dev/loop-control", O_RDWR | O_CLOEXEC); + if (ctl < 0) + return -errno; + nr = ioctl(ctl, LOOP_CTL_GET_FREE); + if (nr < 0) + ret = -errno; + close(ctl); + if (ret) + return ret; + + snprintf(dev, len, "/dev/loop%d", nr); + lfd = open(dev, (rw ? O_RDWR : O_RDONLY) | O_CLOEXEC); + if (lfd < 0) + return -errno; + + cfg.fd = fd; + cfg.info.lo_flags = LO_FLAGS_AUTOCLEAR; + if (!rw) + cfg.info.lo_flags |= LO_FLAGS_READ_ONLY; + if (ioctl(lfd, LOOP_CONFIGURE, &cfg)) { + ret = -errno; + close(lfd); + } else { + ret = lfd; + } + return ret; +} + +static int attach_path(const char *path, bool rw) +{ + char dev[PATH_MAX]; + int fd, ret; + + fd = open(path, (rw ? O_RDWR : O_RDONLY) | O_CLOEXEC); + if (fd < 0) + return -errno; + ret = loop_attach(fd, rw, dev, sizeof(dev)); + close(fd); + if (ret >= 0) { + close(ret); + ret = 0; + } + return ret; +} + +static bool can_use_loop(void) +{ + return geteuid() == 0 && access("/dev/loop-control", R_OK | W_OK) == 0; +} + +TEST(memfd_backing_file) +{ + char dev[PATH_MAX]; + int fd, lfd; + + if (!can_use_loop()) + SKIP(return, "loop devices unavailable"); + + fd = memfd_create("pseudo_backing_test", MFD_CLOEXEC); + ASSERT_GE(fd, 0); + ASSERT_EQ(ftruncate(fd, 1 << 20), 0); + + lfd = loop_attach(fd, true, dev, sizeof(dev)); + ASSERT_GE(lfd, 0); + EXPECT_EQ(close(lfd), 0); + EXPECT_EQ(close(fd), 0); +} + +TEST(loop_device_backing_file) +{ + char dev[PATH_MAX], dev2[PATH_MAX]; + int fd, lfd, bfd, lfd2; + + if (!can_use_loop()) + SKIP(return, "loop devices unavailable"); + + fd = memfd_create("pseudo_backing_test", MFD_CLOEXEC); + ASSERT_GE(fd, 0); + ASSERT_EQ(ftruncate(fd, 1 << 20), 0); + lfd = loop_attach(fd, true, dev, sizeof(dev)); + ASSERT_GE(lfd, 0); + + /* A block device stays fine as a backing file. */ + bfd = open(dev, O_RDWR | O_CLOEXEC); + ASSERT_GE(bfd, 0); + lfd2 = loop_attach(bfd, true, dev2, sizeof(dev2)); + ASSERT_GE(lfd2, 0); + + EXPECT_EQ(close(lfd2), 0); + EXPECT_EQ(close(bfd), 0); + EXPECT_EQ(close(lfd), 0); + EXPECT_EQ(close(fd), 0); +} + +TEST(write_only_backing_file) +{ + char dev[PATH_MAX], path[PATH_MAX]; + int fd, wfd, lfd; + + if (!can_use_loop()) + SKIP(return, "loop devices unavailable"); + + fd = memfd_create("pseudo_backing_test", MFD_CLOEXEC); + ASSERT_GE(fd, 0); + ASSERT_EQ(ftruncate(fd, 1 << 20), 0); + + /* Loop reads from its backing file so it must be open for reading. */ + snprintf(path, sizeof(path), "/proc/self/fd/%d", fd); + wfd = open(path, O_WRONLY | O_CLOEXEC); + ASSERT_GE(wfd, 0); + + lfd = loop_attach(wfd, true, dev, sizeof(dev)); + if (lfd >= 0) + close(lfd); + EXPECT_EQ(lfd, -EBADF); + EXPECT_EQ(close(wfd), 0); + EXPECT_EQ(close(fd), 0); +} + +TEST(procfs_backing_file) +{ + if (!can_use_loop()) + SKIP(return, "loop devices unavailable"); + + ASSERT_EQ(attach_path("/proc/cpuinfo", false), -EINVAL); +} + +TEST(sysfs_backing_file) +{ + if (!can_use_loop()) + SKIP(return, "loop devices unavailable"); + + ASSERT_EQ(attach_path("/sys/kernel/warn_count", false), -EINVAL); + + if (access("/sys/kernel/reboot/mode", F_OK)) + SKIP(return, "no /sys/kernel/reboot/mode"); + ASSERT_EQ(attach_path("/sys/kernel/reboot/mode", true), -EINVAL); +} + +TEST(overlayfs_on_sysfs_backing_file) +{ + if (!can_use_loop()) + SKIP(return, "loop devices unavailable"); + + ASSERT_EQ(unshare(CLONE_NEWNS), 0); + ASSERT_EQ(mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL), 0); + ASSERT_EQ(mount("tmpfs", "/tmp", "tmpfs", 0, NULL), 0); + ASSERT_EQ(mkdir("/tmp/empty", 0755), 0); + ASSERT_EQ(mkdir("/tmp/merged", 0755), 0); + + /* A lower-only overlayfs serves reads from sysfs. */ + if (mount("overlay", "/tmp/merged", "overlay", MS_RDONLY, + "lowerdir=/sys/kernel:/tmp/empty")) + SKIP(return, "no overlayfs on top of sysfs: %s", strerror(errno)); + + ASSERT_EQ(attach_path("/tmp/merged/warn_count", false), -EINVAL); +} + +#define CONFIGFS_DIR "/sys/kernel/config" +#define GADGET_DIR CONFIGFS_DIR "/usb_gadget/pseudo_backing_test" +#define MASS_STORAGE_DIR GADGET_DIR "/functions/mass_storage.0" + +TEST(usb_mass_storage_backing_file) +{ + const char *path = "/sys/kernel/warn_count"; + struct statfs sfs; + ssize_t ret; + int fd, err; + + if (geteuid()) + SKIP(return, "needs root"); + + /* Mounting configfs on top of itself fails with EBUSY. */ + if (statfs(CONFIGFS_DIR, &sfs) || sfs.f_type != CONFIGFS_MAGIC) { + ASSERT_EQ(unshare(CLONE_NEWNS), 0); + ASSERT_EQ(mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL), 0); + if (mount("configfs", CONFIGFS_DIR, "configfs", 0, NULL)) + SKIP(return, "no configfs: %s", strerror(errno)); + } + + if (mkdir(GADGET_DIR, 0755)) + SKIP(return, "no usb gadget configfs: %s", strerror(errno)); + if (mkdir(MASS_STORAGE_DIR, 0755)) { + err = errno; + rmdir(GADGET_DIR); + SKIP(return, "no usb mass storage function: %s", strerror(err)); + } + + /* Writing the path opens the LUN's backing file right away. */ + fd = open(MASS_STORAGE_DIR "/lun.0/file", O_WRONLY | O_CLOEXEC); + EXPECT_GE(fd, 0); + if (fd >= 0) { + ret = write(fd, path, strlen(path)); + err = errno; + EXPECT_EQ(ret, -1); + EXPECT_EQ(err, EINVAL); + EXPECT_EQ(close(fd), 0); + } + + EXPECT_EQ(rmdir(MASS_STORAGE_DIR), 0); + EXPECT_EQ(rmdir(GADGET_DIR), 0); +} + +TEST(erofs_backing_file) +{ + bool refused = false; + char buf[256]; + int fsfd, ret, err; + ssize_t n; + + if (geteuid()) + SKIP(return, "needs root"); + + fsfd = sys_fsopen("erofs", FSOPEN_CLOEXEC); + if (fsfd < 0) + SKIP(return, "no erofs: %s", strerror(errno)); + + ASSERT_EQ(sys_fsconfig(fsfd, FSCONFIG_SET_STRING, "source", + "/sys/kernel/warn_count", 0), 0); + ret = sys_fsconfig(fsfd, FSCONFIG_CMD_CREATE, NULL, NULL, 0); + err = errno; + if (ret && err == ENOTBLK) { + close(fsfd); + SKIP(return, "no file-backed erofs mounts"); + } + ASSERT_EQ(ret, -1); + ASSERT_EQ(err, EINVAL); + + /* + * Something that isn't an erofs image fails with EINVAL as well so + * check that the source itself was refused. + */ + while ((n = read(fsfd, buf, sizeof(buf) - 1)) > 0) { + buf[n] = '\0'; + if (strstr(buf, "pseudo filesystem")) + refused = true; + } + EXPECT_TRUE(refused); + EXPECT_EQ(close(fsfd), 0); +} + +TEST_HARNESS_MAIN -- 2.53.0
