From nobody Fri Jul 24 21:29:04 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EE0E8471247; Thu, 23 Jul 2026 11:30:38 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806240; cv=none; b=e0/tcnbw0tOQgbzFb3F986ztdO+IbZFp5ZbjingcDtDO8jtUAcegbUhkhRQ08ATwGkUBlbrSz1rPjOUQ84TTqei9j0p63Oyjo4rQiwRVitEjaHBKOkmnrAxLSAfx757NJZaNE1xI5qF7f54uzsPrB5r89uyjkJMGSZ6ez4VVPOY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806240; c=relaxed/simple; bh=4d9+/HYmgwPaGOCiJNy5HdkFp7nA85NuXik9e/ndA0U=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=FKcjoo8AV3LhQew+DbrMbsYDmVc3n6Yy+7p8JcjagLytARnhtrUf/IJjjv0ZHFGsT1eOqi8JSpo8NqFO7DJx97oz0l2OMJOMp0+JqytrDbHVeUWkquGZr6f53fz74J706ejdV6ThBDPHCS7KsUBgZbTHZNOM81eleWnzsTfP1R4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Ssqs8UUG; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Ssqs8UUG" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9753B1F00A3A; Thu, 23 Jul 2026 11:30:35 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784806238; bh=cbonWmvpVjsI4El5Jr1VjZ6RhpNeiBJBx+P1i417Ft0=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=Ssqs8UUGKN/gGi8OwtokndYqNp/Z4869n+4mhA6LC5RZDc+RLRHcI7O4H2ICrazq9 Rq5NTrKT1MgWF2Tg8tR2NszOYI6Wpc2Du5IcZ+FLnTeSg68nLV6+/mvsDX7fHvxVQl nIxSXY0S5aiIZ7v1Vt7ZRVO7EXQrv6vPqCaThfPwsL1YVfjXw9QkhSTXerxzFQZtu3 fvsHB0L50uF0n0oIrE+j19f9/2tStqDPFPSpKjIZPWA/TWmkCePP+ZJkQZtQ0QeQqN uY91iFhWhpkhS71/6ZBOVYv5iEGOe0jEi5YFccbFbLTI+KXYz8ZCmby4EALbjwkqRh iyYiezzanrfFg== From: Christian Brauner Date: Thu, 23 Jul 2026 13:30:20 +0200 Subject: [PATCH RFC 1/7] fs: add failfs Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260723-work-failfs-v1-1-3f69b9a9e958@kernel.org> References: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> In-Reply-To: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> To: linux-fsdevel@vger.kernel.org, Andy Lutomirski , Jann Horn Cc: John Ericson , linux-api@vger.kernel.org, "H. Peter Anvin" , Kees Cook , Farid Zakaria , Alexander Viro , Christian Brauner , Jan Kara , linux-kernel@vger.kernel.org, Jonathan Corbet , linux-doc@vger.kernel.org X-Mailer: b4 0.16-dev-0e65f X-Developer-Signature: v=1; a=openpgp-sha256; l=8589; i=brauner@kernel.org; h=from:subject:message-id; bh=4d9+/HYmgwPaGOCiJNy5HdkFp7nA85NuXik9e/ndA0U=; b=owGbwMvMwCU28Zj0gdSKO4sYT6slMWQl/g4P7Th8NeTWvMTk0tzXORW/XTRkpHK8+NM3f5q9d XKf3HP9jlIWBjEuBlkxRRaHdpNwueU8FZuNMjVg5rAygQxh4OIUgImsOMnwV/Aqz41D7wvmnXn6 um93yzbW0sdb3J+2d2xR+F2lMb27+A3DP4UFx9asa1U8+KOs4I1+6lQF5z2H+E1SSxQqfLaKnfR y5wEA X-Developer-Key: i=brauner@kernel.org; a=openpgp; fpr=4880B8C9BD0E5106FC070F4F7B3C391EFEA93624 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//{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 "/". 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//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. Signed-off-by: Christian Brauner (Amutable) --- fs/Makefile | 2 +- fs/failfs.c | 144 +++++++++++++++++++++++++++++++++++++++++= ++++ fs/internal.h | 2 + fs/namespace.c | 1 + include/uapi/linux/magic.h | 1 + 5 files changed, 149 insertions(+), 1 deletion(-) diff --git a/fs/Makefile b/fs/Makefile index 89a8a9d207d1..73b6cab7738e 100644 --- a/fs/Makefile +++ b/fs/Makefile @@ -16,7 +16,7 @@ obj-y :=3D 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 =20 obj-$(CONFIG_BUFFER_HEAD) +=3D buffer.o mpage.o obj-$(CONFIG_PROC_FS) +=3D proc_namespace.o diff --git a/fs/failfs.c b/fs/failfs.c new file mode 100644 index 000000000000..f9d4ba791928 --- /dev/null +++ b/fs/failfs.c @@ -0,0 +1,144 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright (c) 2026 Christian Brauner */ +#include +#include +#include +#include +#include + +#include "internal.h" + +static struct path failfs_root_path =3D {}; + +void failfs_get_root(struct path *path) +{ + *path =3D failfs_root_path; + path_get(path); +} + +static int failfs_permission(struct mnt_idmap *idmap, struct inode *inode, + int mask) +{ + return -EOPNOTSUPP; +} + +static struct dentry *failfs_lookup(struct inode *dir, struct dentry *dent= ry, + unsigned int flags) +{ + /* Unreachable: ->permission() already failed the walk. */ + return ERR_PTR(-EOPNOTSUPP); +} + +static int failfs_getattr(struct mnt_idmap *idmap, const struct path *path, + struct kstat *stat, u32 request_mask, + unsigned int query_flags) +{ + return -EOPNOTSUPP; +} + +static const struct inode_operations failfs_dir_inode_operations =3D { + .permission =3D failfs_permission, + .lookup =3D failfs_lookup, + .getattr =3D failfs_getattr, +}; + +static const struct file_operations failfs_dir_operations =3D {}; + +static int failfs_d_weak_revalidate(struct dentry *dentry, unsigned int fl= ags) +{ + /* + * The root is only ever reached as a path-walk terminal by jumping + * to it: as "/" when it is the caller's root, or through a + * /proc//{root,cwd} magic link. ->permission() already fails + * every walk of a component, but a jump lands on the root without + * one. Refuse here too so the root cannot be pinned by an O_PATH + * open or encoded into a file handle. + */ + return -EOPNOTSUPP; +} + +static const struct dentry_operations failfs_dentry_operations =3D { + .d_weak_revalidate =3D failfs_d_weak_revalidate, +}; + +static int failfs_statfs(struct dentry *dentry, struct kstatfs *buf) +{ + return -EOPNOTSUPP; +} + +static const struct super_operations failfs_super_operations =3D { + .statfs =3D failfs_statfs, +}; + +static int failfs_fill_super(struct super_block *s, struct fs_context *fc) +{ + struct inode *inode; + + s->s_maxbytes =3D MAX_LFS_FILESIZE; + s->s_blocksize =3D PAGE_SIZE; + s->s_blocksize_bits =3D PAGE_SHIFT; + s->s_magic =3D FAIL_FS_MAGIC; + s->s_op =3D &failfs_super_operations; + s->s_export_op =3D NULL; + s->s_xattr =3D NULL; + s->s_time_gran =3D 1; + s->s_d_flags =3D 0; + + inode =3D new_inode(s); + if (!inode) + return -ENOMEM; + + /* failfs supports no operations... */ + inode->i_mode =3D S_IFDIR; + set_nlink(inode, 2); + inode->i_op =3D &failfs_dir_inode_operations; + inode->i_fop =3D &failfs_dir_operations; + simple_inode_init_ts(inode); + inode->i_ino =3D 1; + /* ... and is immutable. */ + inode->i_flags |=3D S_IMMUTABLE; + + set_default_d_op(s, &failfs_dentry_operations); + s->s_root =3D d_make_root(inode); + if (!s->s_root) + return -ENOMEM; + + return 0; +} + +static int failfs_get_tree(struct fs_context *fc) +{ + return get_tree_single(fc, failfs_fill_super); +} + +static const struct fs_context_operations failfs_context_ops =3D { + .get_tree =3D failfs_get_tree, +}; + +static int failfs_init_fs_context(struct fs_context *fc) +{ + fc->ops =3D &failfs_context_ops; + fc->global =3D true; + fc->sb_flags |=3D SB_NOUSER; + fc->s_iflags |=3D SB_I_NOEXEC | SB_I_NODEV; + return 0; +} + +static struct file_system_type failfs_fs_type =3D { + .name =3D "failfs", + .init_fs_context =3D failfs_init_fs_context, + .kill_sb =3D kill_anon_super, +}; + +void __init failfs_init(void) +{ + struct vfsmount *mnt; + + /* A single instance that is member of no mount namespace. */ + mnt =3D kern_mount(&failfs_fs_type); + if (IS_ERR(mnt)) + panic("VFS: Failed to create failfs"); + + failfs_root_path.mnt =3D mnt; + failfs_root_path.dentry =3D mnt->mnt_root; +} diff --git a/fs/internal.h b/fs/internal.h index 355d93f92208..b6d38a5794eb 100644 --- a/fs/internal.h +++ b/fs/internal.h @@ -362,3 +362,5 @@ 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); diff --git a/fs/namespace.c b/fs/namespace.c index 3d5cd5bf3b05..87c365f2f82b 100644 --- a/fs/namespace.c +++ b/fs/namespace.c @@ -6274,6 +6274,7 @@ void __init mnt_init(void) shmem_init(); init_rootfs(); init_mount_tree(); + failfs_init(); } =20 void put_mnt_ns(struct mnt_namespace *ns) diff --git a/include/uapi/linux/magic.h b/include/uapi/linux/magic.h index 4f2da935a76c..fd5f0e95648e 100644 --- a/include/uapi/linux/magic.h +++ b/include/uapi/linux/magic.h @@ -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" */ =20 #endif /* __LINUX_MAGIC_H__ */ --=20 2.53.0 From nobody Fri Jul 24 21:29:04 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B41B7471404; Thu, 23 Jul 2026 11:30:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806243; cv=none; b=QC3UjomjVDk+VhEV5clMYeh01E5zhU3vQXOK4sl8EaakJq9YyJkcJ9kDU9kjmfJFIhxiF9ySBisFt563ODsa76cHyBvJXGGdj8DgdP1iBa7cl896gkppS8nKWAjnC9Aey9/OnYx76iTAPoMRIvIj55p3V/SAajCqf3KAtKuWMzQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806243; c=relaxed/simple; bh=tC3xgOSMixqGYj7WJSGU1GS+MJM6f45b2gdvWBDSnRM=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=gq8N3xqxheT9vrp6wURzMwhvJ5H6x0fGRGO95Eu1arB13EeyYqc2dYeuPeHJbDUtd4ZivDdhvk6pxyg9hVoHqZn+xlsYbk/ELZZH/AjDoPyGu9eHl0dkRmhsWOVs2qASjZ6GObYMNM5WZv36e14hDRJy5ZfVdXmFX8EC8cTT9jo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=LRG07n0w; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="LRG07n0w" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 52FD81F000E9; Thu, 23 Jul 2026 11:30:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784806242; bh=pVI7AJeinyX5LZhsfwQWEU7lkoMKsXW0aPkqO59bTGQ=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=LRG07n0wokP0EWSSv6KuVJBY1x+0s9JzCmepZxiSYdP+GQf5cCUtkKCePyM+LsJDr 6TtVzU3QNXNUlDhvnW4l/Zctay5ELCX0X6i3v2pkjjRQe6h9bUIqxu+dPyb8YGZ4ic II8fgFpGSVCt88SdQNjltK/2iIZhU1PdSm3dDvluNFeidLXDC413543diL9LdnX8gL Em8EAEY0mdL8QHJMItSl/+nkMzEVvVk73vSJAq7Qr9yvKYwwkldJEmnuistn505i/V yPhIj5Xb52nVnGiZhkwmzTWBzPJBorJXTF9sc2H6HY7gf+zUvwFXAIRVjl1bCv1McG ua581oHVTZfdA== From: Christian Brauner Date: Thu, 23 Jul 2026 13:30:21 +0200 Subject: [PATCH RFC 2/7] fs: add FD_FAILFS_ROOT and support it in fchdir() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260723-work-failfs-v1-2-3f69b9a9e958@kernel.org> References: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> In-Reply-To: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> To: linux-fsdevel@vger.kernel.org, Andy Lutomirski , Jann Horn Cc: John Ericson , linux-api@vger.kernel.org, "H. Peter Anvin" , Kees Cook , Farid Zakaria , Alexander Viro , Christian Brauner , Jan Kara , linux-kernel@vger.kernel.org, Jonathan Corbet , linux-doc@vger.kernel.org X-Mailer: b4 0.16-dev-0e65f X-Developer-Signature: v=1; a=openpgp-sha256; l=3232; i=brauner@kernel.org; h=from:subject:message-id; bh=tC3xgOSMixqGYj7WJSGU1GS+MJM6f45b2gdvWBDSnRM=; b=owGbwMvMwCU28Zj0gdSKO4sYT6slMWQl/g7/ufmR0v+f/x0+7uafMGP16efzfqd4HQhZddYk2 Y0rZpm3YUcpC4MYF4OsmCKLQ7tJuNxynorNRpkaMHNYmUCGMHBxCsBE0hIZGc6WLfh0zlvl2AsN 8SZt0VmGM0vymxo9zp1mP7eY1UFxkiXD/6pTr780/ZOMnqlV+bpUaWVyhCiPwqrTvMF/5ubdlTQ 0ZQIA X-Developer-Key: i=brauner@kernel.org; a=openpgp; fpr=4880B8C9BD0E5106FC070F4F7B3C391EFEA93624 Add 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. Signed-off-by: Christian Brauner (Amutable) --- 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(-) diff --git a/fs/failfs.c b/fs/failfs.c index f9d4ba791928..f37e6af9c03c 100644 --- a/fs/failfs.c +++ b/fs/failfs.c @@ -3,6 +3,7 @@ #include #include #include +#include #include #include =20 @@ -124,6 +125,16 @@ static int failfs_init_fs_context(struct fs_context *f= c) return 0; } =20 +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 =3D { .name =3D "failfs", .init_fs_context =3D failfs_init_fs_context, diff --git a/fs/internal.h b/fs/internal.h index b6d38a5794eb..b3c88d999dec 100644 --- a/fs/internal.h +++ b/fs/internal.h @@ -364,3 +364,4 @@ 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); +int failfs_current_chdir(void); diff --git a/fs/open.c b/fs/open.c index 408925d7bd0b..56b6032d4d81 100644 --- a/fs/open.c +++ b/fs/open.c @@ -570,9 +570,12 @@ SYSCALL_DEFINE1(chdir, const char __user *, filename) =20 SYSCALL_DEFINE1(fchdir, unsigned int, fd) { - CLASS(fd_raw, f)(fd); int error; =20 + if ((int)fd =3D=3D FD_FAILFS_ROOT) + return failfs_current_chdir(); + + CLASS(fd_raw, f)(fd); if (fd_empty(f)) return -EBADF; =20 diff --git a/include/uapi/linux/fcntl.h b/include/uapi/linux/fcntl.h index aadfbf6e0cb3..e43e3de3e9ee 100644 --- a/include/uapi/linux/fcntl.h +++ b/include/uapi/linux/fcntl.h @@ -124,6 +124,7 @@ struct delegation { =20 #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 =3D= -10009 */ =20 /* Generic flags for the *at(2) family of syscalls. */ --=20 2.53.0 From nobody Fri Jul 24 21:29:04 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 30BAE471CF3; Thu, 23 Jul 2026 11:30:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806249; cv=none; b=MwfrIDSI1qIFUNQs++k742EDFGpiTWaLLVB86eMHvFU0VwbAdAWAh1jjlvO4QJmNJKC7ih27j+IgwCwEppD6yAhnstJFDOtB9V2uS1/xa1jrrXorC0pQIjbR8srEKLMGtCWkS0IvftIgVQR/Y1kR3Unaxyt4dOzrhOShqC3IIxA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806249; c=relaxed/simple; bh=QeyHf0dBOuekHuS6Q6V8exUEh7qyASDiJjuWd8I++yM=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=esg5IUnXFQj3MvQfcAY+fthJ7On6k13XtuAQ54Ra1L/Gk8GMi+OSZEl9abpwJsHDe8pxccF5i81C9Wo+PdyC6XUWzK8kaa9TJPcIuy47A2iA+CD812B+8xQ1Tfy66k+4HXFV2aoib4bCuiapdk2Ve+zoZ+1I0JiW8OkAeJHVbFU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=dXvhydE4; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="dXvhydE4" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0278E1F00A3A; Thu, 23 Jul 2026 11:30:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784806246; bh=kL222Q7bZV1iEsYup1nUUuglGOFcK2eaek04QbM40+0=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=dXvhydE4RCXkBFqhcOoOvoyjbGrViCWMuuM+CfOL6DQ2vDp+KOylOkN7MoT/TNcyU u7glF1Fwe+PcqyTbQSWWDx7ICK1M5n/4a1UsNn8B6Di2FqS7hBJnXOVvghUeTeZK5y AxeQwZ5OQ9ndV8TPzF7oncpfdSMLeIkXgktZpWLj4nyRVDxC9v2o/yO5zE1sXuPjHH Yn2iiUDMpruqXHnRQygiG3le+32DjpDJx/wJu7/tQcXpadCX7QTf+oLI+iROugpNhq 6C6NOFYTQI1ab1BBOqquMEq2v9Gly3zWeJRvNNJXvOwqUFLH3hrZ7XAzKgVG/JHFiX 5BxSPjNhO0GPw== From: Christian Brauner Date: Thu, 23 Jul 2026 13:30:22 +0200 Subject: [PATCH RFC 3/7] fs: add fchroot() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260723-work-failfs-v1-3-3f69b9a9e958@kernel.org> References: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> In-Reply-To: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> To: linux-fsdevel@vger.kernel.org, Andy Lutomirski , Jann Horn Cc: John Ericson , linux-api@vger.kernel.org, "H. Peter Anvin" , Kees Cook , Farid Zakaria , Alexander Viro , Christian Brauner , Jan Kara , linux-kernel@vger.kernel.org, Jonathan Corbet , linux-doc@vger.kernel.org X-Mailer: b4 0.16-dev-0e65f X-Developer-Signature: v=1; a=openpgp-sha256; l=2585; i=brauner@kernel.org; h=from:subject:message-id; bh=QeyHf0dBOuekHuS6Q6V8exUEh7qyASDiJjuWd8I++yM=; b=owGbwMvMwCU28Zj0gdSKO4sYT6slMWQl/g5PqWuQ0d+ZpOG8uXtyplb70dLkvMsF112SnijPf 9n70cqso5SFQYyLQVZMkcWh3SRcbjlPxWajTA2YOaxMIEMYuDgFYCKf5Rn+l1vNVrnGuKi6qfFo xYbSi+8WLFp+gsHh8FGhu16nlpRsDWL4H7xHXt9MuVJox9UXym9yr/rVloV1Wr08La+kyCWg6f2 ECwA= X-Developer-Key: i=brauner@kernel.org; a=openpgp; fpr=4880B8C9BD0E5106FC070F4F7B3C391EFEA93624 Add 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). Rhe 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. Signed-off-by: Christian Brauner (Amutable) --- fs/open.c | 29 +++++++++++++++++++++++++++++ include/linux/syscalls.h | 1 + 2 files changed, 30 insertions(+) diff --git a/fs/open.c b/fs/open.c index 56b6032d4d81..c57f641f2e29 100644 --- a/fs/open.c +++ b/fs/open.c @@ -618,6 +618,35 @@ SYSCALL_DEFINE1(chroot, const char __user *, filename) return error; } =20 +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 =3D 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 =3D 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 =3D path->dentry->d_inode; diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h index 874d9067a43b..8413b624ad47 100644 --- a/include/linux/syscalls.h +++ b/include/linux/syscalls.h @@ -457,6 +457,7 @@ asmlinkage long sys_faccessat2(int dfd, const char __us= er *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); --=20 2.53.0 From nobody Fri Jul 24 21:29:04 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 00760470430; Thu, 23 Jul 2026 11:30:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806254; cv=none; b=NWJIldrqcm4oJbwHogk3m4hgrFmm9ZbikRSdGQknXpcP7FuEBt4iZoFINSkbCeerHiYf/CeDqF9/31sJsStms0GYkkyJ6vI/sZ2LMbpFsWunjYdgCvEBevZh57+T5RNJIw0TkCdsEGRdQVvrzUxheh/40sU9InVplRD9PPmmWYs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806254; c=relaxed/simple; bh=yqO6vurUVKadnYgpnL4LMFtHuyT4slGfIqlnKKYdgCY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=eLWV6mxpyeAAeMiQfBEdS8N3Bwdd89YF8EFmbifW+JFeiiVvZI70Cs+Q2Wk0OLc6Mu0CA6UCseJXR0ZJbWpNyPeVa0Gf7/TMVnZCHHuylPhYvGW2uFrZjFr1szuNf1mKBPtByhxmSZ57BZYYWc7E93RYVD1la+ZyqCdnELxZcRA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=PX+UDEc9; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="PX+UDEc9" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8D0F81F000E9; Thu, 23 Jul 2026 11:30:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784806249; bh=FwpYn/7CVQ0Kudm+A/0Wp/DqAAY0gvJL5RppLdjSL8Q=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=PX+UDEc9N4UI4hSIG7wzkVlj3XC18kCFee5bSjxnyjKokFRhKcRhoN2wLWJbPNkhW ObYo9p/lDmp6GNK7llNrVVlQ7ysztJht5Ll3QB2KihJdvFuFFXR5hmQnJjjG89Kl92 8ClwOta63fGbiiuOchOaKIVC8Xqgo+7lQPrageQ9041dMvNXQjozK89YAjHILOhb1a SeWrpqau3JzMS2Xuw637ZQj5vaHDb1GOjMRQdLqAo8JlsgMhIYP3PNVZTHcODoyalB 938cZ26q+HGaNBHvzQgcz2HMLigfFEbT3oMs5tTbPS7oICK9rAfH66JmKHZX4wHjey N7ITFibQJR0Sg== From: Christian Brauner Date: Thu, 23 Jul 2026 13:30:23 +0200 Subject: [PATCH RFC 4/7] fs: support FD_FAILFS_ROOT in fchroot() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260723-work-failfs-v1-4-3f69b9a9e958@kernel.org> References: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> In-Reply-To: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> To: linux-fsdevel@vger.kernel.org, Andy Lutomirski , Jann Horn Cc: John Ericson , linux-api@vger.kernel.org, "H. Peter Anvin" , Kees Cook , Farid Zakaria , Alexander Viro , Christian Brauner , Jan Kara , linux-kernel@vger.kernel.org, Jonathan Corbet , linux-doc@vger.kernel.org X-Mailer: b4 0.16-dev-0e65f X-Developer-Signature: v=1; a=openpgp-sha256; l=3927; i=brauner@kernel.org; h=from:subject:message-id; bh=yqO6vurUVKadnYgpnL4LMFtHuyT4slGfIqlnKKYdgCY=; b=owGbwMvMwCU28Zj0gdSKO4sYT6slMWQl/g53vvF46aXr1v/LP+l+yd+8nE3f8LTQjhvXEmf/0 Ayt+eiwsqOUhUGMi0FWTJHFod0kXG45T8Vmo0wNmDmsTCBDGLg4BWAiNv0M/51PfUt+tv/nUq1J 64Nrc37cjTZmLz9nYNB99Irlk6prSzYxMpxeza2fUBsZdPTNwnXmazI9p7t90Otc0nOj8eoToYB vy7kA X-Developer-Key: i=brauner@kernel.org; a=openpgp; fpr=4880B8C9BD0E5106FC070F4F7B3C391EFEA93624 Allow 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 two 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. There's also some thought needed around shared fs_struct state. It's obviously possible to chroot into failfs with a shared fs_struct if the caller has CAP_SYS_CHROOT and shares the fs_struct or if the caller is no_new_privs and shares the fs_struct. The non-chrooted-currently requirement still applies. Once entered, failfs is a throw-away-the-key moment. The task is considered chrooted so it cannot create user namespaces to regain CAP_SYS_CHROOT. chroot()/fchroot() back out require CAP_SYS_CHROOT. The only other exit 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 process that closes or never had such file descriptors and restricts *chdir()/*chroot()/setns() via seccomp has thrown away the key. Signed-off-by: Christian Brauner (Amutable) --- fs/open.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/fs/open.c b/fs/open.c index c57f641f2e29..8adc9f00889a 100644 --- a/fs/open.c +++ b/fs/open.c @@ -618,6 +618,27 @@ SYSCALL_DEFINE1(chroot, const char __user *, filename) return error; } =20 +static int fchroot_failfs(void) +{ + struct path path; + int error; + + if (!ns_capable(current_user_ns(), CAP_SYS_CHROOT)) { + if (!task_no_new_privs(current)) + return -EPERM; + /* Moving the root to failfs lifts the old root's ".." barrier. */ + if (current_chrooted()) + return -EPERM; + } + + failfs_get_root(&path); + error =3D security_path_chroot(&path); + if (!error) + set_fs_root(current->fs, &path); + path_put(&path); + return error; +} + SYSCALL_DEFINE2(fchroot, int, fd, unsigned int, flags) { int error; @@ -625,6 +646,9 @@ SYSCALL_DEFINE2(fchroot, int, fd, unsigned int, flags) if (flags) return -EINVAL; =20 + if (fd =3D=3D FD_FAILFS_ROOT) + return fchroot_failfs(); + CLASS(fd_raw, f)(fd); if (fd_empty(f)) return -EBADF; --=20 2.53.0 From nobody Fri Jul 24 21:29:04 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3F0F1471D0A; Thu, 23 Jul 2026 11:30:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806259; cv=none; b=KTKEnQuIH9JCZUIUcApHQhPZ2Cw5TxzKqINeoy1Y4ApbSa6Ajs6qA5TBwtJLjziAPC8ndD0RqIuc/ySAYUSTRF493c+eYWybglTOL3j6gkF/GDhEmN9jbaKHdTuy9/2w+RFIM8r0P36q9jDbAxlHkGPDYOwpqg6fp//tpm51eW4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806259; c=relaxed/simple; bh=nRFC9CX4rCzP8lIbZ4N7tGTayMaHlcSYceXYpg2Mxj0=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=c1PukNjQEihIL54ZAZZmJyfQYTNLt+fQ5ztRuPDfncYzQCUSs3OKhZavNxdKAxAfKllRiFcuxUrc5cARtkZ3crk0gTkj2qCUS//n3mFL7Su9oPOv9bHMcgtwU16VzyUGSoVfzcBhaAFz84JwU3nWa9pYmhzQtIuovUJ+QSQ81JI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CuLpC7FD; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="CuLpC7FD" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 35BF61F00A3A; Thu, 23 Jul 2026 11:30:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784806253; bh=7wG6mcm6Vty+OoAzAwdyWoiMNMaLRj8Y82jQaGy06/s=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=CuLpC7FD2nFcbHe4KpGdRfsFEtWbReDCYF6tWT6/PnCZrQNBA2nMcUlXkXE0KDizv Bfj8Lu+rgSoV6pRSODLbtuzniURVUW3YE5FsODbHD7SB7Hd8DzIsVx0hGfrEt0FSSi K37XPEw6tz0tyA+lUeu/z1+6uh+j3ldThj2KKAkqNvaDM4ARYTgI89AMgA83gtWYTz JSrB03f49Ryaq6vsaO9o8e8Qw+3dYJWB+5zC4+xQPGv0MFMiTGRqqK5miwAAtmE2sA 1sFIIDmuXm76bmMKjV8w3HrIYDgl0u5mwdu0nmZ5+T5cjxq2rObSuO48n4yq9AfpMC yHxsSuz9+muOw== From: Christian Brauner Date: Thu, 23 Jul 2026 13:30:24 +0200 Subject: [PATCH RFC 5/7] arch: hookup fchroot() system call Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260723-work-failfs-v1-5-3f69b9a9e958@kernel.org> References: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> In-Reply-To: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> To: linux-fsdevel@vger.kernel.org, Andy Lutomirski , Jann Horn Cc: John Ericson , linux-api@vger.kernel.org, "H. Peter Anvin" , Kees Cook , Farid Zakaria , Alexander Viro , Christian Brauner , Jan Kara , linux-kernel@vger.kernel.org, Jonathan Corbet , linux-doc@vger.kernel.org X-Mailer: b4 0.16-dev-0e65f X-Developer-Signature: v=1; a=openpgp-sha256; l=8736; i=brauner@kernel.org; h=from:subject:message-id; bh=nRFC9CX4rCzP8lIbZ4N7tGTayMaHlcSYceXYpg2Mxj0=; b=owGbwMvMwCU28Zj0gdSKO4sYT6slMWQl/g7vSujN3dLLceqA7NOYG//N/O4o8uz933Tiuuj+L wlib+QYOkpZGMS4GGTFFFkc2k3C5ZbzVGw2ytSAmcPKBDKEgYtTACbS2M7wz7zY495zl2r56ZP0 TIr6F9gW+6yYxtn+lXvDX2tvg3NKYowMm1ZzrJ/+80bB6vAqvUhRn/sHvv/be01tb23xsWORuft zGAE= X-Developer-Key: i=brauner@kernel.org; a=openpgp; fpr=4880B8C9BD0E5106FC070F4F7B3C391EFEA93624 Wire up the fchroot() system call as number 472 on (nearly) all architectures. Signed-off-by: Christian Brauner (Amutable) --- 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 + 18 files changed, 22 insertions(+), 1 deletion(-) diff --git a/arch/alpha/kernel/syscalls/syscall.tbl b/arch/alpha/kernel/sys= calls/syscall.tbl index f31b7afffc34..52e3538cc7df 100644 --- a/arch/alpha/kernel/syscalls/syscall.tbl +++ b/arch/alpha/kernel/syscalls/syscall.tbl @@ -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 diff --git a/arch/arm/tools/syscall.tbl b/arch/arm/tools/syscall.tbl index 94351e22bfcf..55717ed32c27 100644 --- a/arch/arm/tools/syscall.tbl +++ b/arch/arm/tools/syscall.tbl @@ -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 diff --git a/arch/arm64/tools/syscall_32.tbl b/arch/arm64/tools/syscall_32.= tbl index 62d93d88e0fe..df2d1d82fb3c 100644 --- a/arch/arm64/tools/syscall_32.tbl +++ b/arch/arm64/tools/syscall_32.tbl @@ -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 diff --git a/arch/m68k/kernel/syscalls/syscall.tbl b/arch/m68k/kernel/sysca= lls/syscall.tbl index 248934257101..ba7a4d8903d0 100644 --- a/arch/m68k/kernel/syscalls/syscall.tbl +++ b/arch/m68k/kernel/syscalls/syscall.tbl @@ -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 diff --git a/arch/microblaze/kernel/syscalls/syscall.tbl b/arch/microblaze/= kernel/syscalls/syscall.tbl index 223d26303627..c55a5c96f49b 100644 --- a/arch/microblaze/kernel/syscalls/syscall.tbl +++ b/arch/microblaze/kernel/syscalls/syscall.tbl @@ -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 diff --git a/arch/mips/kernel/syscalls/syscall_n32.tbl b/arch/mips/kernel/s= yscalls/syscall_n32.tbl index 7430714e2b8f..9ae88e4eac61 100644 --- a/arch/mips/kernel/syscalls/syscall_n32.tbl +++ b/arch/mips/kernel/syscalls/syscall_n32.tbl @@ -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 diff --git a/arch/mips/kernel/syscalls/syscall_n64.tbl b/arch/mips/kernel/s= yscalls/syscall_n64.tbl index 630aab9e5425..83dc93a0712f 100644 --- a/arch/mips/kernel/syscalls/syscall_n64.tbl +++ b/arch/mips/kernel/syscalls/syscall_n64.tbl @@ -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 diff --git a/arch/mips/kernel/syscalls/syscall_o32.tbl b/arch/mips/kernel/s= yscalls/syscall_o32.tbl index 128653112284..9c62429c9b7b 100644 --- a/arch/mips/kernel/syscalls/syscall_o32.tbl +++ b/arch/mips/kernel/syscalls/syscall_o32.tbl @@ -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 diff --git a/arch/parisc/kernel/syscalls/syscall.tbl b/arch/parisc/kernel/s= yscalls/syscall.tbl index c6331dad9461..88adc4016cce 100644 --- a/arch/parisc/kernel/syscalls/syscall.tbl +++ b/arch/parisc/kernel/syscalls/syscall.tbl @@ -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 diff --git a/arch/powerpc/kernel/syscalls/syscall.tbl b/arch/powerpc/kernel= /syscalls/syscall.tbl index 4fcc7c58a105..cfbb70039ff0 100644 --- a/arch/powerpc/kernel/syscalls/syscall.tbl +++ b/arch/powerpc/kernel/syscalls/syscall.tbl @@ -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 diff --git a/arch/s390/kernel/syscalls/syscall.tbl b/arch/s390/kernel/sysca= lls/syscall.tbl index 09a7ef04d979..1b45e68a217b 100644 --- a/arch/s390/kernel/syscalls/syscall.tbl +++ b/arch/s390/kernel/syscalls/syscall.tbl @@ -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 diff --git a/arch/sh/kernel/syscalls/syscall.tbl b/arch/sh/kernel/syscalls/= syscall.tbl index 70b315cbe710..ace068dff0de 100644 --- a/arch/sh/kernel/syscalls/syscall.tbl +++ b/arch/sh/kernel/syscalls/syscall.tbl @@ -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 diff --git a/arch/sparc/kernel/syscalls/syscall.tbl b/arch/sparc/kernel/sys= calls/syscall.tbl index 7e71bf7fcd14..5b9fe0e8140f 100644 --- a/arch/sparc/kernel/syscalls/syscall.tbl +++ b/arch/sparc/kernel/syscalls/syscall.tbl @@ -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 diff --git a/arch/x86/entry/syscalls/syscall_32.tbl b/arch/x86/entry/syscal= ls/syscall_32.tbl index f832ebd2d79b..2c172ef48dfd 100644 --- a/arch/x86/entry/syscalls/syscall_32.tbl +++ b/arch/x86/entry/syscalls/syscall_32.tbl @@ -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 diff --git a/arch/x86/entry/syscalls/syscall_64.tbl b/arch/x86/entry/syscal= ls/syscall_64.tbl index 524155d655da..d5b6045b0090 100644 --- a/arch/x86/entry/syscalls/syscall_64.tbl +++ b/arch/x86/entry/syscalls/syscall_64.tbl @@ -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 =20 # # Due to a historical design error, certain syscalls are numbered differen= tly diff --git a/arch/xtensa/kernel/syscalls/syscall.tbl b/arch/xtensa/kernel/s= yscalls/syscall.tbl index a9bca4e484de..d354bb231796 100644 --- a/arch/xtensa/kernel/syscalls/syscall.tbl +++ b/arch/xtensa/kernel/syscalls/syscall.tbl @@ -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 diff --git a/include/uapi/asm-generic/unistd.h b/include/uapi/asm-generic/u= nistd.h index a627acc8fb5f..5b7e77a7c736 100644 --- a/include/uapi/asm-generic/unistd.h +++ b/include/uapi/asm-generic/unistd.h @@ -863,8 +863,12 @@ __SYSCALL(__NR_listns, sys_listns) #define __NR_rseq_slice_yield 471 __SYSCALL(__NR_rseq_slice_yield, sys_rseq_slice_yield) =20 +/* fs/open.c */ +#define __NR_fchroot 472 +__SYSCALL(__NR_fchroot, sys_fchroot) + #undef __NR_syscalls -#define __NR_syscalls 472 +#define __NR_syscalls 473 =20 /* * 32 bit systems traditionally used different diff --git a/scripts/syscall.tbl b/scripts/syscall.tbl index 7a42b32b6577..0ab531605120 100644 --- a/scripts/syscall.tbl +++ b/scripts/syscall.tbl @@ -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 --=20 2.53.0 From nobody Fri Jul 24 21:29:04 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6C389471D08; Thu, 23 Jul 2026 11:30:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806262; cv=none; b=j6E2DqPaE/NJNXsWT8ULqkdj+xreqK80ir8vxuIxXvG3YNeLPsnQ7DDCY/z+hWtoOYFODew+9nsG37bN+GUIF6Eypt5UX1mvvdILcK8lkJRL7psYJn/wGXAuXCs202ThTsFB5Ifa57C6RmvZg11+0ic4E18pg+WMtF0weiDl81M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806262; c=relaxed/simple; bh=vFXiXoVUxO1QCodz9oNE7hdlOxGBkQK/Z+ArOePUT2Y=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=ZUNc5lE9umj9T7ELsT9CrYvcvPgW1F7UANjxmQ/jjxsm24JCGSRjO9Ud17VRfXYGsPOFiS4aEfEhmAeu9T13P2nXWWShlJrvrPZSFzgvDKP7QspPnZT/6Uk4N2zQ4Ld1MidTnvsMmHCKvPTlz2W41iZcO3gvyZUjNdC2PB0cBNo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=btZWbONO; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="btZWbONO" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 088471F00A3D; Thu, 23 Jul 2026 11:30:53 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784806257; bh=tJiX3ngcmfU/eSYvrRQatTq7LvqG5d1qHmyj7E88yk0=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=btZWbONOB56MbCj7ulbYya/wU07oIEi7pnq0jzHv/exT+asFJqw6EWe7sP3pXM2NL 0nirVTgdUTu9FcJGYJ6ub3HBRRVOuCuznWNvjqdUhFb0laFT8QEN2U7C8xN1QgHGJF VlkNG5I9xAcmVqJV+o7EwCpkF6rgdeJEeJBBxRNOR7Fsc+OA/3k0eAwx5N1XFbp2/q dnvWRmsi7TJrjGsMkECf6Vt+N50lwfT+f2tV0eaUrXzgr2SRKXkIEZdVbuwR0zdrG4 s1b9RuQTJmesuFtmAd+kA9w+SXSyIcO3iuVaQZnjP2fqWh4aDAAgV+Ednzq9ip08Ta 6kuvV9CVW/13Q== From: Christian Brauner Date: Thu, 23 Jul 2026 13:30:25 +0200 Subject: [PATCH RFC 6/7] selftests/filesystems: add failfs selftests Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260723-work-failfs-v1-6-3f69b9a9e958@kernel.org> References: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> In-Reply-To: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> To: linux-fsdevel@vger.kernel.org, Andy Lutomirski , Jann Horn Cc: John Ericson , linux-api@vger.kernel.org, "H. Peter Anvin" , Kees Cook , Farid Zakaria , Alexander Viro , Christian Brauner , Jan Kara , linux-kernel@vger.kernel.org, Jonathan Corbet , linux-doc@vger.kernel.org X-Mailer: b4 0.16-dev-0e65f X-Developer-Signature: v=1; a=openpgp-sha256; l=17417; i=brauner@kernel.org; h=from:subject:message-id; bh=vFXiXoVUxO1QCodz9oNE7hdlOxGBkQK/Z+ArOePUT2Y=; b=owGbwMvMwCU28Zj0gdSKO4sYT6slMWQl/g6XsnRv7b791dP67gwDwVffLyWyn1EQ0VxteOTCK 49FPKsaOkpZGMS4GGTFFFkc2k3C5ZbzVGw2ytSAmcPKBDKEgYtTACbSV8bI0H7NkZubu4ZT5K7h 1umVDGbmjed8tfZ+3VSbG7uu88rv8wx/BcqOHrZS4d4z3VVQUujdgtWVEmI/e0677FGxmpf01jK UGQA= X-Developer-Key: i=brauner@kernel.org; a=openpgp; fpr=4880B8C9BD0E5106FC070F4F7B3C391EFEA93624 Test 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 f= ail 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 - 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 - 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 Signed-off-by: Christian Brauner (Amutable) --- tools/testing/selftests/Makefile | 1 + .../selftests/filesystems/failfs/.gitignore | 2 + .../testing/selftests/filesystems/failfs/Makefile | 5 + .../selftests/filesystems/failfs/failfs_test.c | 506 +++++++++++++++++= ++++ 4 files changed, 514 insertions(+) diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Mak= efile index 8d4db2241cc2..f87167bcf582 100644 --- a/tools/testing/selftests/Makefile +++ b/tools/testing/selftests/Makefile @@ -33,6 +33,7 @@ TARGETS +=3D fchmodat2 TARGETS +=3D filesystems TARGETS +=3D filesystems/binderfs TARGETS +=3D filesystems/epoll +TARGETS +=3D filesystems/failfs TARGETS +=3D filesystems/fat TARGETS +=3D filesystems/overlayfs TARGETS +=3D filesystems/statmount diff --git a/tools/testing/selftests/filesystems/failfs/.gitignore b/tools/= testing/selftests/filesystems/failfs/.gitignore new file mode 100644 index 000000000000..cd3b5d884d7e --- /dev/null +++ b/tools/testing/selftests/filesystems/failfs/.gitignore @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +failfs_test diff --git a/tools/testing/selftests/filesystems/failfs/Makefile b/tools/te= sting/selftests/filesystems/failfs/Makefile new file mode 100644 index 000000000000..3c5d98b4fe72 --- /dev/null +++ b/tools/testing/selftests/filesystems/failfs/Makefile @@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 +CFLAGS +=3D -Wall -O2 -g $(KHDR_INCLUDES) +TEST_GEN_PROGS :=3D failfs_test + +include ../../lib.mk diff --git a/tools/testing/selftests/filesystems/failfs/failfs_test.c b/too= ls/testing/selftests/filesystems/failfs/failfs_test.c new file mode 100644 index 000000000000..bb72a3d2102b --- /dev/null +++ b/tools/testing/selftests/filesystems/failfs/failfs_test.c @@ -0,0 +1,506 @@ +// SPDX-License-Identifier: GPL-2.0 +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../../kselftest_harness.h" + +#ifndef __NR_fchroot +#define __NR_fchroot 472 +#endif + +#ifndef FD_PIDFS_ROOT +#define FD_PIDFS_ROOT -10002 +#endif + +#ifndef FD_NSFS_ROOT +#define FD_NSFS_ROOT -10003 +#endif + +#ifndef FD_FAILFS_ROOT +#define FD_FAILFS_ROOT -10004 +#endif + +#define NOBODY_UID 65534 + +static int sys_fchroot(int fd, unsigned int flags) +{ + return syscall(__NR_fchroot, fd, flags); +} + +/* + * Raw syscall: glibc's getcwd() rejects the kernel's "(unreachable)" + * result and falls back to a generic implementation. + */ +static long sys_getcwd(char *buf, size_t size) +{ + return syscall(__NR_getcwd, buf, size); +} + +static int drop_to_nobody(void) +{ + return setresuid(NOBODY_UID, NOBODY_UID, NOBODY_UID); +} + +/* Is fd a dynamically linked ELF with an absolute PT_INTERP interpreter? = */ +static int elf_has_absolute_interp(int fd) +{ + ElfW(Ehdr) ehdr; + ElfW(Phdr) phdr; + char interp; + int i; + + if (pread(fd, &ehdr, sizeof(ehdr), 0) !=3D sizeof(ehdr)) + return 0; + if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) !=3D 0) + return 0; + + for (i =3D 0; i < ehdr.e_phnum; i++) { + if (pread(fd, &phdr, sizeof(phdr), + ehdr.e_phoff + i * sizeof(phdr)) !=3D sizeof(phdr)) + return 0; + if (phdr.p_type !=3D PT_INTERP) + continue; + if (pread(fd, &interp, 1, phdr.p_offset) !=3D 1) + return 0; + return interp =3D=3D '/'; + } + + return 0; +} + +TEST(fchdir_sentinel) +{ + char buf[PATH_MAX]; + int fd; + + ASSERT_EQ(fchdir(FD_FAILFS_ROOT), 0); + + /* The working directory is unreachable from the process root. */ + ASSERT_GT(sys_getcwd(buf, sizeof(buf)), 0); + ASSERT_EQ(strncmp(buf, "(unreachable)", 13), 0); + + /* Every AT_FDCWD-relative lookup fails. */ + ASSERT_EQ(openat(AT_FDCWD, "foo", O_RDONLY), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + ASSERT_EQ(openat(AT_FDCWD, ".", O_RDONLY), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + ASSERT_EQ(openat(AT_FDCWD, "..", O_RDONLY), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + ASSERT_EQ(openat(AT_FDCWD, "foo", O_WRONLY | O_CREAT, 0600), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + + /* The cwd cannot be pinned by following /proc/self/cwd into it. */ + ASSERT_EQ(open("/proc/self/cwd", O_PATH), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + + /* The root is untouched so absolute lookups keep working... */ + fd =3D open("/", O_RDONLY | O_DIRECTORY); + ASSERT_GE(fd, 0); + ASSERT_EQ(close(fd), 0); + + /* ... and the working directory can be recovered. */ + ASSERT_EQ(chdir("/"), 0); + ASSERT_GT(sys_getcwd(buf, sizeof(buf)), 0); + ASSERT_EQ(strcmp(buf, "/"), 0); +} + +TEST(fchdir_rejects_other_sentinels) +{ + ASSERT_EQ(fchdir(FD_PIDFS_ROOT), -1); + ASSERT_EQ(errno, EBADF); + ASSERT_EQ(fchdir(FD_NSFS_ROOT), -1); + ASSERT_EQ(errno, EBADF); + ASSERT_EQ(fchdir(-10009), -1); + ASSERT_EQ(errno, EBADF); +} + +TEST(fchroot_flags) +{ + int fd; + + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 1), -1); + ASSERT_EQ(errno, EINVAL); + + fd =3D open("/", O_PATH | O_DIRECTORY); + ASSERT_GE(fd, 0); + ASSERT_EQ(sys_fchroot(fd, 1), -1); + ASSERT_EQ(errno, EINVAL); + ASSERT_EQ(close(fd), 0); +} + +TEST(fchroot_bad_fd) +{ + ASSERT_EQ(sys_fchroot(-1, 0), -1); + ASSERT_EQ(errno, EBADF); + + /* Only FD_FAILFS_ROOT is a valid sentinel. */ + ASSERT_EQ(sys_fchroot(FD_PIDFS_ROOT, 0), -1); + ASSERT_EQ(errno, EBADF); + ASSERT_EQ(sys_fchroot(FD_NSFS_ROOT, 0), -1); + ASSERT_EQ(errno, EBADF); +} + +TEST(fchroot_notdir) +{ + int fd; + + fd =3D open("/proc/self/status", O_RDONLY); + ASSERT_GE(fd, 0); + ASSERT_EQ(sys_fchroot(fd, 0), -1); + ASSERT_EQ(errno, ENOTDIR); + ASSERT_EQ(close(fd), 0); +} + +TEST(fchroot_realfd_requires_cap) +{ + int fd; + + if (geteuid() =3D=3D 0) + ASSERT_EQ(drop_to_nobody(), 0); + + fd =3D open("/", O_PATH | O_DIRECTORY); + ASSERT_GE(fd, 0); + ASSERT_EQ(sys_fchroot(fd, 0), -1); + ASSERT_EQ(errno, EPERM); + ASSERT_EQ(close(fd), 0); +} + +TEST(fchroot_realfd) +{ + char template[] =3D "/tmp/failfs_test.XXXXXX"; + char path[PATH_MAX]; + struct stat st; + int tmpfd, dfd, fd; + + if (geteuid() !=3D 0) + SKIP(return, "fchroot() with a regular fd requires CAP_SYS_CHROOT"); + + tmpfd =3D open("/tmp", O_PATH | O_DIRECTORY); + ASSERT_GE(tmpfd, 0); + + ASSERT_NE(mkdtemp(template), NULL); + snprintf(path, sizeof(path), "%s/canary", template); + fd =3D open(path, O_WRONLY | O_CREAT, 0600); + ASSERT_GE(fd, 0); + ASSERT_EQ(close(fd), 0); + + dfd =3D open(template, O_PATH | O_DIRECTORY); + ASSERT_GE(dfd, 0); + ASSERT_EQ(sys_fchroot(dfd, 0), 0); + ASSERT_EQ(close(dfd), 0); + + ASSERT_EQ(stat("/canary", &st), 0); + + /* Best-effort cleanup: dirfd-anchored I/O works with the new root. */ + snprintf(path, sizeof(path), "%s/canary", template + strlen("/tmp/")); + unlinkat(tmpfd, path, 0); + unlinkat(tmpfd, template + strlen("/tmp/"), AT_REMOVEDIR); +} + +TEST(fchroot_sentinel) +{ + char template[] =3D "/tmp/failfs_test.XXXXXX"; + struct stat realroot, st; + struct statfs sfs; + char buf[PATH_MAX]; + int procfd, tmpfd, dfd, fd; + struct { + struct file_handle handle; + unsigned char f_handle[MAX_HANDLE_SZ]; + } fh; + int mntid; + ssize_t ret; + + if (geteuid() !=3D 0) + SKIP(return, "privileged fchroot(FD_FAILFS_ROOT) requires CAP_SYS_CHROOT= "); + + ASSERT_EQ(stat("/", &realroot), 0); + procfd =3D open("/proc", O_PATH | O_DIRECTORY); + ASSERT_GE(procfd, 0); + tmpfd =3D open("/tmp", O_PATH | O_DIRECTORY); + ASSERT_GE(tmpfd, 0); + ASSERT_NE(mkdtemp(template), NULL); + dfd =3D open(template, O_RDONLY | O_DIRECTORY); + ASSERT_GE(dfd, 0); + + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 0), 0); + + /* Absolute lookups fail. */ + ASSERT_EQ(open("/etc/passwd", O_RDONLY), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + ASSERT_EQ(mkdir("/foo", 0700), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + + /* + * The root cannot be referenced at all - not even an O_PATH open, + * which skips ->permission(), because it lands on the root as a + * jumped walk terminal that ->d_weak_revalidate() refuses. + */ + ASSERT_EQ(open("/", O_RDONLY | O_DIRECTORY), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + ASSERT_EQ(open("/", O_PATH), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + ASSERT_EQ(statfs("/", &sfs), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + + /* + * It cannot be pinned by following /proc/self/root into it either + * (only the root is in failfs here, so self/cwd is still real). + */ + ASSERT_EQ(openat(procfd, "self/root", O_PATH), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + + /* Nor encoded into a file handle. */ + fh.handle.handle_bytes =3D MAX_HANDLE_SZ; + ASSERT_EQ(name_to_handle_at(AT_FDCWD, "/", &fh.handle, &mntid, 0), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + + /* The working directory is now unreachable from the root. */ + ASSERT_GT(sys_getcwd(buf, sizeof(buf)), 0); + ASSERT_EQ(strncmp(buf, "(unreachable)", 13), 0); + + /* Lookups anchored at real directories keep working. */ + fd =3D openat(AT_FDCWD, ".", O_RDONLY | O_DIRECTORY); + ASSERT_GE(fd, 0); + ASSERT_EQ(close(fd), 0); + fd =3D openat(dfd, "canary", O_WRONLY | O_CREAT, 0600); + ASSERT_GE(fd, 0); + ASSERT_EQ(write(fd, "x", 1), 1); + ASSERT_EQ(close(fd), 0); + fd =3D openat(dfd, "canary", O_RDONLY); + ASSERT_GE(fd, 0); + ASSERT_EQ(close(fd), 0); + + /* ".." walks clamp at the top of the mount tree, not at failfs. */ + fd =3D openat(AT_FDCWD, "../../../../../../../../../..", O_PATH); + ASSERT_GE(fd, 0); + ASSERT_EQ(fstat(fd, &st), 0); + ASSERT_EQ(st.st_dev, realroot.st_dev); + ASSERT_EQ(st.st_ino, realroot.st_ino); + ASSERT_EQ(close(fd), 0); + + /* readlink of the magic link still works: it does not follow. */ + ret =3D readlinkat(procfd, "self/root", buf, sizeof(buf) - 1); + ASSERT_GT(ret, 0); + buf[ret] =3D '\0'; + TH_LOG("/proc/self/root points to '%s'", buf); + + /* But following it into failfs is refused. */ + ASSERT_EQ(fstatat(procfd, "self/root", &st, 0), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + + /* Best-effort cleanup via the pre-opened dirfds. */ + unlinkat(dfd, "canary", 0); + unlinkat(tmpfd, template + strlen("/tmp/"), AT_REMOVEDIR); +} + +TEST(fchroot_sentinel_absolute_symlink) +{ + char template[] =3D "/tmp/failfs_test.XXXXXX"; + int tmpfd, dfd, fd; + + if (geteuid() !=3D 0) + SKIP(return, "privileged fchroot(FD_FAILFS_ROOT) requires CAP_SYS_CHROOT= "); + + tmpfd =3D open("/tmp", O_PATH | O_DIRECTORY); + ASSERT_GE(tmpfd, 0); + ASSERT_NE(mkdtemp(template), NULL); + dfd =3D open(template, O_RDONLY | O_DIRECTORY); + ASSERT_GE(dfd, 0); + + fd =3D openat(dfd, "target", O_WRONLY | O_CREAT, 0600); + ASSERT_GE(fd, 0); + ASSERT_EQ(close(fd), 0); + ASSERT_EQ(symlinkat("target", dfd, "rel"), 0); + ASSERT_EQ(symlinkat("/etc", dfd, "abs"), 0); + + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 0), 0); + + /* Relative symlinks keep resolving within the dirfd-anchored walk... */ + fd =3D openat(dfd, "rel", O_RDONLY); + ASSERT_GE(fd, 0); + ASSERT_EQ(close(fd), 0); + + /* ... absolute symlinks restart the walk at the failfs root. */ + ASSERT_EQ(openat(dfd, "abs", O_RDONLY), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + + /* Best-effort cleanup via the pre-opened dirfds. */ + unlinkat(dfd, "abs", 0); + unlinkat(dfd, "rel", 0); + unlinkat(dfd, "target", 0); + unlinkat(tmpfd, template + strlen("/tmp/"), AT_REMOVEDIR); +} + +TEST(fchroot_sentinel_unprivileged) +{ + char buf[PATH_MAX]; + + if (geteuid() =3D=3D 0) + ASSERT_EQ(drop_to_nobody(), 0); + + /* Without no_new_privs entering failfs is not allowed... */ + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 0), -1); + ASSERT_EQ(errno, EPERM); + + /* ... with no_new_privs set it is allowed. */ + ASSERT_EQ(prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0), 0); + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 0), 0); + + ASSERT_EQ(open("/etc/passwd", O_RDONLY), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + + /* The task counts as chrooted: no user namespaces anymore. */ + ASSERT_EQ(unshare(CLONE_NEWUSER), -1); + ASSERT_EQ(errno, EPERM); + + /* With both root and cwd in failfs getcwd() reports "/". */ + ASSERT_EQ(fchdir(FD_FAILFS_ROOT), 0); + ASSERT_GT(sys_getcwd(buf, sizeof(buf)), 0); + ASSERT_EQ(strcmp(buf, "/"), 0); +} + +TEST(fchroot_sentinel_rejected_when_chrooted) +{ + char template[] =3D "/tmp/failfs_test.XXXXXX"; + int tmpfd; + + if (geteuid() !=3D 0) + SKIP(return, "chroot() requires CAP_SYS_CHROOT"); + + tmpfd =3D open("/tmp", O_PATH | O_DIRECTORY); + ASSERT_GE(tmpfd, 0); + ASSERT_NE(mkdtemp(template), NULL); + ASSERT_EQ(chroot(template), 0); + ASSERT_EQ(chdir("/"), 0); + + /* Remove the jail while still privileged; sticky /tmp blocks nobody. */ + unlinkat(tmpfd, template + strlen("/tmp/"), AT_REMOVEDIR); + + ASSERT_EQ(drop_to_nobody(), 0); + ASSERT_EQ(prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0), 0); + + /* An unprivileged chrooted task must not lift its ".." barrier. */ + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 0), -1); + ASSERT_EQ(errno, EPERM); +} + +TEST(fchroot_sentinel_no_overmount) +{ + if (geteuid() !=3D 0) + SKIP(return, "mounting requires privileges"); + + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 0), 0); + + /* + * Nothing can be mounted on top of the failfs root. It cannot even + * be named as a mount target: resolving "/" is refused before the + * mount machinery (which, failfs being in no mount namespace, would + * reject it anyway) is ever reached. open_tree(OPEN_TREE_CLONE) is + * likewise moot since no fd to the root can be obtained. + */ + ASSERT_EQ(mount("none", "/", "tmpfs", 0, NULL), -1); + ASSERT_EQ(errno, EOPNOTSUPP); +} + +TEST(fchroot_sentinel_setns_escape) +{ + struct stat realroot, st; + int nsfd; + + if (geteuid() !=3D 0) + SKIP(return, "setns() to a mount namespace requires privileges"); + + ASSERT_EQ(stat("/", &realroot), 0); + nsfd =3D open("/proc/self/ns/mnt", O_RDONLY); + ASSERT_GE(nsfd, 0); + + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 0), 0); + ASSERT_EQ(open("/etc", O_PATH), -1); + ASSERT_EQ(errno, EOPNOTSUPP); + + /* A mount namespace fd is the key out: it resets root and cwd. */ + ASSERT_EQ(setns(nsfd, CLONE_NEWNS), 0); + ASSERT_EQ(close(nsfd), 0); + + ASSERT_EQ(stat("/", &st), 0); + ASSERT_EQ(st.st_dev, realroot.st_dev); + ASSERT_EQ(st.st_ino, realroot.st_ino); +} + +TEST(fchroot_sentinel_exec) +{ + if (geteuid() !=3D 0) + SKIP(return, "privileged fchroot(FD_FAILFS_ROOT) requires CAP_SYS_CHROOT= "); + + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 0), 0); + + ASSERT_EQ(execl("/bin/true", "true", NULL), -1); + ASSERT_EQ(errno, EOPNOTSUPP); +} + +TEST(fchroot_sentinel_exec_interpreter) +{ + static const char * const argv[] =3D { "failfs_test", NULL }; + static const char * const envp[] =3D { NULL }; + int exefd; + + if (geteuid() !=3D 0) + SKIP(return, "privileged fchroot(FD_FAILFS_ROOT) requires CAP_SYS_CHROOT= "); + + /* Exec ourselves: the one binary guaranteed to be around. */ + exefd =3D open("/proc/self/exe", O_RDONLY); + ASSERT_GE(exefd, 0); + if (!elf_has_absolute_interp(exefd)) + SKIP(return, "test binary has no absolute PT_INTERP interpreter"); + + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 0), 0); + + /* + * The binary itself needs no path lookup - it is executed by fd - + * but loading it fails on opening the absolute PT_INTERP + * interpreter. + */ + ASSERT_EQ(syscall(__NR_execveat, exefd, "", argv, envp, + AT_EMPTY_PATH), -1); + ASSERT_EQ(errno, EOPNOTSUPP); +} + +TEST(fchroot_sentinel_inherited) +{ + pid_t pid; + int status; + + if (geteuid() !=3D 0) + SKIP(return, "privileged fchroot(FD_FAILFS_ROOT) requires CAP_SYS_CHROOT= "); + + ASSERT_EQ(sys_fchroot(FD_FAILFS_ROOT, 0), 0); + + pid =3D fork(); + ASSERT_GE(pid, 0); + if (pid =3D=3D 0) { + if (open("/etc", O_PATH) !=3D -1 || errno !=3D EOPNOTSUPP) + _exit(1); + _exit(0); + } + ASSERT_EQ(waitpid(pid, &status, 0), pid); + ASSERT_TRUE(WIFEXITED(status)); + ASSERT_EQ(WEXITSTATUS(status), 0); +} + +TEST_HARNESS_MAIN --=20 2.53.0 From nobody Fri Jul 24 21:29:04 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 81719471D0C; Thu, 23 Jul 2026 11:31:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806263; cv=none; b=S8oUppYTLjb2UlQafbli5ivJe30WWTkWj33Pk5VbnaBxyUFXMc7xIY0dL+zjBYLPV3MPEWPlVacnKsn/jgd9BnQnDWYnSi4T/StpTAGQgoCNozEEagEEFqxixJ4v1zUxZmPQWC2isbxzf/df4oKLuxuzRCdQZxYiIBGvjxeraww= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784806263; c=relaxed/simple; bh=C++APXasOEg8g/XQcYBrRPDHVq5h8OHVddjqmZ0vcd8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=b54A3CJye76J52LeAYHMMvkRqHPubw7KbTG8kXvye7LMejsekSqBPgIF+GAoh3TNiXeJS+UebQQZHscvsHsUgASNMOq8mMex5GGRlgr9JmYQKO6Eb8zPlFa3vZvewCOAlz9AldyzuZUiQ0bCCGG5Qut7Ckj6ulc/agIm+ra9TF0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=EftVfQ47; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="EftVfQ47" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B42081F00A3E; Thu, 23 Jul 2026 11:30:57 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784806261; bh=xARf2O0qu7qCYZPDkTyhea6H3gAN0CxcFQpfXrpAzPY=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=EftVfQ47BWM2HcE46jmhKFntDoTIzB/h1rEI3b48MkBs8Rqxr84orUugmhpH1sG+O +oXOS+DVsSuAYCJzr0jCVsfUg2l5HqzrR9qryFl5nvJEiUI+O8qrySo7mUNHUqtkQ+ AmcPNXhqvG3+icJXR4YCb9f7Kmi4IHuIoy/wyPnx4usLkC4/MV0D0sxZzrIvbXWhnN lzRBeM14zn8YzsZNL3UEmrVSsfF97gZDKbXL5+DjH/BzdKG/5bv4/01NbUlTOyN4ac J8Lfo8fIHK9lFmKVQwnpcHG0lzDu3n03P/Wn34lWIqajX/Cg1xXoQ4X75caz9v6hlr 7b+sj91K+gxAg== From: Christian Brauner Date: Thu, 23 Jul 2026 13:30:26 +0200 Subject: [PATCH RFC 7/7] Documentation: add failfs documentation Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260723-work-failfs-v1-7-3f69b9a9e958@kernel.org> References: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> In-Reply-To: <20260723-work-failfs-v1-0-3f69b9a9e958@kernel.org> To: linux-fsdevel@vger.kernel.org, Andy Lutomirski , Jann Horn Cc: John Ericson , linux-api@vger.kernel.org, "H. Peter Anvin" , Kees Cook , Farid Zakaria , Alexander Viro , Christian Brauner , Jan Kara , linux-kernel@vger.kernel.org, Jonathan Corbet , linux-doc@vger.kernel.org X-Mailer: b4 0.16-dev-0e65f X-Developer-Signature: v=1; a=openpgp-sha256; l=3730; i=brauner@kernel.org; h=from:subject:message-id; bh=C++APXasOEg8g/XQcYBrRPDHVq5h8OHVddjqmZ0vcd8=; b=owGbwMvMwCU28Zj0gdSKO4sYT6slMWQl/g4XSZigIL1NyNJvr9vGC0WqzsceKu0MDztz8cMRI 9Egq8KyjhIWBjEuBlkxRRaHdpNwueU8FZuNMjVg5rAygQxh4OIUgIlIHWb4psib9p+7LV5x3ZbO F1ZCnzeJeSyvv/HDJmmhzeVLmU28DP8L2yTeH/haLiSY0lOnsDOyI12O+//WuXzmUbEvwt4s2cA CAA== X-Developer-Key: i=brauner@kernel.org; a=openpgp; fpr=4880B8C9BD0E5106FC070F4F7B3C391EFEA93624 Document the failfs semantics, the FD_FAILFS_ROOT sentinel, the fchroot() entry requirements, and the ways back out. Signed-off-by: Christian Brauner (Amutable) --- Documentation/filesystems/failfs.rst | 64 ++++++++++++++++++++++++++++++++= ++++ Documentation/filesystems/index.rst | 1 + 2 files changed, 65 insertions(+) diff --git a/Documentation/filesystems/failfs.rst b/Documentation/filesyste= ms/failfs.rst new file mode 100644 index 000000000000..46d91525916b --- /dev/null +++ b/Documentation/filesystems/failfs.rst @@ -0,0 +1,64 @@ +.. SPDX-License-Identifier: GPL-2.0 + +=3D=3D=3D=3D=3D=3D +failfs +=3D=3D=3D=3D=3D=3D + +failfs is a kernel-internal filesystem that fails every operation +reaching it with ``EOPNOTSUPP``. It is the counterpart to nullfs. Where +nullfs is a 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 wh= ich +is understood by ``fchdir(2)`` and ``fchroot(2)``. + +Semantics +=3D=3D=3D=3D=3D=3D=3D=3D=3D + +Every path walk of a component through failfs fails with +``EOPNOTSUPP`` before that component is parsed, including ``.``. + +The root itself cannot be opened at all 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 +=3D=3D=3D=3D=3D=3D=3D=3D + +``fchroot(FD_FAILFS_ROOT, 0)`` requires ``CAP_SYS_CHROOT`` in the +caller's user namespace, mirroring ``chroot(2)``. Unprivileged callers +may enter if both 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, "..")``. + +Leaving +=3D=3D=3D=3D=3D=3D=3D + +A process that entered failfs counts as chrooted. It cannot create user +namespaces to regain ``CAP_SYS_CHROOT``, and ``chroot(2)`` or +``fchroot(2)`` back out require ``CAP_SYS_CHROOT``. The only other exit +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 has thrown away the key. diff --git a/Documentation/filesystems/index.rst b/Documentation/filesystem= s/index.rst index 1f71cf159547..734a45e51667 100644 --- a/Documentation/filesystems/index.rst +++ b/Documentation/filesystems/index.rst @@ -91,6 +91,7 @@ Documentation for filesystem implementations. ext3 ext4/index f2fs + failfs gfs2/index hfs hfsplus --=20 2.53.0