fs: don't use pseudo filesystem files as storage
Subsystems (39)
Christian Brauner
maintainerv2 cover fs: don't use pseudo filesystem files as storage
Loop happily takes any regular file with ->read_iter() as a backing file and any file that also has ->write_iter() as a writable one. A few examples:
* /proc/kcore attaches read-only as a loop device the size of the kernel's virtual address space (64 PiB with 5-level paging)
* sysfs attributes attach read-write as 4096 byte loop devices
* using /sys/kernel/mm/transparent_hugepage/enabled for the loop device and writing a block to the loop device changes the THP setting
It's not just silly. It's abusable (is that a word?). Loop calls ->read_iter() and ->write_iter() of the backing file directly from its kworker which runs with kernel credentials.
But pseudo files enforce part of their access rules at read and write against the caller. So dozens of sysfs ->show() and ->store() methods call capable().
But setting up a loop device requires no capabilities. It only requires access to the device nodes. So whoever has a loop device skips all of the capable() checks.
A couple of fun examples:
On v7.4-rc1 uid 0 without any capabilities can't kill a process of uid 1000 and can't poison its memory either:
$ grep CapEff /proc/self/status
CapEff: 0000000000000000
$ kill -9 327
bash: kill: (327) - Operation not permitted
$ echo 0x220689000 > /sys/devices/system/memory/hard_offline_page
bash: echo: write error: Operation not permittedBut put hard_offline_page behind a loop device, write a block containing 0x220689000 to the loop device and the loop worker happily does it:
Memory failure: 0x220689: recovery action for dirty LRU page: Recovered
MCE: Killing victim:327 due to hardware memory corruption fault at 7f468e972000
That hard_offline_page is a write-only file doesn't stop loop from using it as a writable backing file either.
Other fun examples:
(1) soft-block radios via /sys/class/rfkill/rfkill*/soft
(CAP_NET_ADMIN)
(2) change the reboot mode via /sys/kernel/reboot/mode (CAP_SYS_BOOT)
(3) reconfigure md arrays via /sys/block/md*/md/. md_attr_store() requires CAP_SYS_ADMIN for every md attribute.
(4) reconfigure scsi disks via /sys/class/scsi_disk/*/allow_restart and friends (CAP_SYS_ADMIN)
(5) read dmi-sysfs attributes (CAP_SYS_ADMIN)
And an unprivileged container that was handed a loop device can change gro_flush_timeout of its own network devices. That usually requires CAP_NET_ADMIN in the initial user namespace (via sysfs and via netlink).
I've reproduced that all on v7.4-rc1.
Aaaand zloop, the nvme target's file backend, the scsi target's fileio backend, fuse passthrough and the usb mass storage gadget have the same problem. erofs takes pseudo files as images for file-backed mounts as well. It reads them with the mounter's credentials though so that's just silly and not abusable.
Fwiw, device mapper doesn't need anything. It only takes block devices. md's deprecated bitmap file is fine as well. It maps the file with bmap() which no pseudo filesystem implements.
So this series adds SB_I_PSEUDO to state that the regular files of a filesystem are kernel interfaces and not storage and makes all seven refuse such files.
I didn't want to sprinkle SB_I_PSEUDO over all pseudo filesystems one by one. Instead there's now a common initialization point for all of them via fc_init_pseudo().
init_pseudo() uses it for the internal pseudo filesystems and all mountable pseudo filesystems call it from their ->init_fs_context().
kernfs does it once in kernfs_get_tree(). It raises SB_I_PSEUDO, SB_I_NOEXEC and SB_I_NODEV. Pseudo filesystems never hold executables or device nodes. Some of them raised SB_I_NOEXEC and SB_I_NODEV already, most didn't.
I went through every single one of them. None of them needs to execute anything. The files that can be mmap()ed map data and the tracing ring buffer refuses VM_EXEC anyway.
SB_I_NODEV is cleared again by devpts, binderfs and selinuxfs. The first two did that already. selinuxfs needs it because Android init opens /sys/fs/selinux/null by path as /dev/null doesn't exist yet at that point. Note that systemd mounts most of these filesystems with noexec and nodev already.
file_check_backing() looks at d_real_inode(). overlayfs happily stacks on top of sysfs, cgroup2, debugfs, tracefs, configfs and securityfs and reads of such overlayfs files are served by the pseudo file. Only procfs and binfmt_misc are refused as they set s_stack_depth to FILESYSTEM_MAX_STACK_DEPTH.
Whether all pseudo filesystems should refuse stacking is a separate discussion. overlayfs reads the lower file with the mounter's credentials so a root-mounted overlayfs on top of a sysfs directory hands capability gated reads to every reader. With SB_I_PSEUDO overlayfs could easily refuse them.
The first three patches are independent fixes. Loop never checked whether its backing file is open for reading. It relied on vfs_iter_read() refusing such files. Direct I/O never went through vfs_iter_read() and since v6.15 buffered I/O doesn't either. So whoever has a loop device can read files they could only open for writing. And the nvme target's file backend and the scsi target's fileio backend call ->read_iter() and ->write_iter() without checking that they exist.
---
Changes in v2:
- Add file_check_backing() and use it in all consumers. It replaces file_is_pseudo() and the open-coded file type, open mode and method
checks.
- nvmet, fileio and zloop refuse everything that isn't a regular file
or, for nvmet and fileio, a block device.
- fileio: check the protection file as well. (sashiko)
- acct: refuse files on all pseudo filesystems. (Alexander)
- selftests: add nvmet (Bui), fileio, zloop, link, FIFO and character
device tests.
- Collect tags. They are dropped on the patches that changed.
- Link to v1: https://patch.msgid.link/[email protected]
---
Christian Brauner (42):
loop: refuse backing files that aren't open for reading
nvmet: check that the file backend supports ->{read,write}_iter
target: fileio: check that the backing file supports ->{read,write}_iter
fs: add SB_I_PSEUDO
kernfs: use fc_init_pseudo()
proc: use fc_init_pseudo()
binfmt_misc: use fc_init_pseudo()
mqueue: use fc_init_pseudo()
bpf: use fc_init_pseudo() for bpffs
nullfs: use fc_init_pseudo()
failfs: use fc_init_pseudo()
rust_binderfs: use fc_init_pseudo()
devpts: use fc_init_pseudo()
debugfs: use fc_init_pseudo()
tracefs: use fc_init_pseudo()
configfs: use fc_init_pseudo()
securityfs: use fc_init_pseudo()
selinux: use fc_init_pseudo() for selinuxfs
smack: use fc_init_pseudo() for smackfs
apparmor: use fc_init_pseudo() for apparmorfs
nfsd: use fc_init_pseudo()
sunrpc: use fc_init_pseudo() for rpc_pipefs
fuse: use fc_init_pseudo() for fusectl
efivarfs: use fc_init_pseudo()
pstore: use fc_init_pseudo()
xenfs: use fc_init_pseudo()
openpromfs: use fc_init_pseudo()
ocfs2: use fc_init_pseudo() for dlmfs
s390/hypfs: use fc_init_pseudo()
powerpc/spufs: use fc_init_pseudo()
usb: gadget: f_fs: use fc_init_pseudo()
usb: gadget: gadgetfs: use fc_init_pseudo()
fs: add file_check_backing()
loop: refuse files on pseudo filesystems as backing files
zloop: refuse zone files on pseudo filesystems
nvmet: refuse files on pseudo filesystems as namespace backing files
target: fileio: refuse files on pseudo filesystems as backing files
fuse: refuse files on pseudo filesystems as passthrough backing files
usb: gadget: f_mass_storage: refuse files on pseudo filesystems
erofs: refuse files on pseudo filesystems as backing files
acct: refuse files on pseudo filesystems selftests/filesystems: add backing file tests for pseudo files
arch/powerpc/platforms/cell/spufs/inode.c | 2 + arch/s390/hypfs/inode.c | 2 + drivers/android/binder/rust_binderfs.c | 3 +- drivers/block/loop.c | 14 +- drivers/block/zloop.c | 5 +- drivers/nvme/target/io-cmd-file.c | 4 + drivers/target/target_core_file.c | 14 + drivers/usb/gadget/function/f_fs.c | 2 + drivers/usb/gadget/function/storage_common.c | 11 +- drivers/usb/gadget/legacy/inode.c | 2 + drivers/xen/xenfs/super.c | 2 + fs/binfmt_misc.c | 5 +- fs/configfs/mount.c | 2 + fs/debugfs/inode.c | 2 + fs/devpts/inode.c | 2 + fs/efivarfs/super.c | 2 + fs/erofs/super.c | 5 +- fs/failfs.c | 3 +- fs/fuse/backing.c | 4 + fs/fuse/control.c | 2 + fs/kernfs/mount.c | 4 +- fs/libfs.c | 2 +- fs/nfsd/nfsctl.c | 2 + fs/nullfs.c | 3 +- fs/ocfs2/dlmfs/dlmfs.c | 2 + fs/openpromfs/inode.c | 2 + fs/proc/root.c | 4 +- fs/pstore/inode.c | 2 + fs/read_write.c | 48 ++ fs/tracefs/inode.c | 2 + include/linux/fs.h | 2 + include/linux/fs/super_types.h | 1 + include/linux/pseudo_fs.h | 11 + ipc/mqueue.c | 3 +- kernel/acct.c | 6 +- kernel/bpf/inode.c | 4 +- net/sunrpc/rpc_pipe.c | 2 + security/apparmor/apparmorfs.c | 2 + security/inode.c | 2 + security/selinux/selinuxfs.c | 5 + security/smack/smackfs.c | 2 + tools/testing/selftests/filesystems/.gitignore | 1 + tools/testing/selftests/filesystems/Makefile | 2 +- tools/testing/selftests/filesystems/config | 14 + .../selftests/filesystems/pseudo_backing_test.c | 570 +++++++++++++++++++++ 45 files changed, 747 insertions(+), 39 deletions(-)
---
base-commit: 6628e7d4c6b25c8d18f1345e3a20d21829aae7e4
change-id: 20261109-work-loop-pseudo-890844168ef1
Christian Brauner
maintainerRFC PATCH v2 1/42 loop: refuse backing files that aren't open for reading
loop_configure() takes any file as long as it implements ->read_iter(). Loop itself never checked whether the file was actually opened for reading. Buffered I/O went through vfs_iter_read() which refuses files without FMODE_READ. Direct I/O has called ->read_iter() of the backing file directly ever since loop grew support for it.
Since commit f2fed441c69b ("loop: stop using vfs_iter_{read,write} for buffered I/O") buffered I/O calls ->read_iter() directly as well. That commit was about O_DIRECT handling and the FMODE_READ check went away as a side effect.
So whoever can set up a loop device can read a file it was only allowed to open for writing. Open the file O_WRONLY, configure a loop device with it and read the contents through the loop device.
Refuse backing files that aren't open for reading. Loop always reads from its backing file so a write-only backing file never made sense in the first place.
--- drivers/block/loop.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/block/loop.c +3 -0
@@ -528,6 +528,9 @@ static void loop_assign_backing_file(struct loop_device *lo, struct file *file)static int loop_check_backing_file (struct file *file) { +if (!(file->f_mode &FMODE_READ )) +return -EBADF ; +if (!file->f_op->read_iter)return -EINVAL ;
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 01/42] loop: refuse backing files that aren't open for reading
Sashiko has reviewed this patch and found no issues.
Quoted 19 lines
loop_configure()takes any file as long as it implements ->read_iter(). Loop itself never checked whether the file was actually opened for reading. Buffered I/O went throughvfs_iter_read()which refuses files withoutFMODE_READ. Direct I/O has called ->read_iter() of the backing file directly ever since loop grew support for it.Since commit
f2fed441c69b("loop: stop using vfs_iter_{read,write} for buffered I/O") buffered I/O calls ->read_iter() directly as well. That commit was aboutO_DIRECThandling and theFMODE_READcheck went away as a side effect.So whoever can set up a loop device can read a file it was only allowed to open for writing. Open the file
O_WRONLY, configure a loop device with it and read the contents through the loop device.Refuse backing files that aren't open for reading. Loop always reads from its backing file so a write-only backing file never made sense in the first place.
Quoted 7 lines
Fixes bc07c10a3603 ("block: loop: support DIO & AIO")Fixes f2fed441c69b ("loop: stop using vfs_iter_{read,write} for buffered I/O")Reviewed-by Jan Kara <[email protected]>Reviewed-by Christoph Hellwig <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Christian Brauner
maintainerRFC PATCH v2 2/42 nvmet: check that the file backend supports ->{read,write}_iter
In reply to Christian BraunerThe file backend calls ->read_iter() and ->write_iter() of the backing file directly but never checks that they exist. Everything that isn't a block device ends up in the file backend. So a namespace pointing to a file without them calls a NULL pointer on its first I/O. Only buffered_io=1 gets that far as the O_DIRECT open fails for such files.
Refuse them when the namespace is enabled the same way zloop does since commit 0c10f8a1a7ae ("zloop: check that the zone backing file support ->{read,write}_iter").
--- drivers/nvme/target/io-cmd-file.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/nvme/target/io-cmd-file.c +5 -0
@@ -47,6 +47,11 @@ int nvmet_file_ns_enable(struct nvmet_ns *ns)return ret; } +if (!ns->file->f_op->read_iter || !ns->file->f_op->write_iter) { + ret = -EINVAL ; + goto err; + } +nvmet_file_ns_revalidate (ns);/*
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 02/42] nvmet: check that the file backend supports ->{read,write}_iter
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
The file backend calls ->read_iter() and ->write_iter() of the backing file directly but never checks that they exist. Everything that isn't a block device ends up in the file backend. So a namespace pointing to a file without them calls a NULL pointer on its first I/O. Only buffered_io=1 gets that far as the
O_DIRECTopen fails for such files.
Quoted 8 lines
Refuse them when the namespace is enabled the same way zloop does since commit
0c10f8a1a7ae("zloop: check that the zone backing file support ->{read,write}_iter").Fixes d5eff33ee6f8 ("nvmet: add simple file backed ns support")Reviewed-by Jan Kara <[email protected]>Reviewed-by Christoph Hellwig <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Christian Brauner
maintainerRFC PATCH v2 3/42 target: fileio: check that the backing file supports ->{read,write}_iter
In reply to Christian BraunerWith fd_async_io=1 the fileio backend calls ->read_iter() and ->write_iter() of the backing file directly. The synchronous path goes through vfs_iter_read() and vfs_iter_write() which check for them but the aio path doesn't. So a backing file without them calls a NULL pointer on its first I/O.
Refuse such files when configuring the device. On the synchronous path every read or write that needed the missing method failed with EINVAL anyway.
--- drivers/target/target_core_file.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/target/target_core_file.c +8 -0
@@ -144,6 +144,14 @@ static int fd_configure_device(struct se_device *dev) goto fail; } fd_dev->fd_file = file; + +if (!file->f_op->read_iter || !file->f_op->write_iter) { +pr_err ("FILEIO: %s lacks ->read_iter or ->write_iter\n" , + fd_dev->fd_dev_name); + ret = -EINVAL ; + goto fail; + } +/* * If using a block backend with this struct file, we extract * fd_dev->fd_[block,dev]_size from struct block_device.
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 03/42] target: fileio: check that the backing file supports ->{read,write}_iter
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
With fd_async_io=1 the fileio backend calls ->read_iter() and ->write_iter() of the backing file directly. The synchronous path goes through
vfs_iter_read()andvfs_iter_write()which check for them but the aio path doesn't. So a backing file without them calls a NULL pointer on its first I/O.
Quoted 8 lines
Refuse such files when configuring the device. On the synchronous path every read or write that needed the missing method failed with EINVAL anyway.
Fixes 769031c92c8b ("scsi: target: target/file: Add support of direct and async I/O")Reviewed-by Jan Kara <[email protected]>Reviewed-by Christoph Hellwig <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
Christian Brauner
maintainerRFC PATCH v2 4/42 fs: add SB_I_PSEUDO
In reply to Christian BraunerCurrently, there's no way to tell whether the files of a filesystem store data or whether they are kernel interfaces. Files on pseudo filesystems such as procfs or sysfs generate their contents when they're read and writes to them are commands to the kernel.
But a few places in the kernel take an arbitrary file and use it as
storage: loop, zloop, the nvme target's file backend, the scsi target's fileio backend, fuse passthrough, the usb mass storage gadget and erofs file-backed mounts. At most they check the file type and whether the file implements ->read_iter() and ->write_iter(). That's not enough. kernfs provides both for every sysfs attribute for example.
Add SB_I_PSEUDO so a filesystem can state that its regular files are kernel interfaces and must not be used as storage.
Pseudo filesystems also never hold executables or device nodes. But currently each of them decides on its own whether to raise SB_I_NOEXEC and SB_I_NODEV. Some do, most don't. Add fc_init_pseudo() as the common initialization point for all pseudo filesystems that raises all three flags and switch init_pseudo() over to it. The following patches convert the mountable pseudo filesystems.
Nothing checks SB_I_PSEUDO yet so no functional changes.
--- fs/libfs.c | 2 +- include/linux/fs/super_types.h | 1 + include/linux/pseudo_fs.h | 11 +++++++++++ 3 files changed, 13 insertions(+), 1 deletion(-)
fs/libfs.c +1 -1
@@ -735,7 +735,7 @@ struct pseudo_fs_context *init_pseudo(struct fs_context *fc, fc->fs_private = ctx; fc->ops = &pseudo_fs_context_ops; fc->sb_flags |=SB_NOUSER ; - fc->s_iflags |=SB_I_NOEXEC |SB_I_NODEV ; +fc_init_pseudo (fc); fc->global = true; }return ctx;
include/linux/fs/super_types.h +1 -0
@@ -359,5 +359,6 @@ struct super_block {#define SB_I_NOIDMAP 0x00002000/* No idmapped mounts on this superblock */ #define SB_I_ALLOW_HSM 0x00004000/* Allow HSM events on this superblock */ #define SB_I_NO_DATA_INTEGRITY 0x00008000/* fs cannot guarantee data persistence on sync */ +#define SB_I_PSEUDO 0x00010000/* regular files are kernel interfaces, not storage */ #endif /* _LINUX_FS_SUPER_TYPES_H */
include/linux/pseudo_fs.h +11 -0
@@ -2,6 +2,7 @@#define __LINUX_PSEUDO_FS__#include <linux/fs_context.h> +#include <linux/fs/super_types.h> struct pseudo_fs_context {const struct super_operations *ops;
@@ -15,4 +16,14 @@ struct pseudo_fs_context {struct pseudo_fs_context *init_pseudo (struct fs_context *fc,unsigned long magic); +/* +* Common initialization for all pseudo filesystems, mountable or not. Their +* regular files are kernel interfaces. They don't store data and pseudo +* filesystems never hold executables or device nodes. +*/ +static inline void fc_init_pseudo (struct fs_context *fc) +{ + fc->s_iflags |=SB_I_PSEUDO |SB_I_NOEXEC |SB_I_NODEV ; +} +#endif
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 04/42] fs: add SB_I_PSEUDO
Sashiko has reviewed this patch and found no issues.
Quoted 22 lines
Currently, there's no way to tell whether the files of a filesystem store data or whether they are kernel interfaces. Files on pseudo filesystems such as procfs or sysfs generate their contents when they're read and writes to them are commands to the kernel.
But a few places in the kernel take an arbitrary file and use it as
storage: loop, zloop, the nvme target's file backend, the scsi target's fileio backend, fuse passthrough, the usb mass storage gadget and erofs file-backed mounts. At most they check the file type and whether the file implements ->read_iter() and ->write_iter(). That's not enough. kernfs provides both for every sysfs attribute for example.Add
SB_I_PSEUDOso a filesystem can state that its regular files are kernel interfaces and must not be used as storage.Pseudo filesystems also never hold executables or device nodes. But currently each of them decides on its own whether to raise
SB_I_NOEXECandSB_I_NODEV. Some do, most don't. Addfc_init_pseudo()as the common initialization point for all pseudo filesystems that raises all three flags and switchinit_pseudo()over to it. The following patches convert the mountable pseudo filesystems.
Quoted 6 lines
Nothing checks
SB_I_PSEUDOyet so no functional changes.Reviewed-by Jan Kara <[email protected]>Reviewed-by Christoph Hellwig <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
[email protected]
AI reviewRe: [PATCH RFC v2 04/42] fs: add SB_I_PSEUDO
In reply to Christian BraunerTL;DR: Nit only: the fc_init_pseudo() comment and commit message claim pseudo filesystems never hold device nodes, but devpts and binderfs do and must clear SB_I_NODEV; the wording could mislead.
Quoted 1 line
fs: add
SB_I_PSEUDO
TL;DR: Nit only: the fc_init_pseudo() comment and commit message claim pseudo filesystems never hold device nodes, but devpts and binderfs do and must clear SB_I_NODEV; the wording could mislead.
Quoted 3 lines
include/linux/pseudo_fs.h +0
-0
[ ... ]
include/linux/pseudo_fs.h struct pseudo_fs_context { · line 27
Quoted 9 lines
include/linux/pseudo_fs.h +9
-0+/* +* Common initialization for all pseudo filesystems, mountable or not. Their +* regular files are kernel interfaces. They don't store data and pseudo +* filesystems never hold executables or device nodes. +*/ +static inline void fc_init_pseudo (struct fs_context *fc) +{ + fc->s_iflags |=SB_I_PSEUDO |SB_I_NOEXEC |SB_I_NODEV ; +}
This isn't a bug, but is it accurate that pseudo filesystems "never hold executables or device nodes"? The same wording is in the commit message.
devpts creates character device inodes in devpts_pty_new():
init_special_inode(inode, S_IFCHR|opts->mode,
MKDEV(UNIX98_PTY_SLAVE_MAJOR, index));and binderfs does the same with init_special_inode(inode, S_IFCHR | 0600, ...). Both filesystems are converted to fc_init_pseudo() later in the series, and both have to undo the flag in their fill_super callbacks:
s->s_iflags &= ~SB_I_NODEV;
This works because sget_fc() ORs fc->s_iflags into sb->s_iflags before fill_super runs. A filesystem that has device nodes and relies on this comment would not know it needs to clear SB_I_NODEV, and its device nodes would fail to open with -EACCES from may_open_dev().
Could the comment say that SB_I_NODEV is the default and that pseudo filesystems with device nodes must clear it in fill_super, or could "never ... device nodes" be dropped?
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/43599461726
Christian Brauner
maintainerRFC PATCH v2 5/42 kernfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize all kernfs based filesystems as pseudo filesystems in kernfs_get_tree() instead of raising SB_I_NOEXEC and SB_I_NODEV by hand in kernfs_fill_super(). This adds SB_I_PSEUDO for sysfs, cgroupfs and resctrl.
--- fs/kernfs/mount.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/kernfs/mount.c +2 -2
@@ -8,6 +8,7 @@*/ #include <linux/fs.h> +#include <linux/pseudo_fs.h> #include <linux/mount.h> #include <linux/init.h> #include <linux/magic.h>
@@ -298,8 +299,6 @@ static int kernfs_fill_super(struct super_block *sb, struct kernfs_fs_context *kstruct dentry *root; info->sb = sb; -/* Userspace would break if executables or devices appear on sysfs */ - sb->s_iflags |=SB_I_NOEXEC |SB_I_NODEV ; sb->s_blocksize =PAGE_SIZE ; sb->s_blocksize_bits =PAGE_SHIFT ; sb->s_magic = kfc->magic;
@@ -388,6 +387,7 @@ int kernfs_get_tree(struct fs_context *fc) info->ns = kfc->ns_tag;INIT_LIST_HEAD (&info->node); +fc_init_pseudo (fc); fc->s_fs_info = info; sb =sget_fc (fc, kernfs_test_super, kernfs_set_super);if (IS_ERR (sb))
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 05/42] kernfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 9 lines
Initialize all kernfs based filesystems as pseudo filesystems in
kernfs_get_tree()instead of raisingSB_I_NOEXECandSB_I_NODEVby hand inkernfs_fill_super(). This addsSB_I_PSEUDOfor sysfs, cgroupfs and resctrl.Reviewed-by Jan Kara <[email protected]>Reviewed-by Christoph Hellwig <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
Christian Brauner
maintainerRFC PATCH v2 6/42 proc: use fc_init_pseudo()
In reply to Christian BraunerInitialize procfs as a pseudo filesystem instead of raising SB_I_NOEXEC and SB_I_NODEV by hand. This adds SB_I_PSEUDO.
--- fs/proc/root.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/proc/root.c +2 -2
@@ -17,6 +17,7 @@#include <linux/bitops.h> #include <linux/user_namespace.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/mount.h> #include <linux/pid_namespace.h> #include <linux/fs_parser.h>
@@ -265,8 +266,6 @@ static int proc_fill_super(struct super_block *s, struct fs_context *fc)if (ret)return ret; -/* User space would break if executables or devices appear on proc */ - s->s_iflags |=SB_I_NOEXEC |SB_I_NODEV ; s->s_flags |=SB_NODIRATIME |SB_NOSUID |SB_NOEXEC ; s->s_blocksize =1024 ; s->s_blocksize_bits =10 ;
@@ -350,6 +349,7 @@ static int proc_init_fs_context(struct fs_context *fc)put_user_ns (fc->user_ns); fc->user_ns =get_user_ns (ctx->pid_ns->user_ns); fc->fs_private = ctx; +fc_init_pseudo (fc); fc->ops = &proc_fs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 06/42] proc: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 7 lines
Initialize procfs as a pseudo filesystem instead of raising
SB_I_NOEXECandSB_I_NODEVby hand. This addsSB_I_PSEUDO.Reviewed-by Jan Kara <[email protected]>Reviewed-by Christoph Hellwig <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=6
Christian Brauner
maintainerRFC PATCH v2 7/42 binfmt_misc: use fc_init_pseudo()
In reply to Christian BraunerInitialize binfmt_misc as a pseudo filesystem instead of raising SB_I_NOEXEC and SB_I_NODEV by hand. This adds SB_I_PSEUDO.
--- fs/binfmt_misc.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
fs/binfmt_misc.c +3 -2
@@ -22,6 +22,7 @@#include <linux/file.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/init.h> #include <linux/kstrtox.h> #include <linux/limits.h>
@@ -1575,8 +1576,7 @@ static int bm_fill_super(struct super_block *sb, struct fs_context *fc)if (user_ns !=current_user_ns ())return -EINVAL ; -/* Never exec off this instance and never let anything stack on it. */ - sb->s_iflags |=SB_I_NOEXEC |SB_I_NODEV ; +/* Never let anything stack on this instance. */ sb->s_stack_depth =FILESYSTEM_MAX_STACK_DEPTH ;/*
@@ -1660,6 +1660,7 @@ static void bm_kill_sb(struct super_block *sb)static int bm_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &bm_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 07/42] binfmt_misc: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize
binfmt_miscas a pseudo filesystem instead of raisingSB_I_NOEXECandSB_I_NODEVby hand. This addsSB_I_PSEUDO.Reviewed-by Jan Kara <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
Christian Brauner
maintainerRFC PATCH v2 8/42 mqueue: use fc_init_pseudo()
In reply to Christian BraunerInitialize mqueue as a pseudo filesystem instead of raising SB_I_NOEXEC and SB_I_NODEV by hand. This adds SB_I_PSEUDO.
--- ipc/mqueue.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
ipc/mqueue.c +2 -1
@@ -18,6 +18,7 @@#include <linux/file.h> #include <linux/mount.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/namei.h> #include <linux/sysctl.h> #include <linux/poll.h>
@@ -405,7 +406,6 @@ static int mqueue_fill_super(struct super_block *sb, struct fs_context *fc)struct inode *inode;struct ipc_namespace *ns = sb->s_fs_info; - sb->s_iflags |=SB_I_NOEXEC |SB_I_NODEV ; sb->s_blocksize =PAGE_SIZE ; sb->s_blocksize_bits =PAGE_SHIFT ; sb->s_magic =MQUEUE_MAGIC ;
@@ -457,6 +457,7 @@ static int mqueue_init_fs_context(struct fs_context *fc)put_user_ns (fc->user_ns); fc->user_ns =get_user_ns (ctx->ipc_ns->user_ns); fc->fs_private = ctx; +fc_init_pseudo (fc); fc->ops = &mqueue_fs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 08/42] mqueue: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize mqueue as a pseudo filesystem instead of raising
SB_I_NOEXECandSB_I_NODEVby hand. This addsSB_I_PSEUDO.Reviewed-by Christoph Hellwig <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
Christian Brauner
maintainerRFC PATCH v2 9/42 bpf: use fc_init_pseudo() for bpffs
In reply to Christian BraunerInitialize bpffs as a pseudo filesystem instead of raising SB_I_NOEXEC and SB_I_NODEV by hand. This adds SB_I_PSEUDO.
--- kernel/bpf/inode.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/bpf/inode.c +2 -2
@@ -15,6 +15,7 @@#include <linux/namei.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/fs_parser.h> #include <linux/kdev_t.h> #include <linux/filter.h>
@@ -1197,8 +1198,6 @@ static int bpf_fill_super(struct super_block *sb, struct fs_context *fc) sb->s_magic =BPF_FS_MAGIC ; sb->s_op = &bpf_super_ops; sb->s_xattr = bpf_fs_xattr_handlers; - sb->s_iflags |=SB_I_NOEXEC ; - sb->s_iflags |=SB_I_NODEV ; sb->s_time_gran =1 ; inode =bpf_get_inode (sb,NULL ,S_IFDIR |0777 );
@@ -1261,6 +1260,7 @@ static int bpf_init_fs_context(struct fs_context *fc) opts->delegate_attachs =0 ; fc->s_fs_info = opts; +fc_init_pseudo (fc); fc->ops = &bpf_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 09/42] bpf: use fc_init_pseudo() for bpffs
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize bpffs as a pseudo filesystem instead of raising
SB_I_NOEXECandSB_I_NODEVby hand. This addsSB_I_PSEUDO.Reviewed-by Christoph Hellwig <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=9
Christian Brauner
maintainerRFC PATCH v2 10/42 nullfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize nullfs as a pseudo filesystem instead of raising SB_I_NOEXEC and SB_I_NODEV by hand. This adds SB_I_PSEUDO.
--- fs/nullfs.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/nullfs.c +2 -1
@@ -2,6 +2,7 @@/* Copyright (c) 2026 Christian Brauner <[email protected]> */ #include <linux/fs/super_types.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/magic.h> #include <linux/splice.h> #include <linux/uio.h>
@@ -174,7 +175,7 @@ static int nullfs_init_fs_context(struct fs_context *fc) { fc->ops = &nullfs_fs_context_ops; fc->sb_flags |=SB_NOUSER ; - fc->s_iflags |=SB_I_NOEXEC |SB_I_NODEV ; +fc_init_pseudo (fc);return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 10/42] nullfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 7 lines
Initialize nullfs as a pseudo filesystem instead of raising
SB_I_NOEXECandSB_I_NODEVby hand. This addsSB_I_PSEUDO.Reviewed-by Jan Kara <[email protected]>Reviewed-by Christoph Hellwig <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=10
Christian Brauner
maintainerRFC PATCH v2 11/42 failfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize failfs as a pseudo filesystem instead of raising SB_I_NOEXEC and SB_I_NODEV by hand. This adds SB_I_PSEUDO.
--- fs/failfs.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/failfs.c +2 -1
@@ -3,6 +3,7 @@#include <linux/fs.h> #include <linux/fs/super_types.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/fs_struct.h> #include <linux/magic.h> #include <linux/mount.h>
@@ -132,7 +133,7 @@ static int failfs_init_fs_context(struct fs_context *fc) fc->ops = &failfs_context_ops; fc->global = true; fc->sb_flags |=SB_NOUSER ; - fc->s_iflags |=SB_I_NOEXEC |SB_I_NODEV ; +fc_init_pseudo (fc);return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 11/42] failfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize failfs as a pseudo filesystem instead of raising
SB_I_NOEXECandSB_I_NODEVby hand. This addsSB_I_PSEUDO.Reviewed-by Jan Kara <[email protected]>Reviewed-by Christoph Hellwig <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=11
Christian Brauner
maintainerRFC PATCH v2 12/42 rust_binderfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize binderfs as a pseudo filesystem instead of raising SB_I_NOEXEC by hand. This adds SB_I_PSEUDO. binderfs_fill_super() keeps clearing SB_I_NODEV for the binder device nodes.
--- drivers/android/binder/rust_binderfs.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/android/binder/rust_binderfs.c +2 -1
@@ -3,6 +3,7 @@#include <linux/compiler_types.h> #include <linux/errno.h> #include <linux/fs.h> +#include <linux/pseudo_fs.h> #include <linux/fsnotify.h> #include <linux/gfp.h> #include <linux/idr.h>
@@ -667,7 +668,6 @@ static int binderfs_fill_super(struct super_block *sb, struct fs_context *fc)* necessary and safe. */ sb->s_iflags &= ~SB_I_NODEV ; - sb->s_iflags |=SB_I_NOEXEC ; sb->s_magic =RUST_BINDERFS_SUPER_MAGIC ; sb->s_op = &binderfs_super_ops; sb->s_time_gran =1 ;
@@ -759,6 +759,7 @@ static int binderfs_init_fs_context(struct fs_context *fc) ctx->stats_mode = binderfs_stats_mode_unset; fc->fs_private = ctx; +fc_init_pseudo (fc); fc->ops = &binderfs_fs_context_ops;return 0 ;
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 12/42] rust_binderfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 5 lines
Initialize binderfs as a pseudo filesystem instead of raising
SB_I_NOEXECby hand. This addsSB_I_PSEUDO.binderfs_fill_super()keeps clearingSB_I_NODEVfor the binder device nodes.Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=12
Christian Brauner
maintainerRFC PATCH v2 13/42 devpts: use fc_init_pseudo()
In reply to Christian BraunerInitialize devpts as a pseudo filesystem. This raises SB_I_PSEUDO and SB_I_NOEXEC. devpts never holds executables. devpts_fill_super() keeps clearing SB_I_NODEV for the pty device nodes.
--- fs/devpts/inode.c | 2 ++ 1 file changed, 2 insertions(+)
fs/devpts/inode.c +2 -0
@@ -13,6 +13,7 @@#include <linux/init.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/fs_parser.h> #include <linux/sched.h> #include <linux/namei.h>
@@ -438,6 +439,7 @@ static int devpts_init_fs_context(struct fs_context *fc) fsi->mount_opts.reserve = true; fc->s_fs_info = fsi; +fc_init_pseudo (fc); fc->ops = &devpts_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 13/42] devpts: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize devpts as a pseudo filesystem. This raises
SB_I_PSEUDOandSB_I_NOEXEC. devpts never holds executables.devpts_fill_super()keeps clearingSB_I_NODEVfor the pty device nodes.Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=13
Christian Brauner
maintainerRFC PATCH v2 14/42 debugfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize debugfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. debugfs never holds executables or device nodes.
SB_I_NOEXEC also refuses PROT_EXEC mappings. The debugfs files that can be mapped, kcov, relay channels and powernv's memtrace, map data.
--- fs/debugfs/inode.c | 2 ++ 1 file changed, 2 insertions(+)
fs/debugfs/inode.c +2 -0
@@ -15,6 +15,7 @@#include <linux/module.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/fs_parser.h> #include <linux/pagemap.h> #include <linux/init.h>
@@ -317,6 +318,7 @@ static int debugfs_init_fs_context(struct fs_context *fc) fsi->mode =DEBUGFS_DEFAULT_MODE ; fc->s_fs_info = fsi; +fc_init_pseudo (fc); fc->ops = &debugfs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 14/42] debugfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 10 lines
Initialize debugfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. debugfs never holds executables or device nodes.
SB_I_NOEXECalso refusesPROT_EXECmappings. The debugfs files that can be mapped, kcov, relay channels and powernv's memtrace, map data.Reviewed-by Jan Kara <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=14
Christian Brauner
maintainerRFC PATCH v2 15/42 tracefs: use fc_init_pseudo()
In reply to Christian BraunerInitialize tracefs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. tracefs never holds executables or device nodes.
SB_I_NOEXEC also refuses PROT_EXEC mappings. The only tracefs files that can be mapped are the ring buffers and __rb_map_vma() refuses VM_EXEC already.
--- fs/tracefs/inode.c | 2 ++ 1 file changed, 2 insertions(+)
fs/tracefs/inode.c +2 -0
@@ -12,6 +12,7 @@#include <linux/module.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/fs_parser.h> #include <linux/kobject.h> #include <linux/namei.h>
@@ -510,6 +511,7 @@ static int tracefs_init_fs_context(struct fs_context *fc) fsi->mode =TRACEFS_DEFAULT_MODE ; fc->s_fs_info = fsi; +fc_init_pseudo (fc); fc->ops = &tracefs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 15/42] tracefs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 10 lines
Initialize tracefs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. tracefs never holds executables or device nodes.
SB_I_NOEXECalso refusesPROT_EXECmappings. The only tracefs files that can be mapped are the ring buffers and__rb_map_vma()refusesVM_EXECalready.Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=15
Christian Brauner
maintainerRFC PATCH v2 16/42 configfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize configfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. configfs never holds executables or device nodes.
--- fs/configfs/mount.c | 2 ++ 1 file changed, 2 insertions(+)
fs/configfs/mount.c +2 -0
@@ -13,6 +13,7 @@#include <linux/module.h> #include <linux/mount.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/pagemap.h> #include <linux/init.h> #include <linux/slab.h>
@@ -106,6 +107,7 @@ static const struct fs_context_operations configfs_context_ops = {static int configfs_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &configfs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 16/42] configfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 8 lines
Initialize configfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. configfs never holds executables or device nodes.Reviewed-by Jan Kara <[email protected]>Acked-by Breno Leitao <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=16
Christian Brauner
maintainerRFC PATCH v2 17/42 securityfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize securityfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. securityfs never holds executables or device nodes.
AppArmor puts a .null device node into securityfs but only ever opens it via dentry_open() which doesn't care about SB_I_NODEV.
--- security/inode.c | 2 ++ 1 file changed, 2 insertions(+)
security/inode.c +2 -0
@@ -14,6 +14,7 @@#include <linux/kobject.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/mount.h> #include <linux/pagemap.h> #include <linux/init.h>
@@ -64,6 +65,7 @@ static const struct fs_context_operations securityfs_context_ops = {static int securityfs_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &securityfs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 17/42] securityfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 9 lines
Initialize securityfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. securityfs never holds executables or device nodes.AppArmor puts a .null device node into securityfs but only ever opens it via
dentry_open()which doesn't care aboutSB_I_NODEV.Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=17
[email protected]
AI reviewRe: [PATCH RFC v2 17/42] securityfs: use fc_init_pseudo()
In reply to Christian BraunerTL;DR: Setting SB_I_NODEV on securityfs may make reopening AppArmor's inherited .null fd (e.g. open("/dev/stderr")) fail with -EACCES, which used to work; the commit message may also be inaccurate…
Quoted 1 line
securityfs: use
fc_init_pseudo()
TL;DR: Setting SB_I_NODEV on securityfs may make reopening AppArmor's inherited .null fd (e.g. open("/dev/stderr")) fail with -EACCES, which used to work; the commit message may also be inaccurate about device nodes.
Quoted 3 lines
security/inode.c +0
-0
[ ... ]
security/inode.c static const struct fs_context_operations securityfs_context_ops = { · line 71
Quoted 8 lines
security/inode.c +1
-0@@ -64,6 +65,7 @@ static const struct fs_context_operations securityfs_context_ops = {static int securityfs_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &securityfs_context_ops;return 0 ; }
The commit message says "AppArmor puts a .null device node into securityfs but only ever opens it via dentry_open() which doesn't care about SB_I_NODEV." Is that the whole picture?
aa_inherit_files() installs that dentry_open()ed file into the task's fd table:
devnull = dentry_open(&aa_null, O_RDWR, cred);
...
replace_fd(n - 1, devnull, 0);The fd is not O_CLOEXEC, and its f_path.mnt is the internal mount from simple_pin_fs() in aa_mk_null_file(), which never has MNT_NODEV.
Opening /proc/<pid>/fd/N, or /dev/stdout or /dev/stderr, resolves to that same path and goes through the normal open path:
do_open() -> may_open()
case S_IFCHR:
if (!may_open_dev(path))
return -EACCES;may_open_dev() checks path->mnt->mnt_sb->s_iflags & SB_I_NODEV. That bit was clear on the securityfs superblock before this patch and is set now.
Can this make open("/dev/stderr") fail with -EACCES for an unconfined task that inherited the .null fd, for example a helper exec'd through a ux/Ux transition from a confined task? That open used to succeed.
Should the commit message say that this reopen path is intended to fail, or does .null need separate handling? The statement that "securityfs never holds ... device nodes" also seems to conflict with the .null node described in the next paragraph.
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/43599461726
Re: [PATCH RFC v2 17/42] securityfs: use fc_init_pseudo()
In reply to Christian BraunerHi Christian,
Quoted 2 lines · Christian Brauner
AppArmor puts a .null device node into securityfs but only ever opens it via
dentry_open()which doesn't care aboutSB_I_NODEV.
Not a big deal, but userspace can see that node too, as /sys/kernel/security/apparmor/.null. Opening it by path works in current kernels and fails with EACCES after this patch. Now, I don't know of anything that does that, but selinuxfs gets SB_I_NODEV cleared again in the next patch for the same kind of node, so I think we should do the same thing here. If not, it would be good to have a line in the changelog saying that opening it by path is meant to stop working.
Once that's fixed, please feel free to add:
Christian Brauner
maintainerRe: [PATCH RFC v2 17/42] securityfs: use fc_init_pseudo()
Quoted 7 lines · Chris Down
Not a big deal, but userspace can see that node too, as
/sys/kernel/security/apparmor/.null. Opening it by path works in current kernels and fails with EACCES after this patch. Now, I don't know of anything that does that, but selinuxfs getsSB_I_NODEVcleared again in the next patch for the same kind of node, so I think we should do the same thing here. If not, it would be good to have a line in the changelog saying that opening it by path is meant to stop working.
Yeah, seems fine. Though, afaict aa refuses every read and write on .null in aa_file_perm(). So this change only moves the EACCES from read()/write() to open(). But I guess open() failing might be an issue, idk.
I really really dislike this device node abuse on for both lsms. It's sketchy as hell.
Christian Brauner
maintainerRFC PATCH v2 18/42 selinux: use fc_init_pseudo() for selinuxfs
In reply to Christian BraunerInitialize selinuxfs as a pseudo filesystem. This raises SB_I_PSEUDO and SB_I_NOEXEC. selinuxfs never holds executables. SB_I_NOEXEC also refuses PROT_EXEC mappings but the status and policy files are only ever mapped for reading.
But selinuxfs needs device nodes. The kernel replaces file descriptors with /sys/fs/selinux/null on exec via dentry_open() which doesn't care about SB_I_NODEV. Android init however opens /sys/fs/selinux/null by path as /dev/null doesn't exist yet at that point. So clear SB_I_NODEV again in sel_fill_super().
--- security/selinux/selinuxfs.c | 5 +++++ 1 file changed, 5 insertions(+)
security/selinux/selinuxfs.c +5 -0
@@ -18,6 +18,7 @@#include <linux/vmalloc.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/hex.h> #include <linux/mount.h> #include <linux/mutex.h>
@@ -1852,6 +1853,9 @@ static int sel_fill_super(struct super_block *sb, struct fs_context *fc) /* last one */ {"", NULL, 0} }; +/* Android init opens the null device below by path. */ + sb->s_iflags &= ~SB_I_NODEV ; + ret =selinux_fs_info_create (sb);if (ret) goto err;
@@ -1955,6 +1959,7 @@ static const struct fs_context_operations sel_context_ops = {static int sel_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &sel_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 18/42] selinux: use fc_init_pseudo() for selinuxfs
Sashiko has reviewed this patch and found no issues.
Quoted 5 lines
Initialize selinuxfs as a pseudo filesystem. This raises
SB_I_PSEUDOandSB_I_NOEXEC. selinuxfs never holds executables.SB_I_NOEXECalso refusesPROT_EXECmappings but the status and policy files are only ever mapped for reading.
Quoted 8 lines
But selinuxfs needs device nodes. The kernel replaces file descriptors with
/sys/fs/selinux/nullon exec viadentry_open()which doesn't care aboutSB_I_NODEV. Android init however opens/sys/fs/selinux/nullby path as/dev/nulldoesn't exist yet at that point. So clearSB_I_NODEVagain insel_fill_super().Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=18
Christian Brauner
maintainerRFC PATCH v2 19/42 smack: use fc_init_pseudo() for smackfs
In reply to Christian BraunerInitialize smackfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. smackfs never holds executables or device nodes.
--- security/smack/smackfs.c | 2 ++ 1 file changed, 2 insertions(+)
security/smack/smackfs.c +2 -0
@@ -25,6 +25,7 @@#include <linux/magic.h> #include <linux/mount.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include "smack.h" #define BEBITS (sizeof(__be32) * 8)
@@ -2880,6 +2881,7 @@ static const struct fs_context_operations smk_context_ops = {*/ static int smk_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &smk_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 19/42] smack: use fc_init_pseudo() for smackfs
Sashiko has reviewed this patch and found no issues.
Quoted 7 lines
Initialize smackfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. smackfs never holds executables or device nodes.Acked-by Casey Schaufler <[email protected]>Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=19
Christian Brauner
maintainerRFC PATCH v2 20/42 apparmor: use fc_init_pseudo() for apparmorfs
In reply to Christian BraunerInitialize apparmorfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. apparmorfs never holds executables or device nodes.
--- security/apparmor/apparmorfs.c | 2 ++ 1 file changed, 2 insertions(+)
security/apparmor/apparmorfs.c +2 -0
@@ -21,6 +21,7 @@#include <linux/rcupdate.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/poll.h> #include <linux/zstd.h> #include <linux/string.h>
@@ -263,6 +264,7 @@ static const struct fs_context_operations apparmorfs_context_ops = {static int apparmorfs_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &apparmorfs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 20/42] apparmor: use fc_init_pseudo() for apparmorfs
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize apparmorfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. apparmorfs never holds executables or device nodes.Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=20
Christian Brauner
maintainerRFC PATCH v2 21/42 nfsd: use fc_init_pseudo()
In reply to Christian BraunerInitialize the nfsd filesystem as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. It never holds executables or device nodes.
--- fs/nfsd/nfsctl.c | 2 ++ 1 file changed, 2 insertions(+)
fs/nfsd/nfsctl.c +2 -0
@@ -9,6 +9,7 @@#include <linux/namei.h> #include <linux/ctype.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/sunrpc/cache.h> #include <linux/sunrpc/svcsock.h>
@@ -1375,6 +1376,7 @@ static int nfsd_init_fs_context(struct fs_context *fc) {put_user_ns (fc->user_ns); fc->user_ns =get_user_ns (fc->net_ns->user_ns); +fc_init_pseudo (fc); fc->ops = &nfsd_fs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 21/42] nfsd: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize the nfsd filesystem as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. It never holds executables or device nodes.Acked-by Chuck Lever <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=21
Christian Brauner
maintainerRFC PATCH v2 22/42 sunrpc: use fc_init_pseudo() for rpc_pipefs
In reply to Christian BraunerInitialize rpc_pipefs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. rpc_pipefs never holds executables or device nodes.
--- net/sunrpc/rpc_pipe.c | 2 ++ 1 file changed, 2 insertions(+)
net/sunrpc/rpc_pipe.c +2 -0
@@ -15,6 +15,7 @@#include <linux/pagemap.h> #include <linux/mount.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/namei.h> #include <linux/fsnotify.h> #include <linux/kernel.h>
@@ -1181,6 +1182,7 @@ static int rpc_init_fs_context(struct fs_context *fc) {put_user_ns (fc->user_ns); fc->user_ns =get_user_ns (fc->net_ns->user_ns); +fc_init_pseudo (fc); fc->ops = &rpc_fs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 22/42] sunrpc: use fc_init_pseudo() for rpc_pipefs
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize
rpc_pipefsas a pseudo filesystem. This raisesSB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV.rpc_pipefsnever holds executables or device nodes.Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=22
Christian Brauner
maintainerRFC PATCH v2 23/42 fuse: use fc_init_pseudo() for fusectl
In reply to Christian BraunerInitialize fusectl as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. fusectl never holds executables or device nodes.
--- fs/fuse/control.c | 2 ++ 1 file changed, 2 insertions(+)
fs/fuse/control.c +2 -0
@@ -10,6 +10,7 @@#include <linux/init.h> #include <linux/module.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/namei.h> #define FUSE_CTL_SUPER_MAGIC 0x65735543
@@ -334,6 +335,7 @@ static const struct fs_context_operations fuse_ctl_context_ops = {static int fuse_ctl_init_fs_context (struct fs_context *fsc) { +fc_init_pseudo (fsc); fsc->ops = &fuse_ctl_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 23/42] fuse: use fc_init_pseudo() for fusectl
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize fusectl as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. fusectl never holds executables or device nodes.Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=23
Christian Brauner
maintainerRFC PATCH v2 24/42 efivarfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize efivarfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. efivarfs never holds executables or device nodes.
--- fs/efivarfs/super.c | 2 ++ 1 file changed, 2 insertions(+)
fs/efivarfs/super.c +2 -0
@@ -8,6 +8,7 @@#include <linux/efi.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/fs_parser.h> #include <linux/module.h> #include <linux/pagemap.h>
@@ -554,6 +555,7 @@ static int efivarfs_init_fs_context(struct fs_context *fc) } fc->s_fs_info = sfi; +fc_init_pseudo (fc); fc->ops = &efivarfs_context_ops;return 0 ;
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 24/42] efivarfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize efivarfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. efivarfs never holds executables or device nodes.Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=24
Christian Brauner
maintainerRFC PATCH v2 25/42 pstore: use fc_init_pseudo()
In reply to Christian BraunerInitialize pstore as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. pstore never holds executables or device nodes.
--- fs/pstore/inode.c | 2 ++ 1 file changed, 2 insertions(+)
fs/pstore/inode.c +2 -0
@@ -18,6 +18,7 @@#include <linux/ramfs.h> #include <linux/fs_parser.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/sched.h> #include <linux/magic.h> #include <linux/pstore.h>
@@ -491,6 +492,7 @@ static int pstore_init_fs_context(struct fs_context *fc) ctx->kmsg_bytes = kmsg_bytes; fc->fs_private = ctx; +fc_init_pseudo (fc); fc->ops = &pstore_context_ops;return 0 ;
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 25/42] pstore: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize pstore as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. pstore never holds executables or device nodes.Reviewed-by Alexander Mikhalitsyn <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=25
Christian Brauner
maintainerRFC PATCH v2 26/42 xenfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize xenfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. xenfs never holds executables or device nodes.
SB_I_NOEXEC also refuses PROT_EXEC mappings. xenfs maps the xenstore page and guest memory through privcmd, both data.
--- drivers/xen/xenfs/super.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/xen/xenfs/super.c +2 -0
@@ -15,6 +15,7 @@#include <linux/module.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/magic.h> #include <xen/xen.h>
@@ -80,6 +81,7 @@ static const struct fs_context_operations xenfs_context_ops = {static int xenfs_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &xenfs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 26/42] xenfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 8 lines
Initialize xenfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. xenfs never holds executables or device nodes.
SB_I_NOEXECalso refusesPROT_EXECmappings. xenfs maps the xenstore page and guest memory through privcmd, both data.Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=26
Christian Brauner
maintainerRFC PATCH v2 27/42 openpromfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize openpromfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. openpromfs never holds executables or device nodes.
--- fs/openpromfs/inode.c | 2 ++ 1 file changed, 2 insertions(+)
fs/openpromfs/inode.c +2 -0
@@ -10,6 +10,7 @@#include <linux/string.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/seq_file.h>
@@ -419,6 +420,7 @@ static const struct fs_context_operations openpromfs_context_ops = {static int openpromfs_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &openpromfs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 27/42] openpromfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 5 lines
Initialize openpromfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. openpromfs never holds executables or device nodes.Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=27
Christian Brauner
maintainerRFC PATCH v2 28/42 ocfs2: use fc_init_pseudo() for dlmfs
In reply to Christian BraunerInitialize dlmfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. dlmfs never holds executables or device nodes.
--- fs/ocfs2/dlmfs/dlmfs.c | 2 ++ 1 file changed, 2 insertions(+)
fs/ocfs2/dlmfs/dlmfs.c +2 -0
@@ -21,6 +21,7 @@#include <linux/module.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/pagemap.h> #include <linux/types.h> #include <linux/slab.h>
@@ -563,6 +564,7 @@ static const struct fs_context_operations dlmfs_context_ops = {static int dlmfs_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &dlmfs_context_ops;return 0 ;
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 28/42] ocfs2: use fc_init_pseudo() for dlmfs
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
Initialize dlmfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. dlmfs never holds executables or device nodes.Reviewed-by Jan Kara <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=28
Christian Brauner
maintainerRFC PATCH v2 29/42 s390/hypfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize hypfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. hypfs never holds executables or device nodes.
--- arch/s390/hypfs/inode.c | 2 ++ 1 file changed, 2 insertions(+)
arch/s390/hypfs/inode.c +2 -0
@@ -12,6 +12,7 @@#include <linux/errno.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/fs_parser.h> #include <linux/namei.h> #include <linux/vfs.h>
@@ -301,6 +302,7 @@ static int hypfs_init_fs_context(struct fs_context *fc) sbi->gid =current_gid (); fc->s_fs_info = sbi; +fc_init_pseudo (fc); fc->ops = &hypfs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 29/42] s390/hypfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 5 lines
Initialize hypfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. hypfs never holds executables or device nodes.Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=29
Christian Brauner
maintainerRFC PATCH v2 30/42 powerpc/spufs: use fc_init_pseudo()
In reply to Christian BraunerInitialize spufs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. spufs never holds executables or device nodes.
SB_I_NOEXEC also refuses PROT_EXEC mappings. The spufs files that can be mapped expose local store and problem state areas of the SPU, nothing the PPU executes.
--- arch/powerpc/platforms/cell/spufs/inode.c | 2 ++ 1 file changed, 2 insertions(+)
arch/powerpc/platforms/cell/spufs/inode.c +2 -0
@@ -11,6 +11,7 @@#include <linux/file.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/fs_parser.h> #include <linux/fsnotify.h> #include <linux/backing-dev.h>
@@ -741,6 +742,7 @@ static int spufs_init_fs_context(struct fs_context *fc) fc->fs_private = ctx; fc->s_fs_info = sbi; +fc_init_pseudo (fc); fc->ops = &spufs_context_ops;return 0 ;
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 30/42] powerpc/spufs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 9 lines
Initialize spufs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. spufs never holds executables or device nodes.
SB_I_NOEXECalso refusesPROT_EXECmappings. The spufs files that can be mapped expose local store and problem state areas of the SPU, nothing the PPU executes.Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=30
Christian Brauner
maintainerRFC PATCH v2 31/42 usb: gadget: f_fs: use fc_init_pseudo()
In reply to Christian BraunerInitialize functionfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. functionfs never holds executables or device nodes.
--- drivers/usb/gadget/function/f_fs.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/usb/gadget/function/f_fs.c +2 -0
@@ -15,6 +15,7 @@/* #define VERBOSE_DEBUG */ #include <linux/blkdev.h> +#include <linux/pseudo_fs.h> #include <linux/dma-buf.h> #include <linux/dma-fence.h> #include <linux/dma-resv.h>
@@ -2166,6 +2167,7 @@ static int ffs_fs_init_fs_context(struct fs_context *fc) ctx->no_disconnect = false; fc->fs_private = ctx; +fc_init_pseudo (fc); fc->ops = &ffs_fs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 31/42] usb: gadget: f_fs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 5 lines
Initialize functionfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. functionfs never holds executables or device nodes.Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=31
Christian Brauner
maintainerRFC PATCH v2 32/42 usb: gadget: gadgetfs: use fc_init_pseudo()
In reply to Christian BraunerInitialize gadgetfs as a pseudo filesystem. This raises SB_I_PSEUDO and also SB_I_NOEXEC and SB_I_NODEV. gadgetfs never holds executables or device nodes.
--- drivers/usb/gadget/legacy/inode.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/usb/gadget/legacy/inode.c +2 -0
@@ -13,6 +13,7 @@#include <linux/module.h> #include <linux/fs.h> #include <linux/fs_context.h> +#include <linux/pseudo_fs.h> #include <linux/pagemap.h> #include <linux/uts.h> #include <linux/wait.h>
@@ -2223,6 +2224,7 @@ static const struct fs_context_operations gadgetfs_context_ops = {static int gadgetfs_init_fs_context (struct fs_context *fc) { +fc_init_pseudo (fc); fc->ops = &gadgetfs_context_ops;return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 32/42] usb: gadget: gadgetfs: use fc_init_pseudo()
Sashiko has reviewed this patch and found no issues.
Quoted 5 lines
Initialize gadgetfs as a pseudo filesystem. This raises
SB_I_PSEUDOand alsoSB_I_NOEXECandSB_I_NODEV. gadgetfs never holds executables or device nodes.Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=32
Christian Brauner
maintainerRFC PATCH v2 33/42 fs: add file_check_backing()
In reply to Christian BraunerLoop, zloop, the nvme target, the scsi target, fuse passthrough, the usb mass storage gadget, erofs and acct all take a file from userspace and use it as storage. Currently, each of them has its own idea of what to check before using a file like that:
- loop and the gadget check for a regular file or a block device, the nvme target, the scsi target and zloop take any file type
- loop checks the open mode, the gadget checks FMODE_CAN_READ, the nvme target, the scsi target and zloop only check for ->read_iter() and ->write_iter()
- apart from acct which refuses procfs and sysfs files none of them cares whether the file is a kernel interface
Add a helper that does all of it in one place. It only accepts regular files and, if the caller passes S_IFBLK, block devices. It refuses files on pseudo filesystems. And it checks that the file is open for what the caller is going to do with it and implements ->read_iter() for reading and ->write_iter() for writing.
O_PATH files are refused unless the caller passes FMODE_PATH. That is for callers that only need the path of the file. fuse passthrough is one of them and has accepted O_PATH file descriptors since commit efad7153bf93 ("fuse: allow O_PATH fd for FUSE_DEV_IOC_BACKING_OPEN").
Block devices are fine even though bdevfs is a pseudo filesystem. A block device that userspace hands in is a device node on devtmpfs or some other filesystem. Files on bdevfs only come from bdev_file_open_by_*() and never end up here.
The pseudo filesystem check looks at the inode that actually provides the data via d_real_inode(). overlayfs accepts sysfs, cgroup2, debugfs, tracefs, configfs and securityfs as lower layers and reads of such an overlayfs file are served by the file on the pseudo filesystem. Checking the overlayfs inode would miss that.
Note that the file type is taken from the inode of the file and not from the host of ->f_mapping like loop and the gadget do it. A driver can point ->f_mapping somewhere else in ->open(). It makes no difference for block devices as both inodes are block devices.
No functional changes. Nothing calls the helper yet.
--- fs/read_write.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ include/linux/fs.h | 2 ++ 2 files changed, 50 insertions(+)
fs/read_write.c +48 -0
@@ -866,6 +866,54 @@ static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,return ret; } +/** +* file_check_backing - check that the kernel can use a file as storage +* @file: file that userspace handed in +* @mode: FMODE_READ and/or FMODE_WRITE the kernel will do I/O with, or +* FMODE_PATH if only the path of @file is used +* @type: S_IFBLK if a block device is fine as well, 0 otherwise +* +* Call this where a file from userspace is taken as a backing file. Only +* regular files and, if @type is S_IFBLK, block devices are storage. Files +* on pseudo filesystems are kernel interfaces and are refused. The file +* must be open for @mode and implement ->read_iter() for reading and +* ->write_iter() for writing. O_PATH files are only fine with FMODE_PATH. +* +* Return: 0 on success, -EBADF if @file isn't open for @mode, -EINVAL if it +* can't be used as storage. +*/ +int file_check_backing (const struct file *file,fmode_t mode,umode_t type) +{ +fmode_t io = mode & (FMODE_READ |FMODE_WRITE ); +/* Drivers may point ->f_mapping at something else. */ +umode_t fmt =file_inode (file)->i_mode &S_IFMT ; + +/* O_PATH files are only fine for callers that just use the path. */ +if ((file->f_mode &FMODE_PATH ) && !(mode &FMODE_PATH )) +return -EBADF ; + +if ((file->f_mode & io) != io) +return -EBADF ; + +if (fmt !=S_IFREG && !(type ==S_IFBLK && fmt ==S_IFBLK )) +return -EINVAL ; + +/* Look through stacking filesystems at the inode with the data. */ +if (d_real_inode (file->f_path.dentry)->i_sb->s_iflags &SB_I_PSEUDO ) +return -EINVAL ; + +if ((mode &FMODE_READ ) && + (!(file->f_mode &FMODE_CAN_READ ) || !file->f_op->read_iter)) +return -EINVAL ; + +if ((mode &FMODE_WRITE ) && + (!(file->f_mode &FMODE_CAN_WRITE ) || !file->f_op->write_iter)) +return -EINVAL ; + +return 0 ; +} +EXPORT_SYMBOL_GPL (file_check_backing); +ssize_t vfs_iocb_iter_read (struct file *file,struct kiocb *iocb,struct iov_iter *iter) {
include/linux/fs.h +2 -0
@@ -2553,6 +2553,8 @@ static inline const struct inode *file_user_inode(const struct file *f)return file_inode (f); } +int file_check_backing (const struct file *file,fmode_t mode,umode_t type); +static inline struct file *file_clone_open (struct file *file) {return dentry_open (&file->f_path, file->f_flags, file->f_cred);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 33/42] fs: add file_check_backing()
Thank you for your contribution! Sashiko AI review found 1 potential issue to consider: - [Medium] fs: unverified overlayfs O_PATH d_real_inode() call in file_check_backing() --
Thank you for your contribution! Sashiko AI review found 1 potential issue to consider:
- [Medium] fs: unverified overlayfs O_PATH d_real_inode() call in file_check_backing()
--
commit 12b4c886c3329cc29a995a96a698923b0df5e8e2
Author: Christian Brauner <[email protected]>
fs: add file_check_backing()
This commit adds file_check_backing() to validate whether a userspace file can be used as backing storage by checking its open mode, file type, pseudo-filesystem status, and read/write iterator operations.
Quoted 8 lines
fs/read_write.c +0
-0@@ -866,6 +866,54 @@ static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,return ret; }
[ ... ]
Quoted 9 lines
fs/read_write.c +9
-0+int file_check_backing (const struct file *file,fmode_t mode,umode_t type) +{ +fmode_t io = mode & (FMODE_READ |FMODE_WRITE ); +/* Drivers may point ->f_mapping at something else. */ +umode_t fmt =file_inode (file)->i_mode &S_IFMT ; + +/* O_PATH files are only fine for callers that just use the path. */ +if ((file->f_mode &FMODE_PATH ) && !(mode &FMODE_PATH )) +return -EBADF ;
fs/read_write.c static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter, · line 903
Quoted 10 lines
fs/read_write.c +10
-0+ +if ((file->f_mode & io) != io) +return -EBADF ; + +if (fmt !=S_IFREG && !(type ==S_IFBLK && fmt ==S_IFBLK )) +return -EINVAL ; + +/* Look through stacking filesystems at the inode with the data. */ +if (d_real_inode (file->f_path.dentry)->i_sb->s_iflags &SB_I_PSEUDO ) +return -EINVAL ;
[Severity: Medium]
Can calling d_real_inode() on an O_PATH overlayfs file trigger a WARN(1) in ovl_d_real() and bypass the SB_I_PSEUDO check?
When a file is opened with O_PATH, do_dentry_open() returns before calling f->f_op->open(), so ovl_open() -> ovl_verify_lowerdata() has not run yet. When file_check_backing() is called with FMODE_PATH, d_real_inode() invokes ovl_d_real(dentry, D_REAL_DATA):
fs/overlayfs/super.c:ovl_d_real() {
...
err = ovl_verify_lowerdata(dentry);
if (err)
goto bug;
lower = ovl_dentry_lowerdata(dentry);
if (!lower)
goto bug;real_lower:
/* Handle recursion into stacked lower fs */ return d_real(lower, type);
bug:
WARN(1, "%s(%pd4, %d): real dentry not found\n", __func__, dentry, type); return dentry; }
On an overlayfs mount using data-only lower layers or metacopy verity validation, ovl_verify_lowerdata() takes the inode lock interruptibly via ovl_inode_lock_interruptible() and performs lazy lowerdata lookup or verity checks. If that fails (for instance with -EINTR from a pending signal, or -ENOENT / -EIO), ovl_d_real() fires WARN(1) and returns the overlayfs dentry itself. Because the overlayfs superblock does not set SB_I_PSEUDO, the check here passes even if the underlying data layer is a pseudo filesystem.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=33
[email protected]
AI reviewRe: [PATCH RFC v2 33/42] fs: add file_check_backing()
In reply to Christian BraunerTL;DR: file_check_backing() may call d_real_inode() on O_PATH overlayfs files, which could hit WARN in ovl_d_real() (panic with panic_on_warn) and let the pseudo-fs check pass wrongly; reachable via…
Quoted 1 line
fs: add
file_check_backing()
TL;DR: file_check_backing() may call d_real_inode() on O_PATH overlayfs files, which could hit WARN in ovl_d_real() (panic with panic_on_warn) and let the pseudo-fs check pass wrongly; reachable via fuse backing open, needs CAP_SYS_ADMIN.
Quoted 3 lines
fs/read_write.c +0
-0
[ ... ]
Quoted 2 lines
fs/read_write.c +2
-0+int file_check_backing (const struct file *file,fmode_t mode,umode_t type) +{
[ ... ]
fs/read_write.c static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter, · line 903
Quoted 3 lines
fs/read_write.c +3
-0+/* Look through stacking filesystems at the inode with the data. */ +if (d_real_inode (file->f_path.dentry)->i_sb->s_iflags &SB_I_PSEUDO ) +return -EINVAL ;
With FMODE_PATH accepted, can d_real_inode() be reached for an O_PATH file here? No ->open() has run on such a file.
For an overlayfs metacopy file whose data is in a data-only lower layer, the lowerdata redirect is only resolved lazily, by ovl_open() via ovl_verify_lowerdata() or by ovl_d_real(). For an O_PATH file this means d_real_inode() goes into ovl_d_real(), which does the lookup and verity check itself:
err = ovl_verify_lowerdata(dentry);
if (err)
goto bug;
...
bug:
WARN(1, "%s(%pd4, %d): real dentry not found\n", __func__, dentry, type);
return dentry;ovl_maybe_lookup_lowerdata() treats a failed lookup as a normal runtime event (pr_warn_ratelimited("lazy lowerdata lookup failed ...")). It can also return -EINTR from ovl_inode_lock_interruptible(), and ovl_maybe_validate_verity() returns -EIO for a missing or wrong digest with verity=require. Each of these would hit WARN(1) when reached through this helper, which panics with panic_on_warn.
In that case ovl_d_real() returns the overlayfs dentry, so the SB_I_PSEUDO test looks at the overlayfs superblock and passes. Does the check fail open there?
Nothing calls the helper in this commit, but later in the series f79b9e79484f ("fuse: refuse files on pseudo filesystems as passthrough backing files") adds file_check_backing(file, FMODE_PATH, 0) to fuse_backing_open_file(). That gets its fd via CLASS(fd_raw), which accepts O_PATH:
FUSE_DEV_IOC_BACKING_OPEN
fuse_backing_new()
fuse_backing_open_file()
file_check_backing()
d_real_inode()
ovl_d_real()
ovl_verify_lowerdata() fails -> WARNThis needs CAP_SYS_ADMIN and an overlayfs with data-only layers where the data file is missing, the digest check fails, or the inode lock is contended while a signal is pending. No fix for this was found later in the series.
Could the pseudo filesystem check avoid forcing the lazy lowerdata lookup on O_PATH files, or should ovl_d_real() stop warning on lookup failures now that it has callers besides trace_uprobe?
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/43599461726
Re: [PATCH RFC v2 33/42] fs: add file_check_backing()
In reply to Christian BraunerHi Christian,
fs/read_write.c static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter, · line 903
Quoted 3 lines · Christian Brauner
fs/read_write.c +3
-0+/* Look through stacking filesystems at the inode with the data. */ +if (d_real_inode (file->f_path.dentry)->i_sb->s_iflags &SB_I_PSEUDO ) +return -EINVAL ;
This looks good in general, but what the bots said about O_PATH files here is real. With FMODE_PATH this is reached for a file that was never opened, so on overlayfs nothing has been through ovl_open() to look up the lowerdata of a metacopy file yet. ovl_d_real() then does the lookup itself, and when that fails it hits the WARN(1) at its end and returns the overlayfs dentry, so the check passes as well.
Only fuse passes FMODE_PATH, so it takes CAP_SYS_ADMIN to get there, but it's easy to trigger with that. From a quick test with a metacopy file whose redirect into a data-only layer points at nothing, registering an O_PATH fd of it with FUSE_DEV_IOC_BACKING_OPEN gives
ovl_d_real(/f, 0): real dentry not found
WARNING: fs/overlayfs/super.c:79 at ovl_d_real+0xc9/0x210
[...]
file_check_backing+0x308/0x5e0
fuse_backing_new+0x219/0x4a0
fuse_backing_open+0xe8/0x390
fuse_dev_ioctl+0x53a/0x7d0and the ioctl still succeeds. A normal open of that file fails with ENOENT, so nothing could have used it as a backing file anyway, but with panic_on_warn this is now a panic.
Maybe ovl_d_real() should just stop warning when the lookup fails, now that it has a caller that isn't trace_uprobe? The check would still pass for an O_PATH file whose lowerdata couldn't be looked up at that point, though.
Thanks!
Chris
Amir Goldstein
maintainerRe: [PATCH RFC v2 33/42] fs: add file_check_backing()
Quoted 28 lines · Chris Down
Hi Christian,
fs/read_write.c static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter, · line 903
Quoted 3 lines · Christian Brauner
fs/read_write.c +3
-0+/* Look through stacking filesystems at the inode with the data. */ +if (d_real_inode (file->f_path.dentry)->i_sb->s_iflags &SB_I_PSEUDO ) +return -EINVAL ;This looks good in general, but what the bots said about
O_PATHfiles here is real. WithFMODE_PATHthis is reached for a file that was never opened, so on overlayfs nothing has been throughovl_open()to look up the lowerdata of a metacopy file yet.ovl_d_real()then does the lookup itself, and when that fails it hits the WARN(1) at its end and returns the overlayfs dentry, so the check passes as well.Only fuse passes
FMODE_PATH, so it takesCAP_SYS_ADMINto get there, but it's easy to trigger with that. From a quick test with a metacopy file whose redirect into a data-only layer points at nothing, registering anO_PATHfd of it withFUSE_DEV_IOC_BACKING_OPENgivesovl_d_real(/f, 0): real dentry not found WARNING: fs/overlayfs/super.c:79 at ovl_d_real+0xc9/0x210 [...] file_check_backing+0x308/0x5e0 fuse_backing_new+0x219/0x4a0 fuse_backing_open+0xe8/0x390 fuse_dev_ioctl+0x53a/0x7d0
Quoted 6 lines
and the ioctl still succeeds. A normal open of that file fails with ENOENT, so nothing could have used it as a backing file anyway, but with
panic_on_warnthis is now a panic.Maybe
ovl_d_real()should just stop warning when the lookup fails, now that it has a caller that isn'ttrace_uprobe?
Yeh I guess that this needs to be a Fixes for lazy data lookup.
The correct fix would be to teach all the callers to deal with an error.
Quoted 3 lines
The check would still pass
for anO_PATHfile whose lowerdata couldn't be looked up at that point, though.
One observation relevant to this patch set is that a datadir layer has no business being a pseudo fs and that can and should be blocked explicitly at overlayfs mount time.
The other observation is that fuse_passthrough_open() should probably check the backing_file that was opened for io in addition to checking in fuse_backing_open(), which could have different FMODE and specifically could be FMODE_PATH.
Thanks,
Amir.
Christian Brauner
maintainerRe: [PATCH RFC v2 33/42] fs: add file_check_backing()
Quoted 29 lines · Amir Goldstein
Quoted 28 lines · Chris Down
Hi Christian,
fs/read_write.c static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter, · line 903
Quoted 3 lines · Christian Brauner
fs/read_write.c +3
-0+/* Look through stacking filesystems at the inode with the data. */ +if (d_real_inode (file->f_path.dentry)->i_sb->s_iflags &SB_I_PSEUDO ) +return -EINVAL ;This looks good in general, but what the bots said about
O_PATHfiles here is real. WithFMODE_PATHthis is reached for a file that was never opened, so on overlayfs nothing has been throughovl_open()to look up the lowerdata of a metacopy file yet.ovl_d_real()then does the lookup itself, and when that fails it hits the WARN(1) at its end and returns the overlayfs dentry, so the check passes as well.Only fuse passes
FMODE_PATH, so it takesCAP_SYS_ADMINto get there, but it's easy to trigger with that. From a quick test with a metacopy file whose redirect into a data-only layer points at nothing, registering anO_PATHfd of it withFUSE_DEV_IOC_BACKING_OPENgivesovl_d_real(/f, 0): real dentry not found WARNING: fs/overlayfs/super.c:79 at ovl_d_real+0xc9/0x210 [...] file_check_backing+0x308/0x5e0 fuse_backing_new+0x219/0x4a0 fuse_backing_open+0xe8/0x390 fuse_dev_ioctl+0x53a/0x7d0
Quoted 8 lines
Quoted 6 lines
and the ioctl still succeeds. A normal open of that file fails with ENOENT, so nothing could have used it as a backing file anyway, but with
panic_on_warnthis is now a panic.Maybe
ovl_d_real()should just stop warning when the lookup fails, now that it has a caller that isn'ttrace_uprobe?Yeh I guess that this needs to be a Fixes for lazy data lookup.
I have a fix for that.
Quoted 1 line
The correct fix would be to teach all the callers to deal with an error.
I've also implemented that. It wasn't that hard and it's also a bug. Not a bad one but still.
Quoted 7 lines
Quoted 3 lines
The check would still pass
for anO_PATHfile whose lowerdata couldn't be looked up at that point, though.One observation relevant to this patch set is that a datadir layer has no business being a pseudo fs and that can and should be blocked explicitly at overlayfs mount time.
I agree.
Quoted 4 lines
The other observation is that
fuse_passthrough_open()should probably check thebacking_filethat was opened for io in addition to checking infuse_backing_open(), which could have different FMODE and specifically could beFMODE_PATH.
Sounds good.
Christian Brauner
maintainerRFC PATCH v2 34/42 loop: refuse files on pseudo filesystems as backing files
In reply to Christian BraunerCurrently loop accepts any regular file that implements ->read_iter() as a backing file and any that also implements ->write_iter() as a writable one. That includes files on procfs, sysfs and other pseudo filesystems. For example, /proc/kcore attaches read-only as a loop device the size of the kernel's virtual address space, 64 PiB with 5-level paging. sysfs attributes attach read-write as 4096 byte loop devices. Writing a block to the loop device of /sys/kernel/mm/transparent_hugepage/enabled changes the THP setting.
That's not just nonsensical, it can be abused. Loop calls ->read_iter() and ->write_iter() of the backing file directly from its worker which runs with kernel credentials. But pseudo files enforce part of their access rules at read and write time against current. Dozens of sysfs ->show() and ->store() methods call capable(). Behind a loop device all of these checks are done against the loop worker instead of the task that opened the file. And setting up a loop device requires no capabilities, only access to the device nodes. So on v7.4-rc1:
- uid 0 without any capabilities can't write to /sys/kernel/reboot/mode as mode_store() requires CAP_SYS_BOOT. Writing "warm" through a loop device works.
- uid 0 without any capabilities can't read the files in /sys/firmware/dmi/entries/*/ as dmi_sysfs_attr_show() requires CAP_SYS_ADMIN. Reading them through a loop device works.
- An unprivileged container that was handed a loop device can't change gro_flush_timeout of its own network devices as gro_flush_timeout_store() requires CAP_NET_ADMIN in the initial user namespace. Writing it through a loop device works.
The same goes for hard_offline_page, the md and sd attributes, rfkill and others.
Refuse files on pseudo filesystems as loop backing files by switching to file_check_backing(). Note that it looks through overlayfs so stacking overlayfs on top of sysfs doesn't get around this.
The helper also does the file type, open mode and method checks that loop did itself so far. The check for a regular file or a block device now happens before the loop device is locked and it looks at the inode of the file instead of the host of ->f_mapping. For regular files and block devices both have the same type.
--- drivers/block/loop.c | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-)
drivers/block/loop.c +4 -13
@@ -492,7 +492,6 @@ static inline int is_loop_device(struct file *file)static int loop_validate_file (struct file *file,struct block_device *bdev) { -struct inode *inode = file->f_mapping->host;struct file *f = file;/* Avoid recursion */
@@ -510,8 +509,6 @@ static int loop_validate_file(struct file *file, struct block_device *bdev)rmb (); f = l->lo_backing_file; } -if (!S_ISREG (inode->i_mode) && !S_ISBLK (inode->i_mode)) -return -EINVAL ;return 0 ; }
@@ -528,16 +525,10 @@ static void loop_assign_backing_file(struct loop_device *lo, struct file *file)static int loop_check_backing_file (struct file *file) { -if (!(file->f_mode &FMODE_READ )) -return -EBADF ; - -if (!file->f_op->read_iter) -return -EINVAL ; - -if ((file->f_mode &FMODE_WRITE ) && !file->f_op->write_iter) -return -EINVAL ; - -return 0 ; +/* A backing file that isn't open for writing gives a read-only device. */ +return file_check_backing (file, +FMODE_READ | (file->f_mode &FMODE_WRITE ), +S_IFBLK ); }/* loop sysfs attributes */
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 34/42] loop: refuse files on pseudo filesystems as backing files
Sashiko has reviewed this patch and found no issues.
Quoted 20 lines
Currently loop accepts any regular file that implements ->read_iter() as a backing file and any that also implements ->write_iter() as a writable one. That includes files on procfs, sysfs and other pseudo filesystems. For example,
/proc/kcoreattaches read-only as a loop device the size of the kernel's virtual address space, 64 PiB with 5-level paging. sysfs attributes attach read-write as 4096 byte loop devices. Writing a block to the loop device of/sys/kernel/mm/transparent_hugepage/enabledchanges the THP setting.That's not just nonsensical, it can be abused. Loop calls ->read_iter() and ->write_iter() of the backing file directly from its worker which runs with kernel credentials. But pseudo files enforce part of their access rules at read and write time against current. Dozens of sysfs ->show() and ->store() methods call
capable(). Behind a loop device all of these checks are done against the loop worker instead of the task [ ... ]
now happens before the loop device is locked and it looks at the inode of the file instead of the host of ->f_mapping. For regular files and block devices both have the same type.
Quoted 1 line
Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=34
Christian Brauner
maintainerRFC PATCH v2 35/42 zloop: refuse zone files on pseudo filesystems
In reply to Christian Braunerzloop opens its zone files by name below the base directory but a bind mount can put any file there, including a procfs or sysfs file. Refuse files on pseudo filesystems as zone files just like loop does by switching to file_check_backing().
Note that the helper only accepts regular files. So far zloop took anything with ->read_iter() and ->write_iter() as a zone file. That includes character devices, FIFOs and block devices if someone put them where zloop expects a zone file. Zone files are created by zloop itself and zloop truncates them to size and to reset and finish zones which only works for regular files. So refuse everything else.
--- drivers/block/zloop.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
drivers/block/zloop.c +2 -3
@@ -1132,10 +1132,9 @@ static int zloop_init_zone(struct zloop_device *zlo, struct zloop_options *opts,return PTR_ERR (zone->file); } -if (!zone->file->f_op->read_iter || !zone->file->f_op->write_iter) { - ret = -EINVAL ; + ret =file_check_backing (zone->file,FMODE_READ |FMODE_WRITE ,0 ); +if (ret) goto out_fput; - }if (zlo->block_size) { ret =zloop_get_block_size (zlo, zone);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 35/42] zloop: refuse zone files on pseudo filesystems
Sashiko has reviewed this patch and found no issues.
Quoted 5 lines
zloop opens its zone files by name below the base directory but a bind mount can put any file there, including a procfs or sysfs file. Refuse files on pseudo filesystems as zone files just like loop does by switching to
file_check_backing().
Quoted 8 lines
Note that the helper only accepts regular files. So far zloop took anything with ->read_iter() and ->write_iter() as a zone file. That includes character devices, FIFOs and block devices if someone put them where zloop expects a zone file. Zone files are created by zloop itself and zloop truncates them to size and to reset and finish zones which only works for regular files. So refuse everything else.
Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=35
Christian Brauner
maintainerRFC PATCH v2 36/42 nvmet: refuse files on pseudo filesystems as namespace backing files
In reply to Christian BraunerThe file backend takes any file that can be opened for reading and writing. With buffered_io=1 that includes files on procfs or sysfs which then get read and written by a kernel worker on behalf of the host. Refuse files on pseudo filesystems just like loop does by switching to file_check_backing().
Note that the helper only accepts regular files and block devices. A block device ends up in the file backend when buffered_io is set. But so far the file backend also took anything else with ->read_iter() and ->write_iter() such as character devices and FIFOs. The size of the namespace is the size of the inode which is zero for all of them. So such a namespace was unusable anyway. Refuse them.
--- drivers/nvme/target/io-cmd-file.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
drivers/nvme/target/io-cmd-file.c +2 -3
@@ -47,10 +47,9 @@ int nvmet_file_ns_enable(struct nvmet_ns *ns)return ret; } -if (!ns->file->f_op->read_iter || !ns->file->f_op->write_iter) { - ret = -EINVAL ; + ret =file_check_backing (ns->file,FMODE_READ |FMODE_WRITE ,S_IFBLK ); +if (ret) goto err; - }nvmet_file_ns_revalidate (ns);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 36/42] nvmet: refuse files on pseudo filesystems as namespace backing files
Sashiko has reviewed this patch and found no issues.
Quoted 6 lines
The file backend takes any file that can be opened for reading and writing. With buffered_io=1 that includes files on procfs or sysfs which then get read and written by a kernel worker on behalf of the host. Refuse files on pseudo filesystems just like loop does by switching to
file_check_backing().
Quoted 8 lines
Note that the helper only accepts regular files and block devices. A block device ends up in the file backend when
buffered_iois set. But so far the file backend also took anything else with ->read_iter() and ->write_iter() such as character devices and FIFOs. The size of the namespace is the size of the inode which is zero for all of them. So such a namespace was unusable anyway. Refuse them.Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=36
Christian Brauner
maintainerRFC PATCH v2 37/42 target: fileio: refuse files on pseudo filesystems as backing files
In reply to Christian Braunerfd_dev_name can name any file including files on procfs or sysfs. The initiator then gets to read and write kernel interfaces through the LUN with kernel credentials. Refuse files on pseudo filesystems just like loop does by switching to file_check_backing().
Do the same for the protection file. With DIF protection enabled the fileio backend keeps the protection information in a second file. It is named like the backing file with ".protection" appended and fd_init_prot() opens it by path. Whatever that path leads to was taken without any checks.
Note that the helper only accepts regular files and block devices as backing file and only regular files as protection file. So far the backing file could be anything with ->read_iter() and ->write_iter() including character devices and FIFOs.
--- drivers/target/target_core_file.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
drivers/target/target_core_file.c +8 -2
@@ -145,8 +145,8 @@ static int fd_configure_device(struct se_device *dev) } fd_dev->fd_file = file; -if (!file->f_op->read_iter || !file->f_op->write_iter) { -pr_err ("FILEIO: %s lacks ->read_iter or ->write_iter\n" , +if (file_check_backing (file,FMODE_READ |FMODE_WRITE ,S_IFBLK )) { +pr_err ("FILEIO: %s can't be used as a backing file\n" , fd_dev->fd_dev_name); ret = -EINVAL ; goto fail;
@@ -861,6 +861,12 @@ static int fd_init_prot(struct se_device *dev) ret =PTR_ERR (prot_file);return ret; } + +if (file_check_backing (prot_file,FMODE_READ |FMODE_WRITE ,0 )) { +pr_err ("FILEIO: %s can't be used as a protection file\n" , buf); +filp_close (prot_file,NULL ); +return -EINVAL ; + } fd_dev->fd_prot_file = prot_file;return 0 ;
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 37/42] target: fileio: refuse files on pseudo filesystems as backing files
Sashiko has reviewed this patch and found no issues.
Quoted 11 lines
fd_dev_namecan name any file including files on procfs or sysfs. The initiator then gets to read and write kernel interfaces through the LUN with kernel credentials. Refuse files on pseudo filesystems just like loop does by switching tofile_check_backing().Do the same for the protection file. With DIF protection enabled the fileio backend keeps the protection information in a second file. It is named like the backing file with ".protection" appended and
fd_init_prot()opens it by path. Whatever that path leads to was taken without any checks.
Quoted 8 lines
Note that the helper only accepts regular files and block devices as backing file and only regular files as protection file. So far the backing file could be anything with ->read_iter() and ->write_iter() including character devices and FIFOs.
Reported-by Sashiko <[email protected]>Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=37
Christian Brauner
maintainerRFC PATCH v2 38/42 fuse: refuse files on pseudo filesystems as passthrough backing files
In reply to Christian BraunerThe fuse server can register any regular file as a backing file. procfs and binfmt_misc files are already refused by the stacking depth check as both set s_stack_depth to FILESYSTEM_MAX_STACK_DEPTH. sysfs and the other pseudo filesystems aren't. Reads and writes of the fuse file would then be done on the pseudo file with the fuse server's credentials. Refuse files on pseudo filesystems just like loop does.
Note that the backing file is only registered here and opened again for every fuse file that uses it. Only its path is used and O_PATH file descriptors are allowed since commit efad7153bf93 ("fuse: allow O_PATH fd for FUSE_DEV_IOC_BACKING_OPEN"). So pass FMODE_PATH to file_check_backing() to keep them working.
--- fs/fuse/backing.c | 4 ++++ 1 file changed, 4 insertions(+)
fs/fuse/backing.c +4 -0
@@ -147,6 +147,10 @@ static int fuse_backing_open_file(struct fuse_conn *fc, struct fuse_backing *fb,if (inode->i_sb->s_stack_depth >= fc->max_stack_depth)return -ELOOP ; + err =file_check_backing (file,FMODE_PATH ,0 ); +if (err) +return err; + fb->type =FUSE_BACKING_PATH ; fb->path = file->f_path;path_get (&fb->path);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 38/42] fuse: refuse files on pseudo filesystems as passthrough backing files
Thank you for your contribution! Sashiko AI review found 1 potential issue to consider: - [Medium] fuse: file_check_backing() with FMODE_PATH on unverified ovl dentry fails open --
Thank you for your contribution! Sashiko AI review found 1 potential issue to consider:
- [Medium] fuse: file_check_backing() with FMODE_PATH on unverified ovl dentry fails open
--
commit 3377a8521784786f7f79c18bd3aafabd17e04633
Author: Christian Brauner <[email protected]>
fuse: refuse files on pseudo filesystems as passthrough backing files
This commit calls file_check_backing() in fuse_backing_open_file() to reject regular files on pseudo filesystems when registering FUSE passthrough backing files.
fs/fuse/backing.c static int fuse_backing_open_file(struct fuse_conn *fc, struct fuse_backing *fb, · line 152
Quoted 11 lines
fs/fuse/backing.c +3
-0@@ -147,6 +147,10 @@ static int fuse_backing_open_file(struct fuse_conn *fc, struct fuse_backing *fb,if (inode->i_sb->s_stack_depth >= fc->max_stack_depth)return -ELOOP ; + err =file_check_backing (file,FMODE_PATH ,0 ); +if (err) +return err;
[Severity: Medium]
Can calling file_check_backing() with FMODE_PATH on an O_PATH overlayfs file trigger a WARN(1) in ovl_d_real() and fail open?
Unlike a normal open(), opening with O_PATH returns from do_dentry_open() before calling ovl_open() -> ovl_verify_lowerdata(). When file_check_backing() then calls d_real_inode(file->f_path.dentry), ovl_d_real() runs ovl_verify_lowerdata() on the unverified dentry:
fs/overlayfs/super.c:ovl_d_real() {
...
err = ovl_verify_lowerdata(dentry);
if (err)
goto bug;
lower = ovl_dentry_lowerdata(dentry);
if (!lower)
goto bug;real_lower:
/* Handle recursion into stacked lower fs */ return d_real(lower, type);
bug:
WARN(1, "%s(%pd4, %d): real dentry not found\n", __func__, dentry, type); return dentry; }
If ovl_verify_lowerdata() fails (for example, -ENOENT on a broken metacopy redirect in a data-only lower layer, -EIO on verity failure, or -EINTR in ovl_maybe_lookup_lowerdata()), ovl_d_real() hits the WARN(1) and returns the overlayfs dentry itself. Because the overlayfs superblock does not have SB_I_PSEUDO set, file_check_backing() returns 0 and registers fb->path; if the failure was transient, a later fuse_passthrough_open() -> backing_file_open() -> vfs_open() -> ovl_open() can still resolve the lower data dentry on a pseudo filesystem.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=38
Christian Brauner
maintainerRFC PATCH v2 39/42 usb: gadget: f_mass_storage: refuse files on pseudo filesystems
In reply to Christian Braunerfsg_lun_open() takes any regular file as the backing file of a LUN. The file-storage kthread then reads and writes it with kernel_read() and kernel_write() on behalf of the USB host. With a procfs or sysfs file behind a LUN the host gets to read and write kernel interfaces with kernel credentials. Refuse files on pseudo filesystems just like loop does by switching to file_check_backing().
The helper also does the file type and readability checks. So the messages for an unsuitable backing file become one. It looks at the inode of the file instead of the host of ->f_mapping. For regular files and block devices both have the same type. It also wants ->read_iter() where FMODE_CAN_READ was enough so far. But kernel_read() never worked without ->read_iter() anyway.
--- drivers/usb/gadget/function/storage_common.c | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-)
drivers/usb/gadget/function/storage_common.c +3 -8
@@ -205,23 +205,18 @@ int fsg_lun_open(struct fsg_lun *curlun, const char *filename)if (!(filp->f_mode &FMODE_WRITE )) ro =1 ; - inode = filp->f_mapping->host; -if ((!S_ISREG (inode->i_mode) && !S_ISBLK (inode->i_mode))) { -LINFO (curlun,"invalid file type: %s\n" , filename); - goto out; - } -/* * If we can't read the file, it's no good. * If we can't write the file, use it read-only. */ -if (!(filp->f_mode &FMODE_CAN_READ )) { -LINFO (curlun,"file not readable: %s\n" , filename); +if (file_check_backing (filp,FMODE_READ ,S_IFBLK )) { +LINFO (curlun,"invalid backing file: %s\n" , filename); goto out; }if (!(filp->f_mode &FMODE_CAN_WRITE )) ro =1 ; + inode = filp->f_mapping->host; size =i_size_read (inode);if (size <0 ) {LINFO (curlun,"unable to find file size: %s\n" , filename);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 39/42] usb: gadget: f_mass_storage: refuse files on pseudo filesystems
Sashiko has reviewed this patch and found no issues.
Quoted 7 lines
fsg_lun_open()takes any regular file as the backing file of a LUN. The file-storage kthread then reads and writes it withkernel_read()andkernel_write()on behalf of the USB host. With a procfs or sysfs file behind a LUN the host gets to read and write kernel interfaces with kernel credentials. Refuse files on pseudo filesystems just like loop does by switching tofile_check_backing().
Quoted 8 lines
The helper also does the file type and readability checks. So the messages for an unsuitable backing file become one. It looks at the inode of the file instead of the host of ->f_mapping. For regular files and block devices both have the same type. It also wants ->read_iter() where
FMODE_CAN_READwas enough so far. Butkernel_read()never worked without ->read_iter() anyway.Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=39
Christian Brauner
maintainerRFC PATCH v2 40/42 erofs: refuse files on pseudo filesystems as backing files
In reply to Christian BraunerFile-backed mounts take any regular file as the image and the same goes for the extra devices of such a mount. erofs reads them with the credentials of the mounter so this doesn't hand out anything the mounter couldn't read anyway. But files on pseudo filesystems aren't images. Refuse them just like loop does.
file_check_backing() also checks that the file is open for reading. So a source file descriptor that erofs can't read from fails the mount right away instead of on the first read.
--- fs/erofs/super.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
fs/erofs/super.c +4 -1
@@ -158,7 +158,7 @@ static int erofs_init_device(struct erofs_buf *buf, struct super_block *sb,if (!erofs_is_fileio_mode (sbi)) { dif->dax_dev =fs_dax_get_by_bdev (file_bdev (file), &dif->dax_part_off,NULL ,NULL ); - }else if (!S_ISREG (file_inode (file)->i_mode)) { + }else if (file_check_backing (file,FMODE_READ ,0 )) {fput (file);return -EINVAL ; }
@@ -835,6 +835,9 @@ static int erofs_file_get_tree(struct fs_context *fc) {struct erofs_sb_info *sbi = fc->s_fs_info; +if (file_check_backing (sbi->dif0.file,FMODE_READ ,0 )) +return invalfc (fc,"source can't be used as a backing file" ); +if (!test_opt (&sbi->opt,SUPERBLOCK_SHARE ))return get_tree_nodev (fc, erofs_fc_fill_super);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 40/42] erofs: refuse files on pseudo filesystems as backing files
Sashiko has reviewed this patch and found no issues.
Quoted 11 lines
File-backed mounts take any regular file as the image and the same goes for the extra devices of such a mount. erofs reads them with the credentials of the mounter so this doesn't hand out anything the mounter couldn't read anyway. But files on pseudo filesystems aren't images. Refuse them just like loop does.
file_check_backing()also checks that the file is open for reading. So a source file descriptor that erofs can't read from fails the mount right away instead of on the first read.Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=40
Christian Brauner
maintainerRFC PATCH v2 41/42 acct: refuse files on pseudo filesystems
In reply to Christian Brauneracct(2) already refuses to write its records to files on kernel internal filesystems and to procfs and sysfs files. It recognizes the latter two by FS_USERNS_MOUNT_RESTRICTED which misses every other pseudo filesystem. So a cgroup2 or binfmt_misc file is accepted as the accounting file.
The records are written with the credentials of whoever turned on accounting so this isn't abusable the way loop is. But files on pseudo filesystems aren't a place to store accounting records. Use file_check_backing() to refuse all of them.
SB_NOUSER doesn't need to be checked separately anymore. It is only raised by pseudo filesystems and by tmpfs instances that are either kernel internal or can't be mounted.
--- kernel/acct.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
kernel/acct.c +3 -3
@@ -245,11 +245,11 @@ static int acct_on(const char __user *name)return -EACCES ;/* Exclude kernel internal filesystems. */ -if (file_inode (file)->i_sb->s_flags & (SB_NOUSER |SB_KERNMOUNT )) +if (file_inode (file)->i_sb->s_flags &SB_KERNMOUNT )return -EINVAL ; -/* Exclude procfs and sysfs. */ -if (file_inode (file)->i_sb->s_type->fs_flags &FS_USERNS_MOUNT_RESTRICTED ) +/* Exclude pseudo filesystems. */ +if (file_check_backing (file,0 ,0 ))return -EINVAL ;if (!(file->f_mode &FMODE_CAN_WRITE ))
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 41/42] acct: refuse files on pseudo filesystems
Sashiko has reviewed this patch and found no issues.
Quoted 11 lines
acct(2) already refuses to write its records to files on kernel internal filesystems and to procfs and sysfs files. It recognizes the latter two by
FS_USERNS_MOUNT_RESTRICTEDwhich misses every other pseudo filesystem. So a cgroup2 orbinfmt_miscfile is accepted as the accounting file.The records are written with the credentials of whoever turned on accounting so this isn't abusable the way loop is. But files on pseudo filesystems aren't a place to store accounting records. Use
file_check_backing()to refuse all of them.
Quoted 7 lines
SB_NOUSERdoesn't need to be checked separately anymore. It is only raised by pseudo filesystems and by tmpfs instances that are either kernel internal or can't be mounted.
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=41
Christian Brauner
maintainerRFC PATCH v2 42/42 selftests/filesystems: add backing file tests for pseudo files
In reply to Christian BraunerAdd tests that files on pseudo filesystems can't be used as storage:
- a procfs file attached read-only to a loop device
- sysfs files attached read-only and read-write to a loop device
- a sysfs file behind a lower-only overlayfs attached to a loop device
- a symlink and a magic link to a sysfs file attached to a loop device
- a procfs file as the backing file of an nvme target namespace
- a procfs file as the backing file and as the protection file of a fileio device of the scsi target
- a procfs file as a zloop zone file
- a sysfs file as the backing file of a usb mass storage gadget LUN
- a sysfs file as the source of a file-backed erofs mount
Add tests that FIFOs and character devices can't be used as storage by loop, the nvme target, the fileio backend and zloop either.
And make sure that a memfd and another loop device still work as loop backing files, that a regular file and a block device still work for the nvme target and the fileio backend and that loop refuses a backing file that isn't open for reading.
The nvme target test uses buffered_io as asked for in [1]. Most pseudo files can't be opened with O_DIRECT and the test would pass without ever reaching the check.
[1]: https://lore.kernel.org/r/[email protected]
--- tools/testing/selftests/filesystems/.gitignore | 1 + tools/testing/selftests/filesystems/Makefile | 2 +- tools/testing/selftests/filesystems/config | 14 + .../selftests/filesystems/pseudo_backing_test.c | 570 +++++++++++++++++++++ 4 files changed, 586 insertions(+), 1 deletion(-)
tools/testing/selftests/filesystems/.gitignore +1 -0
@@ -7,3 +7,4 @@ kernfs_test idmapped_tmpfile ustat_test rw_hint_test +pseudo_backing_test
tools/testing/selftests/filesystems/Makefile +1 -1
@@ -2,7 +2,7 @@ CFLAGS += $(KHDR_INCLUDES) TEST_GEN_PROGS := devpts_pts anon_inode_test kernfs_test fclog ustat_test rw_hint_test -TEST_GEN_PROGS += idmapped_tmpfile +TEST_GEN_PROGS += idmapped_tmpfile pseudo_backing_test TEST_GEN_PROGS_EXTENDED := dnotify_test include ../lib.mk
tools/testing/selftests/filesystems/config +14 -0
@@ -6,3 +6,17 @@ CONFIG_NET=y CONFIG_NET_NS=y CONFIG_INET=y CONFIG_SYSFS=y +CONFIG_BLK_DEV_LOOP=y +CONFIG_OVERLAY_FS=y +CONFIG_TMPFS=y +CONFIG_CONFIGFS_FS=y +CONFIG_USB_GADGET=y +CONFIG_USB_CONFIGFS=y +CONFIG_USB_CONFIGFS_MASS_STORAGE=y +CONFIG_EROFS_FS=y +CONFIG_EROFS_FS_BACKED_BY_FILE=y +CONFIG_NVME_TARGET=y +CONFIG_TARGET_CORE=y +CONFIG_TCM_FILEIO=y +CONFIG_BLK_DEV_ZONED=y +CONFIG_BLK_DEV_ZONED_LOOP=y
tools/testing/selftests/filesystems/pseudo_backing_test.c new file +570 -0
570 lines not on this page · raw message
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH RFC v2 42/42] selftests/filesystems: add backing file tests for pseudo files
Sashiko has reviewed this patch and found no issues.
Quoted 21 lines
Add tests that files on pseudo filesystems can't be used as storage:
- a procfs file attached read-only to a loop device
- sysfs files attached read-only and read-write to a loop device
- a sysfs file behind a lower-only overlayfs attached to a loop device
- a symlink and a magic link to a sysfs file attached to a loop device
- a procfs file as the backing file of an nvme target namespace
- a procfs file as the backing file and as the protection file of a fileio device of the scsi target
- a procfs file as a zloop zone file
- a sysfs file as the backing file of a usb mass storage gadget LUN
- a sysfs file as the source of a file-backed erofs mountAdd tests that FIFOs and character devices can't be used as storage by loop, the nvme target, the fileio backend and zloop either.
And make sure that a memfd and another loop device still work as loop backing files, that a regular file and a block device still work for the nvme target and the fileio backend and that loop refuses a backing file that isn't open for reading.
Quoted 7 lines
The nvme target test uses
buffered_ioas asked for in [1]. Most pseudo files can't be opened withO_DIRECTand the test would pass without ever reaching the check.[1]: https://lore.kernel.org/r/[email protected]
Signed-off-by Christian Brauner (Amutable) <[email protected]>
Sashiko has reviewed this patch and found no issues.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=42
Hi Christian,
Patches 1-11, 13-16, 18-26, 28, 31, 32, 34-37 and 39-42 look good to me, so for those please feel free to add:
I've also tested 5, 6, 34-37, 41 and 42. The selftests all pass with the series applied, and a uid 0 without capabilities can no longer change /sys/kernel/reboot/mode through a loop device. So for those, please also feel free to add:
I've replied separately to 17 and 33.
Thanks!
Chris