fs: add failfs
Subsystems (21)
Christian Brauner
maintainerv2 cover fs: add failfs
nullfs provides a permanently empty and immutable directory. Lookups fail with ENOENT. The directory can be opened, read, stat, mounted upon. It behaves like nothing is there.
Add its counterpart failfs where the semantics are not "there is nothing here" but "nothing is supported here". Every operation that reaches the filesystem fails with EOPNOTSUPP. Even statfs()/fstatfs() fail so the filesystem cannot be discovered through an fd to it.
EOPNOTSUPP rather than a permission errno keeps that coherent. There is no permission model in which anything could ever be allowed and EACCES or EPERM would merely suggest that different credentials might succeed while EIO would suggest corruption. It also makes hitting the failfs boundary mostly quite dinstinguishable. A task anchoring its lookups at real directory file descriptors may be able to tell a failfs refusal from an ordinary permission failure. I wouldn't go so far as guaranteeing that but it should mostly work.
The root cannot be opened at all not even with O_PATH. It is never reached by a lookup in a parent directory. The only way to a path-walk terminal at the root is a jump through a /proc/<pid>/{root,cwd} magic link or by mountpoint traversal. The root also refuses ->d_weak_revalidate() which the VFS calls for jumped terminals. That closes every remaining way to reference it. An O_PATH
open is refused and name_to_handle_at() cannot encode it into a file handle, and following a magic link into it fails. A plain readlink() of such a link still works and shows "failfs:/".
There is a single instance of failfs mounted during early boot via kern_mount() making it logically distinct from every mount namespace.
Since the mount is a member of no mount namespace mounting onto it fails. So nothing can ever be mounted on top of it. It cannot be cloned via OPEN_TREE_CLONE and it does not show up in statmount()/listmount() or /proc/<pid>/mountinfo. The filesystem is not registered so it is not visible in /proc/filesystems and cannot be mounted from userspace.
This lets tasks shed their filesystem state completely. A process with its root directory or working directory in failfs must anchor every path lookup at an explicit file descriptor or is doomed to fail any lookup. Absolute paths, absolute symlinks, and AT_FDCWD-relative lookups simply fail. Followup patches will expose it via a new FD_FAILFS_ROOT file descriptor sentinel understood by fchdir() and the new fchroot() system call.
Fun fact, because of how dynamic binary execution work with PT_INTERP this also currently prevents execution of dynamic binaries because loaders have absolute paths (see selftests).
---
Changes in v2:
- Don't promise guarantees we might not want to give.
- Link to v1: https://patch.msgid.link/[email protected]
---
Christian Brauner (7):
fs: add failfs
fs: support FD_FAILFS_ROOT in fchdir()
fs: add fchroot()
fs: support FD_FAILFS_ROOT in fchroot()
arch: hookup fchroot() system call
selftests/filesystems: add failfs selftests
Documentation: add failfs documentation
Documentation/filesystems/failfs.rst | 73 +++ Documentation/filesystems/index.rst | 1 + arch/alpha/kernel/syscalls/syscall.tbl | 1 + arch/arm/tools/syscall.tbl | 1 + arch/arm64/tools/syscall_32.tbl | 1 + arch/m68k/kernel/syscalls/syscall.tbl | 1 + arch/microblaze/kernel/syscalls/syscall.tbl | 1 + arch/mips/kernel/syscalls/syscall_n32.tbl | 1 + arch/mips/kernel/syscalls/syscall_n64.tbl | 1 + arch/mips/kernel/syscalls/syscall_o32.tbl | 1 + arch/parisc/kernel/syscalls/syscall.tbl | 1 + arch/powerpc/kernel/syscalls/syscall.tbl | 1 + arch/s390/kernel/syscalls/syscall.tbl | 1 + arch/sh/kernel/syscalls/syscall.tbl | 1 + arch/sparc/kernel/syscalls/syscall.tbl | 1 + arch/x86/entry/syscalls/syscall_32.tbl | 1 + arch/x86/entry/syscalls/syscall_64.tbl | 1 + arch/xtensa/kernel/syscalls/syscall.tbl | 1 + fs/Makefile | 2 +- fs/d_path.c | 3 +- fs/failfs.c | 166 ++++++ fs/internal.h | 4 + fs/namespace.c | 1 + fs/open.c | 51 +- include/linux/syscalls.h | 1 + include/uapi/asm-generic/unistd.h | 6 +- include/uapi/linux/fcntl.h | 1 + include/uapi/linux/magic.h | 1 + scripts/syscall.tbl | 1 + tools/include/uapi/asm-generic/unistd.h | 6 +- tools/perf/arch/x86/entry/syscalls/syscall_64.tbl | 1 + tools/scripts/syscall.tbl | 1 + tools/testing/selftests/Makefile | 1 + .../selftests/filesystems/failfs/.gitignore | 2 + .../testing/selftests/filesystems/failfs/Makefile | 5 + .../selftests/filesystems/failfs/failfs_test.c | 581 +++++++++++++++++++++ 36 files changed, 919 insertions(+), 5 deletions(-)
---
base-commit: 1590cf0329716306e948a8fc29f1d3ee87d3989f
change-id: 20260723-work-failfs-d86a0c1db48d
Christian Brauner
maintainerPATCH v2 1/7 fs: add failfs
nullfs provides a permanently empty and immutable directory. Lookups fail with ENOENT. The directory can be opened, read, stat, mounted upon. It behaves like nothing is there.
Add its counterpart failfs where the semantics are not "there is nothing here" but "nothing is supported here". Every operation that reaches the filesystem fails with EOPNOTSUPP. Even statfs()/fstatfs() fail so the filesystem cannot be discovered through an fd to it.
EOPNOTSUPP rather than a permission errno keeps that coherent. There is no permission model in which anything could ever be allowed and EACCES or EPERM would merely suggest that different credentials might succeed while EIO would suggest corruption. It also makes hitting the failfs boundary mostly quite dinstinguishable. A task anchoring its lookups at real directory file descriptors may be able to tell a failfs refusal from an ordinary permission failure. I wouldn't go so far as guaranteeing that but it should mostly work.
No path lookup can open the root, not even with O_PATH. It is never reached by a lookup in a parent directory. The only way to a path-walk terminal at the root is a jump through a /proc/<pid>/{root,cwd} magic link or by mountpoint traversal. The root also refuses ->d_weak_revalidate() which the VFS calls for jumped terminals. That covers the jump-based references too: an O_PATH open is refused, name_to_handle_at() cannot encode it into a file handle, and following a magic link into it fails. A plain readlink() of such a link still works and shows "failfs:/".
There is a single instance of failfs mounted during early boot via kern_mount() making it logically distinct from every mount namespace.
Since the mount is a member of no mount namespace mounting onto it fails. So nothing can ever be mounted on top of it. It cannot be cloned via OPEN_TREE_CLONE and it does not show up in statmount()/listmount() or /proc/<pid>/mountinfo. The filesystem is not registered so it is not visible in /proc/filesystems and cannot be mounted from userspace.
This lets tasks shed their filesystem state completely. A process with its root directory or working directory in failfs must anchor every path lookup at an explicit file descriptor or is doomed to fail any lookup. Absolute paths, absolute symlinks, and AT_FDCWD-relative lookups simply fail. Followup patches will expose it via a new FD_FAILFS_ROOT file descriptor sentinel understood by fchdir() and the new fchroot() system call.
--- fs/Makefile | 2 +- fs/d_path.c | 3 +- fs/failfs.c | 155 +++++++++++++++++++++++++++++++++++++++++++++ fs/internal.h | 3 + fs/namespace.c | 1 + include/uapi/linux/magic.h | 1 + 6 files changed, 163 insertions(+), 2 deletions(-)
fs/Makefile +1 -1
@@ -16,7 +16,7 @@ obj-y := open.o read_write.o file_table.o super.o \ stack.o fs_struct.o statfs.o fs_pin.o nsfs.o \ fs_dirent.o fs_context.o fs_parser.o fsopen.o init.o \ kernel_read_file.o mnt_idmapping.o remap_range.o pidfs.o \ - file_attr.o fserror.o nullfs.o + file_attr.o fserror.o nullfs.o failfs.o obj-$(CONFIG_BUFFER_HEAD) += buffer.o mpage.o obj-$(CONFIG_PROC_FS) += proc_namespace.o
fs/d_path.c +2 -1
@@ -279,7 +279,8 @@ char *d_path(const struct path *path, char *buf, int buflen)* and instead have d_path return the mounted path. */ if (path->dentry->d_op && path->dentry->d_op->d_dname && - (!IS_ROOT (path->dentry) || path->dentry != path->mnt->mnt_root)) + (!IS_ROOT (path->dentry) || path->dentry != path->mnt->mnt_root || +failfs_mnt (path->mnt)))return path->dentry->d_op->d_dname (path->dentry, buf, buflen);rcu_read_lock ();
fs/failfs.c new file +155 -0
155 lines not on this page · raw message
fs/internal.h +3 -0
@@ -362,3 +362,6 @@ int anon_inode_setattr(struct mnt_idmap *idmap, struct dentry *dentry, struct iattr *attr);void pidfs_get_root (struct path *path);void nsfs_get_root (struct path *path); +void failfs_get_root (struct path *path); +void __init failfs_init (void ); +bool failfs_mnt (const struct vfsmount *mnt);
fs/namespace.c +1 -0
@@ -6274,6 +6274,7 @@ void __init mnt_init(void)shmem_init ();init_rootfs ();init_mount_tree (); +failfs_init (); }void put_mnt_ns (struct mnt_namespace *ns)
include/uapi/linux/magic.h +1 -0
@@ -105,5 +105,6 @@#define PID_FS_MAGIC 0x50494446/* "PIDF" */ #define GUEST_MEMFD_MAGIC 0x474d454d/* "GMEM" */ #define NULL_FS_MAGIC 0x4E554C4C/* "NULL" */ +#define FAIL_FS_MAGIC 0x4641494C/* "FAIL" */ #endif /* __LINUX_MAGIC_H__ */
Signature · 1 line
2.53.0
Christian Brauner
maintainerPATCH v2 2/7 fs: support FD_FAILFS_ROOT in fchdir()
In reply to Christian BraunerAdd a new file descriptor sentinel FD_FAILFS_ROOT following FD_PIDFS_ROOT and FD_NSFS_ROOT and teach fchdir() to accept it. A process calling fchdir(FD_FAILFS_ROOT) moves its working directory into failfs. Every AT_FDCWD-relative lookup afterwards fails with EOPNOTSUPP including "." and ".." and getcwd() reports the working directory as unreachable from the process root by returning a path prefixed with "(unreachable)". Lookups relative to explicit directory file descriptors are unaffected.
The sentinel is the only way in. No privilege or gating is required. Setting the working directory to a directory in which every operation fails grants nothing and loses nothing that closing file descriptors couldn't lose. An unlinked working directory behaves the same way today modulo errno. The working directory also plays no role in confining ".." resolution so no boundary is weakened.
--- fs/failfs.c | 11 +++++++++++ fs/internal.h | 1 + fs/open.c | 5 ++++- include/uapi/linux/fcntl.h | 1 + 4 files changed, 17 insertions(+), 1 deletion(-)
fs/failfs.c +11 -0
@@ -3,6 +3,7 @@#include <linux/fs.h> #include <linux/fs/super_types.h> #include <linux/fs_context.h> +#include <linux/fs_struct.h> #include <linux/magic.h> #include <linux/mount.h>
@@ -135,6 +136,16 @@ static int failfs_init_fs_context(struct fs_context *fc)return 0 ; } +int failfs_current_chdir (void ) +{ +struct path path; + +failfs_get_root (&path); +set_fs_pwd (current->fs, &path); +path_put (&path); +return 0 ; +} +static struct file_system_type failfs_fs_type = { .name ="failfs" , .init_fs_context = failfs_init_fs_context,
fs/internal.h +1 -0
@@ -365,3 +365,4 @@ void nsfs_get_root(struct path *path);void failfs_get_root (struct path *path);void __init failfs_init (void );bool failfs_mnt (const struct vfsmount *mnt); +int failfs_current_chdir (void );
fs/open.c +4 -1
@@ -570,9 +570,12 @@ SYSCALL_DEFINE1(chdir, const char __user *, filename) SYSCALL_DEFINE1(fchdir, unsigned int, fd) { -CLASS (fd_raw, f)(fd);int error; +if ((int )fd ==FD_FAILFS_ROOT ) +return failfs_current_chdir (); + +CLASS (fd_raw, f)(fd);if (fd_empty (f))return -EBADF ;
include/uapi/linux/fcntl.h +1 -0
@@ -124,6 +124,7 @@ struct delegation {#define FD_PIDFS_ROOT -10002/* Root of the pidfs filesystem */ #define FD_NSFS_ROOT -10003/* Root of the nsfs filesystem */ +#define FD_FAILFS_ROOT -10004/* Root of the failfs filesystem */ #define FD_INVALID -10009/* Invalid file descriptor: -10000 - EBADF = -10009 */ /* Generic flags for the *at(2) family of syscalls. */
Signature · 1 line
2.53.0
Christian Brauner
maintainerPATCH v2 3/7 fs: add fchroot()
In reply to Christian BraunerAdd a file descriptor based counterpart to chroot(2). This has been overdue for a long time. It is the natural companion to fchdir() and avoids re-resolving a path that the caller already holds a file descriptor to. No TOCTOU between resolving the target and changing the root. It composes with modern fd-based APIs meaning it works with O_PATH file descriptors and file descriptors to detached mount trees created via open_tree(OPEN_TREE_CLONE).
The permission model is identical to chroot(2). The caller must have CAP_SYS_CHROOT in its user namespace, must pass MAY_EXEC | MAY_CHDIR permission checks on the target directory, and LSMs are consulted via the same security_path_chroot() hook.
The system call takes a flags argument for future extensibility which must currently be zero.
--- fs/open.c | 29 +++++++++++++++++++++++++++++ include/linux/syscalls.h | 1 + 2 files changed, 30 insertions(+)
fs/open.c +29 -0
@@ -618,6 +618,35 @@ SYSCALL_DEFINE1(chroot, const char __user *, filename)return error; } +SYSCALL_DEFINE2(fchroot, int, fd, unsigned int, flags) +{ +int error; + +if (flags) +return -EINVAL ; + +CLASS (fd_raw, f)(fd); +if (fd_empty (f)) +return -EBADF ; + +if (!d_can_lookup (fd_file (f)->f_path.dentry)) +return -ENOTDIR ; + + error =file_permission (fd_file (f),MAY_EXEC |MAY_CHDIR ); +if (error) +return error; + +if (!ns_capable (current_user_ns (),CAP_SYS_CHROOT )) +return -EPERM ; + + error =security_path_chroot (&fd_file (f)->f_path); +if (error) +return error; + +set_fs_root (current->fs, &fd_file (f)->f_path); +return 0 ; +} +int chmod_common (const struct path *path,umode_t mode) {struct inode *inode = path->dentry->d_inode;
include/linux/syscalls.h +1 -0
@@ -457,6 +457,7 @@ asmlinkage long sys_faccessat2(int dfd, const char __user *filename, int mode,asmlinkage long sys_chdir (const char __user *filename);asmlinkage long sys_fchdir (unsigned int fd);asmlinkage long sys_chroot (const char __user *filename); +asmlinkage long sys_fchroot (int fd,unsigned int flags);asmlinkage long sys_fchmod (unsigned int fd,umode_t mode);asmlinkage long sys_fchmodat (int dfd,const char __user *filename,umode_t mode);
Signature · 1 line
2.53.0
Christian Brauner
maintainerPATCH v2 4/7 fs: support FD_FAILFS_ROOT in fchroot()
In reply to Christian BraunerAllow a process to move its root directory into failfs via fchroot(FD_FAILFS_ROOT). From that point on every absolute path lookup and every absolute symlink fails with EOPNOTSUPP. Combined with fchdir(FD_FAILFS_ROOT) this leaves the process with lookups anchored at explicit directory file descriptors only. It is the fs_struct equivalent of RESOLVE_BENEATH. This allows taks to drop their filesystem state completely.
Callers with CAP_SYS_CHROOT in their user namespace may always do this, mirroring chroot(2). Unprivileged callers are subject to three requirements (which may be loosened later):
(1) no_new_privs must be set
After entering failfs suid binaries on regular mounts remain reachable via inherited directory file descriptors or the working directory. A setuid program executing with an unusable root directory might be tricked by this. I'm not 100% convinced that this is needed but it feels more secure initially and it also forces more no_new_privs on userspace. So win-win imo.
(2) The caller must not already be chrooted.
The root directory is what confines .. resolution. The failfs root can never be reached by walking up a real mount tree. A task whose root is failfs has no .. barrier left below the top of its mount tree. A .. walk from any real directory fd it still holds climbs to the mount-namespace root. Which is kinda the point if you want to do fd-based lookup only. If failfs prevented you from doing that then it doesn't make a lot of sense.
A task that a privileged manager chrooted into a subtree could use chroot()ing into failfs as a way to allow for an inherited fd to resolve it again.
So reject already-chrooted callers closing that issue without losing anything for the intended self-sandboxing use case.
(3) The caller must not share its fs_struct.
Requirement (1) is checked on the calling thread, but the root lives in the fs_struct which may be shared via CLONE_FS. A sibling thread without no_new_privs could then execute a setuid binary with the failfs root and defeat (1). setns() to a mount or user namespace refuses a shared fs_struct for the same kind of reason, so do the same here and require fs->users == 1. no_new_privs is inherited across clone() and can never be cleared, so any CLONE_FS child created afterwards carries it too and the guarantee holds.
Privileged callers (CAP_SYS_CHROOT) are not subject to these requirements and may share the fs_struct. They can already chroot and exec a setuid binary today, so failfs hands them nothing new.
Backing out is currently hard, but that is a property of the current implementation and not a promise. current_chrooted() treats a failfs root as chrooted so for now the task cannot create user namespaces to regain CAP_SYS_CHROOT and chroot()/fchroot() back out require CAP_SYS_CHROOT. This is not guaranteed though. current_chrooted() may change, or an unprivileged no_new_privs task could be allowed to chroot to a real directory, either of which would loosen this. So don't treat it as a permanent one-way door.
The remaining way out today is setns() to a mount namespace file descriptor which requires CAP_SYS_ADMIN over the target namespace plus CAP_SYS_CHROOT and CAP_SYS_ADMIN in the caller's user namespace and resets both root and working directory. A task that closes or never had such file descriptors and restricts *chdir()/*chroot()/setns() via seccomp currently cannot get back out.
--- fs/open.c | 47 ++++++++++++++++++++++++++++++++--------------- 1 file changed, 32 insertions(+), 15 deletions(-)
fs/open.c +32 -15
@@ -620,31 +620,48 @@ SYSCALL_DEFINE1(chroot, const char __user *, filename) SYSCALL_DEFINE2(fchroot, int, fd, unsigned int, flags) { +struct path path;int error;if (flags)return -EINVAL ; -CLASS (fd_raw, f)(fd); -if (fd_empty (f)) -return -EBADF ; +if (fd ==FD_FAILFS_ROOT ) { +if (!ns_capable (current_user_ns (),CAP_SYS_CHROOT )) { +if (!task_no_new_privs (current)) +return -EPERM ; +/* A shared fs_struct lets a sibling exec setuid past the check above. */ +if (current->fs->users !=1 ) +return -EINVAL ; +/* Moving the root to failfs lifts the old root's ".." barrier. */ +if (current_chrooted ()) +return -EPERM ; + } +failfs_get_root (&path); + }else { +CLASS (fd_raw, f)(fd); +if (fd_empty (f)) +return -EBADF ; -if (!d_can_lookup (fd_file (f)->f_path.dentry)) -return -ENOTDIR ; +if (!d_can_lookup (fd_file (f)->f_path.dentry)) +return -ENOTDIR ; - error =file_permission (fd_file (f),MAY_EXEC |MAY_CHDIR ); -if (error) -return error; + error =file_permission (fd_file (f),MAY_EXEC |MAY_CHDIR ); +if (error) +return error; -if (!ns_capable (current_user_ns (),CAP_SYS_CHROOT )) -return -EPERM ; +if (!ns_capable (current_user_ns (),CAP_SYS_CHROOT )) +return -EPERM ; - error =security_path_chroot (&fd_file (f)->f_path); -if (error) -return error; + path =fd_file (f)->f_path; +path_get (&path); + } -set_fs_root (current->fs, &fd_file (f)->f_path); -return 0 ; + error =security_path_chroot (&path); +if (!error) +set_fs_root (current->fs, &path); +path_put (&path); +return error; }int chmod_common (const struct path *path,umode_t mode)
Signature · 1 line
2.53.0
Christian Brauner
maintainerPATCH v2 5/7 arch: hookup fchroot() system call
In reply to Christian BraunerWire up the fchroot() system call as number 472 on (nearly) all architectures and sync the mirrored copies of the syscall tables and the asm-generic unistd.h under tools/.
--- arch/alpha/kernel/syscalls/syscall.tbl | 1 + arch/arm/tools/syscall.tbl | 1 + arch/arm64/tools/syscall_32.tbl | 1 + arch/m68k/kernel/syscalls/syscall.tbl | 1 + arch/microblaze/kernel/syscalls/syscall.tbl | 1 + arch/mips/kernel/syscalls/syscall_n32.tbl | 1 + arch/mips/kernel/syscalls/syscall_n64.tbl | 1 + arch/mips/kernel/syscalls/syscall_o32.tbl | 1 + arch/parisc/kernel/syscalls/syscall.tbl | 1 + arch/powerpc/kernel/syscalls/syscall.tbl | 1 + arch/s390/kernel/syscalls/syscall.tbl | 1 + arch/sh/kernel/syscalls/syscall.tbl | 1 + arch/sparc/kernel/syscalls/syscall.tbl | 1 + arch/x86/entry/syscalls/syscall_32.tbl | 1 + arch/x86/entry/syscalls/syscall_64.tbl | 1 + arch/xtensa/kernel/syscalls/syscall.tbl | 1 + include/uapi/asm-generic/unistd.h | 6 +++++- scripts/syscall.tbl | 1 + tools/include/uapi/asm-generic/unistd.h | 6 +++++- tools/perf/arch/x86/entry/syscalls/syscall_64.tbl | 1 + tools/scripts/syscall.tbl | 1 + 21 files changed, 29 insertions(+), 2 deletions(-)
arch/alpha/kernel/syscalls/syscall.tbl +1 -0
@@ -511,3 +511,4 @@ 579 common file_setattr sys_file_setattr 580 common listns sys_listns 581 common rseq_slice_yield sys_rseq_slice_yield +582 common fchroot sys_fchroot
arch/arm/tools/syscall.tbl +1 -0
@@ -486,3 +486,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
arch/arm64/tools/syscall_32.tbl +1 -0
@@ -483,3 +483,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
arch/m68k/kernel/syscalls/syscall.tbl +1 -0
@@ -471,3 +471,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
arch/microblaze/kernel/syscalls/syscall.tbl +1 -0
@@ -477,3 +477,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
arch/mips/kernel/syscalls/syscall_n32.tbl +1 -0
@@ -410,3 +410,4 @@ 469 n32 file_setattr sys_file_setattr 470 n32 listns sys_listns 471 n32 rseq_slice_yield sys_rseq_slice_yield +472 n32 fchroot sys_fchroot
arch/mips/kernel/syscalls/syscall_n64.tbl +1 -0
@@ -386,3 +386,4 @@ 469 n64 file_setattr sys_file_setattr 470 n64 listns sys_listns 471 n64 rseq_slice_yield sys_rseq_slice_yield +472 n64 fchroot sys_fchroot
arch/mips/kernel/syscalls/syscall_o32.tbl +1 -0
@@ -459,3 +459,4 @@ 469 o32 file_setattr sys_file_setattr 470 o32 listns sys_listns 471 o32 rseq_slice_yield sys_rseq_slice_yield +472 o32 fchroot sys_fchroot
arch/parisc/kernel/syscalls/syscall.tbl +1 -0
@@ -470,3 +470,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
arch/powerpc/kernel/syscalls/syscall.tbl +1 -0
@@ -562,3 +562,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 nospu rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
arch/s390/kernel/syscalls/syscall.tbl +1 -0
@@ -398,3 +398,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
arch/sh/kernel/syscalls/syscall.tbl +1 -0
@@ -475,3 +475,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
arch/sparc/kernel/syscalls/syscall.tbl +1 -0
@@ -517,3 +517,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
arch/x86/entry/syscalls/syscall_32.tbl +1 -0
@@ -477,3 +477,4 @@ 469 i386 file_setattr sys_file_setattr 470 i386 listns sys_listns 471 i386 rseq_slice_yield sys_rseq_slice_yield +472 i386 fchroot sys_fchroot
arch/x86/entry/syscalls/syscall_64.tbl +1 -0
@@ -396,6 +396,7 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot # # Due to a historical design error, certain syscalls are numbered differently
arch/xtensa/kernel/syscalls/syscall.tbl +1 -0
@@ -442,3 +442,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
include/uapi/asm-generic/unistd.h +5 -1
@@ -863,8 +863,12 @@ __SYSCALL(__NR_listns, sys_listns)#define __NR_rseq_slice_yield 471__SYSCALL (__NR_rseq_slice_yield, sys_rseq_slice_yield) +/* fs/open.c */ +#define __NR_fchroot 472 +__SYSCALL(__NR_fchroot, sys_fchroot) +#undef __NR_syscalls -#define __NR_syscalls 472 +#define __NR_syscalls 473/* * 32 bit systems traditionally used different
scripts/syscall.tbl +1 -0
@@ -412,3 +412,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
tools/include/uapi/asm-generic/unistd.h +5 -1
@@ -863,8 +863,12 @@ __SYSCALL(__NR_listns, sys_listns)#define __NR_rseq_slice_yield 471__SYSCALL (__NR_rseq_slice_yield, sys_rseq_slice_yield) +/* fs/open.c */ +#define __NR_fchroot 472 +__SYSCALL(__NR_fchroot, sys_fchroot) +#undef __NR_syscalls -#define __NR_syscalls 472 +#define __NR_syscalls 473/* * 32 bit systems traditionally used different
tools/perf/arch/x86/entry/syscalls/syscall_64.tbl +1 -0
@@ -396,6 +396,7 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot # # Due to a historical design error, certain syscalls are numbered differently
tools/scripts/syscall.tbl +1 -0
@@ -412,3 +412,4 @@ 469 common file_setattr sys_file_setattr 470 common listns sys_listns 471 common rseq_slice_yield sys_rseq_slice_yield +472 common fchroot sys_fchroot
Signature · 1 line
2.53.0
Christian Brauner
maintainerPATCH v2 6/7 selftests/filesystems: add failfs selftests
In reply to Christian BraunerTest the failfs semantics and both new entry points:
- fchdir(FD_FAILFS_ROOT):
* working directory lookups and getcwd() fail
* other sentinels are rejected
* the state is recoverable while the root is untouched
- fchroot() with regular fds:
* chroot parity
* CAP_SYS_CHROOT required
* ENOTDIR/EBADF/EINVAL checks
- fchroot(FD_FAILFS_ROOT):
* absolute lookups, stat, statfs and opens of the root including O_PATH fail with EOPNOTSUPP
* dirfd-anchored I/O keeps working
* ".." walks clamp at the top of the mount tree
* /proc magic links resolve but can't be stat through
* absolute symlinks fail while relative symlinks keep resolving
- Unprivileged entry requires no_new_privs and is rejected for chrooted callers and for a shared fs_struct
- entering makes the task count as chrooted so user namespace creation fails
- Nothing can be mounted on top of failfs and OPEN_TREE_CLONE is rejected; the overmount test runs in a private mount namespace so a regression cannot touch the host root
- setns() to a kept mount namespace fd restores root and working directory
- The failfs root is inherited across fork() and absolute exec fails
- Exec by fd of a dynamically linked binary fails on opening its absolute PT_INTERP interpreter
The exec tests run the exec in a child so a wrongly successful exec cannot replace the test image and masquerade as a pass.
--- tools/testing/selftests/Makefile | 1 + .../selftests/filesystems/failfs/.gitignore | 2 + .../testing/selftests/filesystems/failfs/Makefile | 5 + .../selftests/filesystems/failfs/failfs_test.c | 581 +++++++++++++++++++++ 4 files changed, 589 insertions(+)
tools/testing/selftests/Makefile +1 -0
@@ -33,6 +33,7 @@ TARGETS += fchmodat2 TARGETS += filesystems TARGETS += filesystems/binderfs TARGETS += filesystems/epoll +TARGETS += filesystems/failfs TARGETS += filesystems/fat TARGETS += filesystems/overlayfs TARGETS += filesystems/statmount
tools/testing/selftests/filesystems/failfs/.gitignore new file +2 -0
@@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +failfs_test
tools/testing/selftests/filesystems/failfs/Makefile new file +5 -0
@@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 +CFLAGS += -Wall -O2 -g $(KHDR_INCLUDES) +TEST_GEN_PROGS := failfs_test + +include ../../lib.mk
tools/testing/selftests/filesystems/failfs/failfs_test.c new file +581 -0
581 lines not on this page · raw message
Signature · 1 line
2.53.0
Christian Brauner
maintainerPATCH v2 7/7 Documentation: add failfs documentation
In reply to Christian BraunerDocument the failfs semantics, the FD_FAILFS_ROOT sentinel, the fchroot() entry requirements, and the ways back out.
--- Documentation/filesystems/failfs.rst | 73 ++++++++++++++++++++++++++++++++++++ Documentation/filesystems/index.rst | 1 + 2 files changed, 74 insertions(+)
Documentation/filesystems/failfs.rst new file +73 -0
@@ -0,0 +1,73 @@ +.. SPDX-License-Identifier: GPL-2.0 + +====== +failfs +====== + +failfs is a kernel-internal filesystem that fails every operation +reaching it with ``EOPNOTSUPP``. It is the counterpart to nullfs. Where +nullfs is permanently empty, failfs means "nothing is supported here". +It cannot be mounted from userspace, nothing can be mounted on top of +it. It cannot be cloned. + +The only way into it is the ``FD_FAILFS_ROOT`` file descriptor sentinel which +is understood by ``fchdir(2)`` and ``fchroot(2)``. + +Semantics +========= + +Every path walk of a component through failfs fails with +``EOPNOTSUPP`` before that component is parsed, including ``.``. + +No path lookup can open the root, not even with ``O_PATH``. + +A process with its working directory in failfs fails every +``AT_FDCWD``-relative lookup. As with any working directory that is +unreachable from the process root, the ``getcwd(2)`` system call returns +a path prefixed with ``(unreachable)``. + +A process with its root directory in failfs fails every absolute path +lookup including absolute symlinks and the interpreter of dynamically +linked binaries. In other words, this fails exec. + +Lookups anchored at explicit directory file descriptors keep working. It +is the ``fs_struct`` equivalent of ``RESOLVE_BENEATH``. The process must +anchor every lookup at a file descriptor it explicitly holds. + +Entering +======== + +``fchroot(FD_FAILFS_ROOT, 0)`` requires ``CAP_SYS_CHROOT`` in the +caller's user namespace, mirroring ``chroot(2)``. Unprivileged callers +may enter if all of the following hold: + +* ``no_new_privs`` is set: setuid binaries on regular mounts remain + reachable via inherited directory file descriptors and executing them + with an unusable root directory is the classic confused deputy. + +* The caller is not already chrooted: the root directory is what + confines ``..`` resolution and the failfs root can never be reached by + walking up a real mount tree, so moving the root of a chrooted task to + failfs would allow it to escape its chroot via ``openat(fd, "..")``. + +* The caller does not share its ``fs_struct``: ``no_new_privs`` is + checked on the calling thread, but the root lives in the ``fs_struct``. + A ``CLONE_FS`` sibling without ``no_new_privs`` could otherwise execute + a setuid binary with the failfs root, so entry requires ``fs->users == + 1``, the same restriction ``setns(2)`` applies for the mount and user + namespaces. + +Leaving +======= + +Backing out is currently hard, but this is a property of the current +implementation, not a guaranteed interface, and may be loosened later. +For now a process that entered failfs counts as chrooted, so it cannot +create user namespaces to regain ``CAP_SYS_CHROOT``, and ``chroot(2)`` +or ``fchroot(2)`` back out require ``CAP_SYS_CHROOT``. The remaining way +out today is ``setns(2)`` with a mount namespace file descriptor, which +requires ``CAP_SYS_ADMIN`` over the target mount namespace as well as +``CAP_SYS_CHROOT`` and ``CAP_SYS_ADMIN`` in the caller's user namespace +and resets both root and working directory. A process that holds no such +file descriptor and restricts ``*chdir()``/``*chroot()``/``setns()`` via +seccomp cannot currently get back out.
Documentation/filesystems/index.rst +1 -0
@@ -91,6 +91,7 @@ Documentation for filesystem implementations. ext3 ext4/index f2fs + failfs gfs2/index hfs hfsplus
Signature · 1 line
2.53.0