fs,kthread: start all kthreads in nullfs
Subsystems (18)
Christian Brauner
maintainerv4 cover fs,kthread: start all kthreads in nullfs
I have not heard any big complaints. So I would like to move this into -next. But I _do not_ intend to merge anything this cycle. Given that this is a fundamental change I want this to be in -next for the rest of this cycle and the whole 7.3 cycle.
Summary:
* all kthreads are isolated in a separate SB_KERNMOUNT of nullfs. -> no lookup of anything else, no mounting on top of it, completely isolated.
* init has a separate fs_struct from all kthreads
* scoped_with_init_fs() allows a kthread to temporarily assume init's fs_struct for filesystem operations.
So this is a bit of a crazy series. When the kernel is started it roughly goes like this:
init_task
==> create pid 1 (systemd etc.)
==> pid 2 (kthreadd)
After this point all kthreads and PID 1 share the same filesystem state. That obviously already came up when we discussed pivot_root() as this allows pivot_root() to rewrite the fs_struct of all kthreads.
This rewriting is really weird and mostly done so kthread can use init's filesystem state when they would like to. But this really should be discouraged. The rewriting should also stop completely. I worked a bit to get rid of it in a more fundamental way. Is it crazy? Yes. Is it likely broken? Yes. Does it at least boot? Yes.
Instead of sharing fs_struct between kernel threads and pid 1, pid 1 get's a completely separate fs_struct. All kthreads continue sharing init_fs as before and pid 1's fs_struct is isolated from kthread's filesystem state. IOW, userspace init cannot affect kthreads filesystem state anymore and kthreads cannot affect userspace's filesystem state anymore - without explicit opt-in.
All kthreads are anchored in a kernel internal mount of nullfs that cannot be mounted on and that cannot be used to follow other mounts. It's a completely private mount that insulates kthreads.
This series makes performing mountains of filesystem work such as path lookup and file opening and so on from kthreads hard - painfully so. I think this is a benefit because it takes the idea of just offloading _security sensitive_ operations in init's filesystem state and running random binaries or opening and creating files to kthreads difficult behind the shed... And imho it should.
The only remaining kernel tasks that actually share init's filesystem state are usermodhelpers - as they execute random binaries in the root filesystem. Another concept we should really show the back of the shed.
This gives a lot stronger guarantees than what we have now. This also makes path lookup from kthreads fail by default. IOW, it won't be possible anymore to just lookup random stuff in init's filesytem state without explicitly opting in to that.
The places that need to perform lookup in init's filesystem state may use scoped_with_init_fs() which will temporarily override the caller's fs_struct with init's fs_struct.
We now also warn and notice when pid 1 simply stops sharing filesystem state with us, i.e., abandons it's userspace_init_fs.
On older kernels if PID 1 unshared its filesystem state with us the kernel simply used the stale fs_struct state implicitly pinning anything that PID 1 had last used. Even if PID 1 might've moved on to some completely different fs_struct state and might've even unmounted the old root.
This has hilarious consequences: Think continuing to dump coredump state into an implicitly pinned directory somewhere. Calling random binaries in the old rootfs via usermodehelpers.
Be aggressive about this: We simply reject operating on stale fs_struct state by reverting userspace_init_fs to nullfs. Every kworker that does lookups after this point will fail. Every usermodehelper call will fail. This is a lot stronger but I wouldn't know what it means for pid 1 to simply stop sharing its fs state with the kernel. Clearly it wanted to separate so cut all ties.
I've went through the kernel and looked at hopefully everything that does path lookup from kthreads (workqueues, ...).
TL;DR:
==== PID 1 (systemd) ====
root@localhost:~# stat --file-system /proc/1/root
File: "/proc/1/root"
ID: e3cb00dd533cd3d7 Namelen: 255 Type: ext2/ext3root@localhost:~# cat /proc/1/mountinfo | wc -l 30
==== PID 2 (kthreadd) ====
root@localhost:~# stat --file-system /proc/2/root
File: "/proc/2/root"
ID: 200000000 Namelen: 255 Type: nullfsroot@localhost:~# cat /proc/2/mountinfo | wc -l 0
---
Changes in v4:
- scsi: target: only override current->fs in kthread context for the
ALUA metadata write. core_alua_write_tpg_metadata() is also reached
from the configfs alua_access_state and alua_tg_pt_offline store
handlers in process context, which must resolve against the caller's
root.
- devtmpfs: drop the kthread_mntns() helper and call ksys_unshare(UNSHARE_EMPTY_MNTNS) directly now that empty mount
namespaces have landed; the unshare path already points the kthread's
root and pwd at the new namespace.
- Reword the copy_fs() usermodehelper comment ("may copy" rather than
"may use").
- Rebase onto v7.1-rc1.
- Link to v3: https://patch.msgid.link/[email protected]
Changes in v3:
- Fix __override_init_fs() to save and return the original fs instead of
the override, so __revert_init_fs() actually restores the caller's fs.
- Replace smp_store_release() with WRITE_ONCE() in fs override/revert.
- Move userspace_init_fs wiring commit before conversion patches to fix bisectability for user-process-context callers.
- Switch all remote procfs accesses (mounts_open_common, get_task_root, proc_cwd_link, task_state umask, kcmp) to use task_struct::real_fs
instead of task_struct::fs.
- Move VFS_WARN_ON_ONCE in copy_fs() into else block so it doesn't fire
for UMH threads.
- Fix sleeping under task_lock: validate_fs_switch() now runs outside task_lock() with might_sleep() annotation.
- Add pnfs/blocklayout scoped_with_init_fs() conversion.
- Wrap security_initramfs_populated() inside scoped_with_init_fs() in
initramfs unpacking since IPE accesses current->fs->root.
- Fix stale comments: "two mounts" -> "three mounts", UMH comment, kthread_mntns() nullfs ambiguity.
- Fix commit message mismatches.
- Link to v2: https://patch.msgid.link/[email protected]
Changes in v2:
- Remove LOOKUP_IN_INIT in favor of scoped_with_init_fs().
- Link to v1: https://patch.msgid.link/[email protected]
---
Christian Brauner (25):
fs: add switch_fs_struct()
fs: notice when init abandons fs sharing
fs: add scoped_with_init_fs()
fs: add real_fs to track task's actual fs_struct
fs: make userspace_init_fs a dynamically-initialized pointer
rnbd: use scoped_with_init_fs() for block device open
crypto: ccp: use scoped_with_init_fs() for SEV file access
scsi: target: use scoped_with_init_fs() for ALUA metadata
scsi: target: use scoped_with_init_fs() for APTPL metadata
btrfs: use scoped_with_init_fs() for update_dev_time()
coredump: use scoped_with_init_fs() for coredump path resolution
fs: use scoped_with_init_fs() for kernel_read_file_from_path_initns()
ksmbd: use scoped_with_init_fs() for share path resolution
ksmbd: use scoped_with_init_fs() for filesystem info path lookup
ksmbd: use scoped_with_init_fs() for VFS path operations pnfs/blocklayout: use scoped_with_init_fs() for SCSI device lookup
initramfs: use scoped_with_init_fs() for rootfs unpacking
af_unix: use scoped_with_init_fs() for coredump socket lookup
fs: stop sharing fs_struct between init_task and pid 1
fs: add umh argument to struct kernel_clone_args
devtmpfs: create private mount namespace
nullfs: make nullfs multi-instance
fs: start all kthreads in nullfs
fs: stop rewriting kthread fs structs
fs: stop rewriting paths for PF_EXITING | PF_DUMPCORE
drivers/base/devtmpfs.c | 2 +- drivers/block/rnbd/rnbd-srv.c | 4 +- drivers/crypto/ccp/sev-dev.c | 12 ++--- drivers/target/target_core_alua.c | 11 +++- drivers/target/target_core_pr.c | 4 +- fs/btrfs/volumes.c | 11 +++- fs/coredump.c | 11 ++-- fs/fs_struct.c | 103 ++++++++++++++++++++++++++++++++++++-- fs/kernel_read_file.c | 9 +--- fs/namespace.c | 16 +++--- fs/nfs/blocklayout/dev.c | 15 ++++-- fs/nullfs.c | 12 ++--- fs/proc/array.c | 4 +- fs/proc/base.c | 8 +-- fs/proc_namespace.c | 4 +- fs/smb/server/mgmt/share_config.c | 4 +- fs/smb/server/smb2pdu.c | 4 +- fs/smb/server/vfs.c | 14 ++++-- include/linux/fs_struct.h | 34 +++++++++++++ include/linux/init_task.h | 1 + include/linux/sched.h | 1 + include/linux/sched/task.h | 1 + init/init_task.c | 1 + init/initramfs.c | 14 ++++-- init/main.c | 10 +++- kernel/fork.c | 53 ++++++++++++-------- kernel/kcmp.c | 2 +- kernel/umh.c | 6 +-- net/unix/af_unix.c | 17 +++---- 29 files changed, 282 insertions(+), 106 deletions(-)
---
base-commit: 254f49634ee16a731174d2ae34bc50bd5f45e731
change-id: 20260303-work-kthread-nullfs-875a837f4198
Christian Brauner
maintainerRFC PATCH v4 1/25 fs: add switch_fs_struct()
Don't open-code the guts of replacing current's fs struct.
--- fs/fs_struct.c | 18 ++++++++++++++++++ include/linux/fs_struct.h | 2 ++ kernel/fork.c | 22 ++++++---------------- 3 files changed, 26 insertions(+), 16 deletions(-)
fs/fs_struct.c +18 -0
@@ -147,6 +147,24 @@ int unshare_fs_struct(void) }EXPORT_SYMBOL_GPL (unshare_fs_struct); +struct fs_struct *switch_fs_struct (struct fs_struct *new_fs) +{ +struct fs_struct *fs; + + scoped_guard(task_lock, current) { + fs = current->fs; +read_seqlock_excl (&fs->seq); + current->fs = new_fs; +if (--fs->users) + new_fs =NULL ; +else + new_fs = fs; +read_sequnlock_excl (&fs->seq); + } + +return new_fs; +} +/* to be mentioned only in INIT_TASK */ struct fs_struct init_fs = { .users =1 ,
include/linux/fs_struct.h +2 -0
@@ -40,6 +40,8 @@ static inline void get_fs_pwd(struct fs_struct *fs, struct path *pwd)read_sequnlock_excl (&fs->seq); } +struct fs_struct *switch_fs_struct (struct fs_struct *new_fs); +extern bool current_chrooted (void );static inline int current_umask (void )
kernel/fork.c +6 -16
@@ -3192,7 +3192,7 @@ static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp*/ int ksys_unshare (unsigned long unshare_flags) { -struct fs_struct *fs, *new_fs =NULL ; +struct fs_struct *new_fs =NULL ;struct files_struct *new_fd =NULL ;struct cred *new_cred =NULL ;struct nsproxy *new_nsproxy =NULL ;
@@ -3270,23 +3270,13 @@ int ksys_unshare(unsigned long unshare_flags) new_nsproxy =NULL ; } -task_lock (current); +if (new_fs) + new_fs =switch_fs_struct (new_fs); -if (new_fs) { - fs = current->fs; -read_seqlock_excl (&fs->seq); - current->fs = new_fs; -if (--fs->users) - new_fs =NULL ; -else - new_fs = fs; -read_sequnlock_excl (&fs->seq); - } - -if (new_fd) +if (new_fd) { +guard (task_lock)(current);swap (current->files, new_fd); - -task_unlock (current); + }if (new_cred) {/* Install the new user namespace */
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 2/25 fs: notice when init abandons fs sharing
In reply to Christian BraunerPID 1 may choose to stop sharing fs_struct state with us. Either via unshare(CLONE_FS) or unshare(CLONE_NEWNS). Of course, PID 1 could have chosen to create arbitrary process trees that all share fs_struct state via CLONE_FS. This is a strong statement: We only care about PID 1 aka the thread-group leader so subthread's fs_struct state doesn't matter.
PID 1 unsharing fs_struct state is a bug. PID 1 relies on various kthreads to be able to perform work based on its fs_struct state. Breaking that contract sucks for both sides. So just don't bother with extra work for this. No sane init system should ever do this.
--- fs/fs_struct.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
fs/fs_struct.c +25 -0
@@ -147,6 +147,30 @@ int unshare_fs_struct(void) }EXPORT_SYMBOL_GPL (unshare_fs_struct); +/* +* PID 1 may choose to stop sharing fs_struct state with us. +* Either via unshare(CLONE_FS) or unshare(CLONE_NEWNS). Of +* course, PID 1 could have chosen to create arbitrary process +* trees that all share fs_struct state via CLONE_FS. This is a +* strong statement: We only care about PID 1 aka the thread-group +* leader so subthread's fs_struct state doesn't matter. +* +* PID 1 unsharing fs_struct state is a bug. PID 1 relies on +* various kthreads to be able to perform work based on its +* fs_struct state. Breaking that contract sucks for both sides. +* So just don't bother with extra work for this. No sane init +* system should ever do this. +*/ +static inline void validate_fs_switch (struct fs_struct *old_fs) +{ +if (likely (current->pid !=1 )) +return ; +/* @old_fs may be dangling but for comparison it's fine */ +if (old_fs != &init_fs) +return ; +pr_warn ("VFS: Pid 1 stopped sharing filesystem state\n" ); +} +struct fs_struct *switch_fs_struct (struct fs_struct *new_fs) {struct fs_struct *fs;
@@ -162,6 +186,7 @@ struct fs_struct *switch_fs_struct(struct fs_struct *new_fs)read_sequnlock_excl (&fs->seq); } +validate_fs_switch (fs);return new_fs; }
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 3/25 fs: add scoped_with_init_fs()
In reply to Christian BraunerSimilar to scoped_with_kernel_creds() allow a temporary override of current->fs to serve the few places where lookup is performed from kthread context or needs init's filesytem state.
--- include/linux/fs_struct.h | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+)
include/linux/fs_struct.h +31 -0
@@ -6,6 +6,7 @@#include <linux/path.h> #include <linux/spinlock.h> #include <linux/seqlock.h> +#include <linux/vfsdebug.h> struct fs_struct {int users;
@@ -49,4 +50,34 @@ static inline int current_umask(void) return current->fs->umask; } +/* +* Temporarily use userspace_init_fs for path resolution in kthreads. +* Callers should use scoped_with_init_fs() which automatically +* restores the original fs_struct at scope exit. +*/ +static inline struct fs_struct *__override_init_fs (void ) +{ +struct fs_struct *fs; + + fs = current->fs; +WRITE_ONCE (current->fs, fs); +return fs; +} + +static inline void __revert_init_fs (struct fs_struct *revert_fs) +{ +VFS_WARN_ON_ONCE (current->fs != revert_fs); +WRITE_ONCE (current->fs, revert_fs); +} + +DEFINE_CLASS (__override_init_fs, + struct fs_struct *, +__revert_init_fs (_T), + __override_init_fs(), void) + +#define scoped_with_init_fs () \ + scoped_class(__override_init_fs, __UNIQUE_ID(label)) + +void __init init_userspace_fs (void ); +#endif /* _LINUX_FS_STRUCT_H */
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 4/25 fs: add real_fs to track task's actual fs_struct
In reply to Christian BraunerAdd a real_fs field to task_struct that always mirrors the fs field. This lays the groundwork for distinguishing between a task's permanent fs_struct and one that is temporarily overridden via scoped_with_init_fs().
When a kthread temporarily overrides current->fs for path lookup, we need to know the original fs_struct for operations like exit_fs() and unshare_fs_struct() that must operate on the real, permanent fs.
For now real_fs is always equal to fs. It is maintained alongside fs in all the relevant paths: exit_fs(), unshare_fs_struct(), switch_fs_struct(), and copy_fs().
--- fs/fs_struct.c | 11 ++++++++--- fs/proc/array.c | 4 ++-- fs/proc/base.c | 8 ++++---- fs/proc_namespace.c | 4 ++-- include/linux/sched.h | 1 + init/init_task.c | 1 + kernel/fork.c | 8 +++++++- kernel/kcmp.c | 2 +- 8 files changed, 26 insertions(+), 13 deletions(-)
fs/fs_struct.c +8 -3
@@ -61,7 +61,7 @@ void chroot_fs_refs(const struct path *old_root, const struct path *new_root)read_lock (&tasklist_lock);for_each_process_thread (g, p) {task_lock (p); - fs = p->fs; + fs = p->real_fs;if (fs) {int hits =0 ;write_seqlock (&fs->seq);
@@ -89,12 +89,13 @@ void free_fs_struct(struct fs_struct *fs)void exit_fs (struct task_struct *tsk) { -struct fs_struct *fs = tsk->fs; +struct fs_struct *fs = tsk->real_fs;if (fs) {int kill;task_lock (tsk);read_seqlock_excl (&fs->seq); + tsk->real_fs =NULL ; tsk->fs =NULL ; kill = !--fs->users;read_sequnlock_excl (&fs->seq);
@@ -126,7 +127,7 @@ struct fs_struct *copy_fs_struct(struct fs_struct *old)int unshare_fs_struct (void ) { -struct fs_struct *fs = current->fs; +struct fs_struct *fs = current->real_fs;struct fs_struct *new_fs =copy_fs_struct (fs);int kill;
@@ -135,8 +136,10 @@ int unshare_fs_struct(void)task_lock (current);read_seqlock_excl (&fs->seq); +VFS_WARN_ON_ONCE (fs != current->fs); kill = !--fs->users; current->fs = new_fs; + current->real_fs = new_fs;read_sequnlock_excl (&fs->seq);task_unlock (current);
@@ -177,8 +180,10 @@ struct fs_struct *switch_fs_struct(struct fs_struct *new_fs) scoped_guard(task_lock, current) { fs = current->fs; +VFS_WARN_ON_ONCE (fs != current->real_fs);read_seqlock_excl (&fs->seq); current->fs = new_fs; + current->real_fs = new_fs;if (--fs->users) new_fs =NULL ;else
fs/proc/array.c +2 -2
@@ -168,8 +168,8 @@ static inline void task_state(struct seq_file *m, struct pid_namespace *ns, cred =get_task_cred (p);task_lock (p); -if (p->fs) - umask = p->fs->umask; +if (p->real_fs) + umask = p->real_fs->umask;if (p->files) max_fds =files_fdtable (p->files)->max_fds;task_unlock (p);
fs/proc/base.c +4 -4
@@ -210,8 +210,8 @@ static int get_task_root(struct task_struct *task, struct path *root)int result = -ENOENT ;task_lock (task); -if (task->fs) { -get_fs_root (task->fs, root); +if (task->real_fs) { +get_fs_root (task->real_fs, root); result =0 ; }task_unlock (task);
@@ -225,8 +225,8 @@ static int proc_cwd_link(struct dentry *dentry, struct path *path)if (task) {task_lock (task); -if (task->fs) { -get_fs_pwd (task->fs, path); +if (task->real_fs) { +get_fs_pwd (task->real_fs, path); result =0 ; }task_unlock (task);
fs/proc_namespace.c +2 -2
@@ -254,13 +254,13 @@ static int mounts_open_common(struct inode *inode, struct file *file, } ns = nsp->mnt_ns;get_mnt_ns (ns); -if (!task->fs) { +if (!task->real_fs) {task_unlock (task);put_task_struct (task); ret = -ENOENT ; goto err_put_ns; } -get_fs_root (task->fs, &root); +get_fs_root (task->real_fs, &root);task_unlock (task);put_task_struct (task);
include/linux/sched.h +1 -0
@@ -1180,6 +1180,7 @@ struct task_struct {unsigned long last_switch_time;#endif /* Filesystem information: */ +struct fs_struct *real_fs;struct fs_struct *fs;/* Open file information: */
init/init_task.c +1 -0
@@ -152,6 +152,7 @@ struct task_struct init_task __aligned(L1_CACHE_BYTES) = { RCU_POINTER_INITIALIZER(cred, &init_cred), .comm = INIT_TASK_COMM, .thread = INIT_THREAD, + .real_fs = &init_fs, .fs = &init_fs, .files = &init_files, #ifdef CONFIG_IO_URING
kernel/fork.c +7 -1
@@ -1596,6 +1596,8 @@ static int copy_mm(u64 clone_flags, struct task_struct *tsk)static int copy_fs (u64 clone_flags,struct task_struct *tsk) {struct fs_struct *fs = current->fs; + +VFS_WARN_ON_ONCE (current->fs != current->real_fs);if (clone_flags &CLONE_FS ) {/* tsk->fs is already what we want */ read_seqlock_excl (&fs->seq);
@@ -1608,7 +1610,7 @@ static int copy_fs(u64 clone_flags, struct task_struct *tsk)read_sequnlock_excl (&fs->seq);return 0 ; } - tsk->fs =copy_fs_struct (fs); + tsk->real_fs = tsk->fs =copy_fs_struct (fs);if (!tsk->fs)return -ENOMEM ;return 0 ;
@@ -3223,6 +3225,10 @@ int ksys_unshare(unsigned long unshare_flags)if (unshare_flags &CLONE_NEWNS ) unshare_flags |=CLONE_FS ; +/* No unsharing with overriden fs state */ +VFS_WARN_ON_ONCE (unshare_flags & (CLONE_NEWNS |CLONE_FS ) && + current->fs != current->real_fs); + err =check_unshare_flags (unshare_flags);if (err) goto bad_unshare_out;
kernel/kcmp.c +1 -1
@@ -186,7 +186,7 @@ SYSCALL_DEFINE5(kcmp, pid_t, pid1, pid_t, pid2, int, type, ret =kcmp_ptr (task1->files, task2->files,KCMP_FILES );break ;case KCMP_FS : - ret =kcmp_ptr (task1->fs, task2->fs,KCMP_FS ); + ret =kcmp_ptr (task1->real_fs, task2->real_fs,KCMP_FS );break ;case KCMP_SIGHAND : ret =kcmp_ptr (task1->sighand, task2->sighand,KCMP_SIGHAND );
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 5/25 fs: make userspace_init_fs a dynamically-initialized pointer
In reply to Christian BraunerChange userspace_init_fs from a declared-but-unused extern struct to a dynamically initialized pointer. Add init_userspace_fs() which is called early in kernel_init() (PID 1) to record PID 1's fs_struct as the canonical userspace filesystem state.
Wire up __override_init_fs() and __revert_init_fs() to actually swap current->fs to/from userspace_init_fs. Previously these were no-ops that stored current->fs back to itself.
Fix nullfs_userspace_init() to compare against userspace_init_fs instead of &init_fs. When PID 1 unshares its filesystem state, revert userspace_init_fs to init_fs's root (nullfs) so that stale filesystem state is not silently inherited by kworkers and usermodehelpers.
At this stage PID 1's fs still points to rootfs (set by init_mount_tree), so userspace_init_fs points to rootfs and scoped_with_init_fs() is functionally equivalent to its previous no-op behavior.
--- fs/fs_struct.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++- include/linux/fs_struct.h | 15 ++++++++------- include/linux/init_task.h | 1 + init/main.c | 3 +++ 4 files changed, 59 insertions(+), 8 deletions(-)
fs/fs_struct.c +47 -1
@@ -8,6 +8,7 @@#include <linux/fs_struct.h> #include <linux/init_task.h> #include "internal.h" +#include "mount.h" /* * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values.
@@ -163,15 +164,34 @@ EXPORT_SYMBOL_GPL(unshare_fs_struct);* fs_struct state. Breaking that contract sucks for both sides. * So just don't bother with extra work for this. No sane init * system should ever do this. +* +* On older kernels if PID 1 unshared its filesystem state with us the +* kernel simply used the stale fs_struct state implicitly pinning +* anything that PID 1 had last used. Even if PID 1 might've moved on to +* some completely different fs_struct state and might've even unmounted +* the old root. +* +* This has hilarious consequences: Think continuing to dump coredump +* state into an implicitly pinned directory somewhere. Calling random +* binaries in the old rootfs via usermodehelpers. +* +* Be aggressive about this: We simply reject operating on stale +* fs_struct state by reverting to nullfs. Every kworker that does +* lookups after this point will fail. Every usermodehelper call will +* fail. Tough luck but let's be kind and emit a warning to userspace. */ static inline void validate_fs_switch (struct fs_struct *old_fs) { +might_sleep (); +if (likely (current->pid !=1 ))return ;/* @old_fs may be dangling but for comparison it's fine */ -if (old_fs != &init_fs) +if (old_fs != userspace_init_fs)return ;pr_warn ("VFS: Pid 1 stopped sharing filesystem state\n" ); +set_fs_root (userspace_init_fs, &init_fs.root); +set_fs_pwd (userspace_init_fs, &init_fs.root); }struct fs_struct *switch_fs_struct (struct fs_struct *new_fs)
@@ -201,3 +221,29 @@ struct fs_struct init_fs = { .seq = __SEQLOCK_UNLOCKED(init_fs.seq), .umask = 0022, }; + +struct fs_struct *userspace_init_fs__ro_after_init ; +EXPORT_SYMBOL_GPL (userspace_init_fs); + +void __init init_userspace_fs (void ) +{ +struct mount *m; +struct path root; + +/* Move PID 1 from nullfs into the initramfs. */ + m =topmost_overmount (current->nsproxy->mnt_ns->root); + root.mnt = &m->mnt; + root.dentry = root.mnt->mnt_root; + +VFS_WARN_ON_ONCE (current->pid !=1 ); + +set_fs_root (current->fs, &root); +set_fs_pwd (current->fs, &root); + +/* Hold a reference for the global pointer. */ +read_seqlock_excl (¤t->fs->seq); + current->fs->users++; +read_sequnlock_excl (¤t->fs->seq); + + userspace_init_fs = current->fs; +}
include/linux/fs_struct.h +8 -7
@@ -17,6 +17,7 @@ struct fs_struct { } __randomize_layout;extern struct kmem_cache *fs_cachep; +extern struct fs_struct *userspace_init_fs;extern void exit_fs (struct task_struct *);extern void set_fs_root (struct fs_struct *,const struct path *);
@@ -57,17 +58,17 @@ static inline int current_umask(void)*/ static inline struct fs_struct *__override_init_fs (void ) { -struct fs_struct *fs; +struct fs_struct *old_fs; - fs = current->fs; -WRITE_ONCE (current->fs, fs); -return fs; + old_fs = current->fs; +WRITE_ONCE (current->fs, userspace_init_fs); +return old_fs; } -static inline void __revert_init_fs (struct fs_struct *revert_fs) +static inline void __revert_init_fs (struct fs_struct *old_fs) { -VFS_WARN_ON_ONCE (current->fs != revert_fs); -WRITE_ONCE (current->fs, revert_fs); +VFS_WARN_ON_ONCE (current->fs != userspace_init_fs); +WRITE_ONCE (current->fs, old_fs); } DEFINE_CLASS(__override_init_fs,
include/linux/init_task.h +1 -0
@@ -24,6 +24,7 @@extern struct files_struct init_files;extern struct fs_struct init_fs; +extern struct fs_struct *userspace_init_fs;extern struct nsproxy init_nsproxy;#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
init/main.c +3 -0
@@ -103,6 +103,7 @@#include <linux/stackdepot.h> #include <linux/randomize_kstack.h> #include <linux/pidfs.h> +#include <linux/fs_struct.h> #include <linux/ptdump.h> #include <linux/time_namespace.h> #include <linux/unaligned.h>
@@ -1585,6 +1586,8 @@ static int __ref kernel_init(void *unused) {int ret; +init_userspace_fs (); +/* * Wait until kthreadd is all set-up. */
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 6/25 rnbd: use scoped_with_init_fs() for block device open
In reply to Christian BraunerUse scoped_with_init_fs() to temporarily override current->fs for the bdev_file_open_by_path() call so the path lookup happens in init's filesystem context.
process_msg_open() ← rnbd_srv_rdma_ev() ← RDMA completion callback ← ib_cq_poll_work() ← kworker (InfiniBand completion workqueue)
--- drivers/block/rnbd/rnbd-srv.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/block/rnbd/rnbd-srv.c +3 -1
@@ -11,6 +11,7 @@#include <linux/module.h> #include <linux/blkdev.h> +#include <linux/fs_struct.h> #include "rnbd-srv.h" #include "rnbd-srv-trace.h"
@@ -734,7 +735,8 @@ static int process_msg_open(struct rnbd_srv_session *srv_sess, goto reject; } - bdev_file =bdev_file_open_by_path (full_path, open_flags,NULL ,NULL ); +scoped_with_init_fs () + bdev_file = bdev_file_open_by_path(full_path, open_flags, NULL, NULL);if (IS_ERR (bdev_file)) { ret =PTR_ERR (bdev_file); pr_err("Opening device '%s' on session %s failed, failed to open the block device, err: %pe\n",
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 7/25 crypto: ccp: use scoped_with_init_fs() for SEV file access
In reply to Christian BraunerReplace the manual init_task root retrieval with scoped_with_init_fs() to temporarily override current->fs. This allows using the simpler filp_open() instead of the init_root() + file_open_root() pattern.
open_file_as_root() ← sev_read_init_ex_file() / sev_write_init_ex_file() ← sev_platform_init() ← __sev_guest_init() ← KVM ioctl — user process context
Needs init's root because the SEV init_ex file path should resolve against the real root, not a KVM user's chroot.
--- drivers/crypto/ccp/sev-dev.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
drivers/crypto/ccp/sev-dev.c +4 -8
@@ -260,20 +260,16 @@ static int sev_cmd_buffer_len(int cmd)static struct file *open_file_as_root (const char *filename,int flags,umode_t mode) { - struct path root __free(path_put) = {}; - -task_lock (&init_task); -get_fs_root (init_task.fs, &root); -task_unlock (&init_task); -CLASS (prepare_creds, cred)();if (!cred)return ERR_PTR (-ENOMEM ); cred->fsuid =GLOBAL_ROOT_UID ; -scoped_with_creds (cred) - return file_open_root(&root, filename, flags, mode); + scoped_with_init_fs() { +scoped_with_creds (cred) + return filp_open(filename, flags, mode); + } }static int sev_read_init_ex_file (void )
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 8/25 scsi: target: use scoped_with_init_fs() for ALUA metadata
In reply to Christian Braunercore_alua_write_tpg_metadata() can be called from both kthread and user process context. Use scoped_with_init_fs() to temporarily override current->fs for the filp_open() call when running in kthread context so the path lookup happens in init's filesystem context.
core_alua_write_tpg_metadata() ← core_alua_update_tpg_primary_metadata() ← core_alua_do_transition_tg_pt() ← target_queued_submit_work() ← kworker (target submission workqueue)
Also reached synchronously from configfs (user process) via the alua_access_state and alua_tg_pt_offline attributes:
core_alua_write_tpg_metadata() ← core_alua_update_tpg_primary_metadata() ← core_alua_do_transition_tg_pt() ← core_alua_do_port_transition() ← target_tg_pt_gp_alua_access_state_store()
In that case current->fs must not be overridden as the path should resolve against the calling process's filesystem root.
--- drivers/target/target_core_alua.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
drivers/target/target_core_alua.c +10 -1
@@ -18,6 +18,8 @@#include <linux/fcntl.h> #include <linux/file.h> #include <linux/fs.h> +#include <linux/fs_struct.h> +#include <linux/kthread.h> #include <scsi/scsi_proto.h> #include <linux/unaligned.h>
@@ -856,10 +858,17 @@ static int core_alua_write_tpg_metadata( unsigned char *md_buf, u32 md_buf_len) { -struct file *file =filp_open (path,O_RDWR |O_CREAT |O_TRUNC ,0600 ); +struct file *file;loff_t pos =0 ;int ret; +if (tsk_is_kthread (current)) { +scoped_with_init_fs () + file = filp_open(path, O_RDWR | O_CREAT | O_TRUNC, 0600); + }else { + file =filp_open (path,O_RDWR |O_CREAT |O_TRUNC ,0600 ); + } +if (IS_ERR (file)) {pr_err ("filp_open(%s) for ALUA metadata failed\n" , path);return -ENODEV ;
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 9/25 scsi: target: use scoped_with_init_fs() for APTPL metadata
In reply to Christian BraunerUse scoped_with_init_fs() to temporarily override current->fs for the filp_open() call in __core_scsi3_write_aptpl_to_file() so the path lookup happens in init's filesystem context.
__core_scsi3_write_aptpl_to_file() ← core_scsi3_update_and_write_aptpl() ← PR command handlers ← target_queued_submit_work() ← kworker
--- drivers/target/target_core_pr.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/target/target_core_pr.c +3 -1
@@ -18,6 +18,7 @@#include <linux/file.h> #include <linux/fcntl.h> #include <linux/fs.h> +#include <linux/fs_struct.h> #include <scsi/scsi_proto.h> #include <linux/unaligned.h>
@@ -1969,7 +1970,8 @@ static int __core_scsi3_write_aptpl_to_file(if (!path)return -ENOMEM ; - file =filp_open (path, flags,0600 ); +scoped_with_init_fs () + file = filp_open(path, flags, 0600);if (IS_ERR (file)) {pr_err ("filp_open(%s) for APTPL metadata" " failed\n" , path);
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 10/25 btrfs: use scoped_with_init_fs() for update_dev_time()
In reply to Christian Braunerupdate_dev_time() can be called from both kthread and process context. Use scoped_with_init_fs() to temporarily override current->fs for the kern_path() call when running in kthread context so the path lookup happens in init's filesystem context.
update_dev_time() ← btrfs_scratch_superblocks() ← btrfs_dev_replace_finishing() ← btrfs_dev_replace_kthread() ← kthread (kthread_run)
Also called from ioctl (user process).
--- fs/btrfs/volumes.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
fs/btrfs/volumes.c +10 -1
@@ -12,6 +12,7 @@#include <linux/uuid.h> #include <linux/list_sort.h> #include <linux/namei.h> +#include <linux/fs_struct.h> #include "misc.h" #include "disk-io.h" #include "extent-tree.h"
@@ -2120,8 +2121,16 @@ static int btrfs_add_dev_item(struct btrfs_trans_handle *trans,static void update_dev_time (const char *device_path) {struct path path; +int err; -if (!kern_path (device_path,LOOKUP_FOLLOW , &path)) { +if (tsk_is_kthread (current)) { +scoped_with_init_fs () + err = kern_path(device_path, LOOKUP_FOLLOW, &path); + }else { + err =kern_path (device_path,LOOKUP_FOLLOW , &path); + } + +if (!err) {vfs_utimes (&path,NULL );path_put (&path); }
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 11/25 coredump: use scoped_with_init_fs() for coredump path resolution
In reply to Christian BraunerUse scoped_with_init_fs() to temporarily override current->fs for the filp_open() call so the coredump path lookup happens in init's filesystem context. This replaces the init_root() + file_open_root() pattern with the simpler scoped override.
coredump_file() ← do_coredump() ← vfs_coredump() ← get_signal() — runs as the crashing userspace process
Uses init's root to prevent a chrooted/user-namespaced process from controlling where suid coredumps land. Not a kthread, but intentionally needs init's fs for security.
--- fs/coredump.c | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-)
fs/coredump.c +3 -8
@@ -922,15 +922,10 @@ static bool coredump_file(struct core_name *cn, struct coredump_params *cprm,* with a fully qualified path" rule is to control where * coredumps may be placed using root privileges, * current->fs->root must not be used. Instead, use the -* root directory of init_task. +* root directory of PID 1. */ -struct path root; - -task_lock (&init_task); -get_fs_root (init_task.fs, &root); -task_unlock (&init_task); - file =file_open_root (&root, cn->corename, open_flags,0600 ); -path_put (&root); +scoped_with_init_fs () + file = filp_open(cn->corename, open_flags, 0600); }else { file =filp_open (cn->corename, open_flags,0600 ); }
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 12/25 fs: use scoped_with_init_fs() for kernel_read_file_from_path_initns()
In reply to Christian BraunerReplace the manual init_task root retrieval with scoped_with_init_fs() to temporarily override current->fs. This allows using the simpler filp_open() instead of the init_root() + file_open_root() pattern.
kernel_read_file_from_path_initns() ← fw_get_filesystem_firmware() ← _request_firmware() ← request_firmware_work_func() ← kworker (async firmware loading)
Also called synchronously from request_firmware() which can be user or kthread context.
--- fs/kernel_read_file.c | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-)
fs/kernel_read_file.c +2 -7
@@ -150,18 +150,13 @@ ssize_t kernel_read_file_from_path_initns(const char *path, loff_t offset, enum kernel_read_file_id id) {struct file *file; -struct path root;ssize_t ret;if (!path || !*path)return -EINVAL ; -task_lock (&init_task); -get_fs_root (init_task.fs, &root); -task_unlock (&init_task); - - file =file_open_root (&root, path,O_RDONLY ,0 ); -path_put (&root); +scoped_with_init_fs () + file = filp_open(path, O_RDONLY, 0);if (IS_ERR (file))return PTR_ERR (file);
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 13/25 ksmbd: use scoped_with_init_fs() for share path resolution
In reply to Christian BraunerUse scoped_with_init_fs() to temporarily override current->fs for the kern_path() call in share_config_request() so the share path lookup happens in init's filesystem context.
All ksmbd paths ← SMB command handlers ← handle_ksmbd_work() ← workqueue ← ksmbd_conn_handler_loop() ← kthread
--- fs/smb/server/mgmt/share_config.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
fs/smb/server/mgmt/share_config.c +3 -1
@@ -9,6 +9,7 @@#include <linux/rwsem.h> #include <linux/parser.h> #include <linux/namei.h> +#include <linux/fs_struct.h> #include <linux/sched.h> #include <linux/mm.h>
@@ -189,7 +190,8 @@ static struct ksmbd_share_config *share_config_request(struct ksmbd_work *work, goto out; } - ret =kern_path (share->path,0 , &share->vfs_path); +scoped_with_init_fs () + ret = kern_path(share->path, 0, &share->vfs_path);ksmbd_revert_fsids (work);if (ret) { ksmbd_debug(SMB, "failed to access '%s'\n",
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 14/25 ksmbd: use scoped_with_init_fs() for filesystem info path lookup
In reply to Christian BraunerUse scoped_with_init_fs() to temporarily override current->fs for the kern_path() call in smb2_get_info_filesystem() so the share path lookup happens in init's filesystem context.
All ksmbd paths ← SMB command handlers ← handle_ksmbd_work() ← workqueue ← ksmbd_conn_handler_loop() ← kthread
--- fs/smb/server/smb2pdu.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
fs/smb/server/smb2pdu.c +3 -1
@@ -9,6 +9,7 @@#include <net/addrconf.h> #include <linux/syscalls.h> #include <linux/namei.h> +#include <linux/fs_struct.h> #include <linux/statfs.h> #include <linux/ethtool.h> #include <linux/falloc.h>
@@ -5507,7 +5508,8 @@ static int smb2_get_info_filesystem(struct ksmbd_work *work,if (!share->path)return -EIO ; - rc =kern_path (share->path,LOOKUP_NO_SYMLINKS , &path); +scoped_with_init_fs () + rc = kern_path(share->path, LOOKUP_NO_SYMLINKS, &path);if (rc) {pr_err ("cannot create vfs path\n" );return -EIO ;
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 15/25 ksmbd: use scoped_with_init_fs() for VFS path operations
In reply to Christian BraunerUse scoped_with_init_fs() to temporarily override current->fs for path lookups in ksmbd VFS helpers:
- ksmbd_vfs_path_lookup(): wrap vfs_path_parent_lookup()
- ksmbd_vfs_link(): wrap kern_path() for old path resolution
- ksmbd_vfs_kern_path_create(): wrap start_creating_path()
This ensures path lookups happen in init's filesystem context.
All ksmbd paths ← SMB command handlers ← handle_ksmbd_work() ← workqueue ← ksmbd_conn_handler_loop() ← kthread
--- fs/smb/server/vfs.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-)
fs/smb/server/vfs.c +9 -5
@@ -7,6 +7,7 @@#include <crypto/sha2.h> #include <linux/kernel.h> #include <linux/fs.h> +#include <linux/fs_struct.h> #include <linux/filelock.h> #include <linux/uaccess.h> #include <linux/backing-dev.h>
@@ -67,9 +68,10 @@ static int ksmbd_vfs_path_lookup(struct ksmbd_share_config *share_conf, }CLASS (filename_kernel, filename)(pathname); - err =vfs_path_parent_lookup (filename, flags, - path, &last, &type, - root_share_path); +scoped_with_init_fs () + err = vfs_path_parent_lookup(filename, flags, + path, &last, &type, + root_share_path);if (err)return err;
@@ -622,7 +624,8 @@ int ksmbd_vfs_link(struct ksmbd_work *work, const char *oldname,if (ksmbd_override_fsids (work))return -ENOMEM ; - err =kern_path (oldname,LOOKUP_NO_SYMLINKS , &oldpath); +scoped_with_init_fs () + err = kern_path(oldname, LOOKUP_NO_SYMLINKS, &oldpath);if (err) {pr_err ("cannot get linux path for %s, err = %d\n" , oldname, err);
@@ -1258,7 +1261,8 @@ struct dentry *ksmbd_vfs_kern_path_create(struct ksmbd_work *work,if (!abs_name)return ERR_PTR (-ENOMEM ); - dent =start_creating_path (AT_FDCWD , abs_name, path, flags); +scoped_with_init_fs () + dent = start_creating_path(AT_FDCWD, abs_name, path, flags);kfree (abs_name);return dent; }
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 16/25 pnfs/blocklayout: use scoped_with_init_fs() for SCSI device lookup
In reply to Christian Braunerbl_open_path() resolves pNFS block device paths under /dev/disk/by-id/ via bdev_file_open_by_path() -> lookup_bdev() -> kern_path(). This path resolution uses current->fs->root.
With kthreads now starting in nullfs, this fails when the call originates from writeback kworker context because current->fs->root points at the empty nullfs. The full callchain from kworker is:
wb_workfn [kworker writeback callback]
...
nfs_writepages [address_space_operations.writepages]
nfs_do_writepage
nfs_pageio_add_request
...
bl_pg_init_write [nfs_pageio_ops.pg_init]
pnfs_generic_pg_init_write
pnfs_update_layout
nfs4_proc_layoutget [synchronous RPC]
pnfs_layout_process
bl_alloc_lseg
bl_alloc_extent
bl_find_get_deviceid
bl_alloc_deviceid_node
bl_parse_deviceid
bl_parse_scsi
bl_open_path
bdev_file_open_by_path
lookup_bdev
kern_path <- current->fs->rootbl_open_path() can also be reached from userspace process context (e.g. open, read, write syscalls via pnfs_update_layout). In that case current->fs must not be overridden as the path should resolve against the calling process's filesystem root.
Add a tsk_is_kthread() conditional in bl_open_path() to only apply scoped_with_init_fs() in kthread context.
--- fs/nfs/blocklayout/dev.c | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-)
fs/nfs/blocklayout/dev.c +11 -4
@@ -4,6 +4,7 @@*/ #include <linux/sunrpc/svc.h> #include <linux/blkdev.h> +#include <linux/fs_struct.h> #include <linux/nfs4.h> #include <linux/nfs_fs.h> #include <linux/nfs_xdr.h>
@@ -363,15 +364,22 @@ static struct file * bl_open_path(struct pnfs_block_volume *v, const char *prefix) { struct file *bdev_file; -const char *devname; + const char *devname __free(kfree) = NULL; devname =kasprintf (GFP_KERNEL ,"/dev/disk/by-id/%s%*phN" , prefix, v->scsi.designator_len, v->scsi.designator);if (!devname)return ERR_PTR (-ENOMEM ); - bdev_file =bdev_file_open_by_path (devname, -BLK_OPEN_READ |BLK_OPEN_WRITE ,NULL ,NULL ); +if (tsk_is_kthread (current)) { +scoped_with_init_fs () + bdev_file = bdev_file_open_by_path(devname, +BLK_OPEN_READ |BLK_OPEN_WRITE , +NULL ,NULL ); + }else { + bdev_file =bdev_file_open_by_path (devname, +BLK_OPEN_READ |BLK_OPEN_WRITE ,NULL ,NULL ); + }if (IS_ERR (bdev_file)) {dprintk ("failed to open device %s (%ld)\n" , devname,PTR_ERR (bdev_file));
@@ -380,7 +388,6 @@ bl_open_path(struct pnfs_block_volume *v, const char *prefix) file_bdev(bdev_file)->bd_disk->disk_name); } -kfree (devname);return bdev_file; }
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 17/25 initramfs: use scoped_with_init_fs() for rootfs unpacking
In reply to Christian BraunerExtract the initramfs unpacking code into a separate unpack_initramfs() function and wrap its invocation from do_populate_rootfs() with scoped_with_init_fs(). This ensures all file operations during initramfs unpacking (including filp_open() calls in do_name() and populate_initrd_image()) happen in init's filesystem context.
Note that security_initramfs_populated() needs the scope as well since it does use current->fs to derive the initramfs superblock.
do_populate_rootfs() ← async_schedule_domain() ← kworker (async workqueue)
May also run synchronously from PID 1 in case async workqueue is considered full. Overriding in that case is fine as well.
--- init/initramfs.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-)
init/initramfs.c +10 -4
@@ -3,6 +3,7 @@#include <linux/async.h> #include <linux/export.h> #include <linux/fs.h> +#include <linux/fs_struct.h> #include <linux/slab.h> #include <linux/types.h> #include <linux/fcntl.h>
@@ -708,7 +709,7 @@ static void __init populate_initrd_image(char *err) }#endif /* CONFIG_BLK_DEV_RAM */ -static void __init do_populate_rootfs (void *unused,async_cookie_t cookie) +static void __init unpack_initramfs (async_cookie_t cookie) {/* Load the built in initramfs */ char *err =unpack_to_rootfs (__initramfs_start, __initramfs_size);
@@ -716,7 +717,7 @@ static void __init do_populate_rootfs(void *unused, async_cookie_t cookie)panic_show_mem ("%s" , err);/* Failed to decompress INTERNAL initramfs */ if (!initrd_start ||IS_ENABLED (CONFIG_INITRAMFS_FORCE )) - goto done; +return ;if (IS_ENABLED (CONFIG_BLK_DEV_RAM ))printk (KERN_INFO "Trying to unpack rootfs image as initramfs...\n" );
@@ -731,9 +732,14 @@ static void __init do_populate_rootfs(void *unused, async_cookie_t cookie)printk (KERN_EMERG "Initramfs unpacking failed: %s\n" , err);#endif } +} -done: -security_initramfs_populated (); +static void __init do_populate_rootfs (void *unused,async_cookie_t cookie) +{ + scoped_with_init_fs() { +unpack_initramfs (cookie); +security_initramfs_populated (); + }/* * If the initrd region is overlapped with crashkernel reserved region,
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 18/25 af_unix: use scoped_with_init_fs() for coredump socket lookup
In reply to Christian BraunerUse scoped_with_init_fs() to temporarily override current->fs for the coredump unix socket path resolution. This replaces the init_root() + vfs_path_lookup() pattern with scoped_with_init_fs() + kern_path().
The old code used LOOKUP_BENEATH to confine the lookup beneath init's root. This is dropped because the coredump socket path is absolute and resolved from root (where ".." is a no-op), and LOOKUP_NO_SYMLINKS already blocks any symlink-based escape. LOOKUP_BENEATH was redundant in this context.
unix_find_bsd(SOCK_COREDUMP) ← coredump_sock_connect() ← do_coredump() — same crashing userspace process
Same security rationale as coredump.
--- net/unix/af_unix.c | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-)
net/unix/af_unix.c +6 -11
@@ -1198,17 +1198,12 @@ static struct sock *unix_find_bsd(struct sockaddr_un *sunaddr, int addr_len,unix_mkname_bsd (sunaddr, addr_len);if (flags &SOCK_COREDUMP ) { -struct path root; - -task_lock (&init_task); -get_fs_root (init_task.fs, &root); -task_unlock (&init_task); - -scoped_with_kernel_creds () - err = vfs_path_lookup(root.dentry, root.mnt, sunaddr->sun_path, -LOOKUP_BENEATH |LOOKUP_NO_SYMLINKS | -LOOKUP_NO_MAGICLINKS , &path); -path_put (&root); + scoped_with_init_fs() { +scoped_with_kernel_creds () + err = kern_path(sunaddr->sun_path, +LOOKUP_NO_SYMLINKS | +LOOKUP_NO_MAGICLINKS , &path); + }if (err) goto fail; }else {
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 19/25 fs: stop sharing fs_struct between init_task and pid 1
In reply to Christian BraunerSpawn kernel_init (PID 1) via kernel_clone() directly instead of user_mode_thread(), without CLONE_FS. This gives PID 1 its own private copy of init_task's fs_struct rather than sharing it.
This is a prerequisite for isolating kthreads in nullfs: when init_task's fs is later pointed at nullfs, PID 1 must not share it or init_userspace_fs() would modify init_task's fs as well, defeating the isolation.
At this stage PID 1 still gets rootfs (a private copy rather than a shared reference), so there is no functional change.
--- init/main.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
init/main.c +6 -1
@@ -716,6 +716,11 @@ static __initdata DECLARE_COMPLETION(kthreadd_done); static noinline void __ref __noreturn rest_init(void) { +struct kernel_clone_args init_args = { + .flags = (CLONE_VM |CLONE_UNTRACED ), + .fn = kernel_init, + .fn_arg =NULL , + };struct task_struct *tsk;int pid;
@@ -725,7 +730,7 @@ static noinline void __ref __noreturn rest_init(void)* the init task will end up wanting to create kthreads, which, if * we schedule it before we create kthreadd, will OOPS. */ - pid =user_mode_thread (kernel_init,NULL ,CLONE_FS ); + pid =kernel_clone (&init_args);/* * Pin init on the boot CPU. Task migration is not properly working * until sched_init_smp() has been run. It will set the allowed
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 20/25 fs: add umh argument to struct kernel_clone_args
In reply to Christian BraunerAdd a umh field to struct kernel_clone_args. When set, copy_fs() copies from pid 1's fs_struct instead of the kthread's fs_struct. This ensures usermodehelper threads always get init's filesystem state regardless of their parent's (kthreadd's) fs.
Usermodehelper threads are not allowed to create mount namespaces (CLONE_NEWNS), share filesystem state (CLONE_FS), or be started from a non-initial mount namespace. No usermodehelper currently does this so we don't need to worry about this restriction.
Set .umh = 1 in user_mode_thread(). At this stage pid 1's fs points to rootfs which is the same as kthreadd's fs, so this is functionally equivalent.
--- include/linux/sched/task.h | 1 + kernel/fork.c | 25 +++++++++++++++++++++---- kernel/umh.c | 6 ++---- 3 files changed, 24 insertions(+), 8 deletions(-)
include/linux/sched/task.h +1 -0
@@ -31,6 +31,7 @@ struct kernel_clone_args { u32 io_thread:1; u32 user_worker:1; u32 no_files:1; + u32 umh:1;unsigned long stack;unsigned long stack_size;unsigned long tls;
kernel/fork.c +21 -4
@@ -1593,11 +1593,27 @@ static int copy_mm(u64 clone_flags, struct task_struct *tsk)return 0 ; } -static int copy_fs (u64 clone_flags,struct task_struct *tsk) +static int copy_fs (u64 clone_flags,struct task_struct *tsk,bool umh) { -struct fs_struct *fs = current->fs; +struct fs_struct *fs; + +/* +* Usermodehelper may copy userspace_init_fs filesystem state but +* they don't get to create mount namespaces, share the +* filesystem state, or be started from a non-initial mount +* namespace. +*/ +if (umh) { +if (clone_flags & (CLONE_NEWNS |CLONE_FS )) +return -EINVAL ; +if (current->nsproxy->mnt_ns != &init_mnt_ns) +return -EINVAL ; + fs = userspace_init_fs; + }else { + fs = current->fs; +VFS_WARN_ON_ONCE (current->fs != current->real_fs); + } -VFS_WARN_ON_ONCE (current->fs != current->real_fs);if (clone_flags &CLONE_FS ) {/* tsk->fs is already what we want */ read_seqlock_excl (&fs->seq);
@@ -2252,7 +2268,7 @@ __latent_entropy struct task_struct *copy_process( retval =copy_files (clone_flags, p, args->no_files);if (retval) goto bad_fork_cleanup_semundo; - retval =copy_fs (clone_flags, p); + retval =copy_fs (clone_flags, p, args->umh);if (retval) goto bad_fork_cleanup_files; retval =copy_sighand (clone_flags, p);
@@ -2796,6 +2812,7 @@ pid_t user_mode_thread(int (*fn)(void *), void *arg, unsigned long flags) .exit_signal = (flags & CSIGNAL), .fn = fn, .fn_arg = arg, + .umh = 1, };return kernel_clone (&args);
kernel/umh.c +2 -4
@@ -71,10 +71,8 @@ static int call_usermodehelper_exec_async(void *data)spin_unlock_irq (¤t->sighand->siglock);/* -* Initial kernel threads share ther FS with init, in order to -* get the init root directory. But we've now created a new -* thread that is going to execve a user process and has its own -* 'struct fs_struct'. Reset umask to the default. +* Usermodehelper threads get a copy of userspace init's +* fs_struct. Reset umask to the default. */ current->fs->umask =0022 ;
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 21/25 devtmpfs: create private mount namespace
In reply to Christian BraunerKernel threads start in a completely isolated nullfs mount. Use UNSHARE_EMPTY_MNTNS to give the devtmpfsd kthread a private empty mount namespace with its root and pwd already set up, so it can mount its own devtmpfs instance instead of unsharing a copy of the initial mount namespace.
--- drivers/base/devtmpfs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/base/devtmpfs.c +1 -1
@@ -413,7 +413,7 @@ static noinline int __init devtmpfs_setup(void *p) {int err; - err =ksys_unshare (CLONE_NEWNS ); + err =ksys_unshare (UNSHARE_EMPTY_MNTNS );if (err) goto out; err =init_mount ("devtmpfs" ,"/" ,"devtmpfs" ,DEVTMPFS_MFLAGS ,NULL );
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 22/25 nullfs: make nullfs multi-instance
In reply to Christian BraunerAllow multiple instances of nullfs to be created. Right now we're only going to use it for kernel-internal purposes but ultimately we can allow userspace to use it too to e.g., safely overmount stuff.
--- fs/nullfs.c | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-)
fs/nullfs.c +3 -9
@@ -40,14 +40,9 @@ static int nullfs_fs_fill_super(struct super_block *s, struct fs_context *fc)return 0 ; } -/* -* For now this is a single global instance. If needed we can make it -* mountable by userspace at which point we will need to make it -* multi-instance. -*/ static int nullfs_fs_get_tree (struct fs_context *fc) { -return get_tree_single (fc, nullfs_fs_fill_super); +return get_tree_nodev (fc, nullfs_fs_fill_super); }static const struct fs_context_operations nullfs_fs_context_ops = {
@@ -57,9 +52,8 @@ static const struct fs_context_operations nullfs_fs_context_ops = {static int nullfs_init_fs_context (struct fs_context *fc) { fc->ops = &nullfs_fs_context_ops; - fc->global = true; - fc->sb_flags =SB_NOUSER ; - fc->s_iflags =SB_I_NOEXEC |SB_I_NODEV ; + fc->sb_flags |=SB_NOUSER ; + fc->s_iflags |=SB_I_NOEXEC |SB_I_NODEV ;return 0 ; }
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 23/25 fs: start all kthreads in nullfs
In reply to Christian BraunerPoint init_task's fs_struct (root and pwd) at a private nullfs instance instead of the mutable rootfs. All kthreads now start isolated in nullfs and must use scoped_with_init_fs() for any path resolution.
PID 1 is moved from nullfs into the initramfs by init_userspace_fs(). Usermodehelper threads use userspace_init_fs via the umh flag in copy_fs(). All subsystems that need init's filesystem state for path resolution already use scoped_with_init_fs() from earlier commits in this series.
This isolates kthreads from userspace filesystem state and makes it hard to perform filesystem operations from kthread context.
--- fs/namespace.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-)
fs/namespace.c +10 -6
@@ -6173,12 +6173,14 @@ static void __init init_mount_tree(void)struct path root;/* -* We create two mounts: +* We create three mounts: * * (1) nullfs with mount id 1 * (2) mutable rootfs with mount id 2 +* (3) private nullfs for kthreads (SB_KERNMOUNT) * -* with (2) mounted on top of (1). +* with (2) mounted on top of (1). The init_task's root and pwd +* are pointed at (3) so all kthreads start isolated in nullfs. */ nullfs_mnt =vfs_kern_mount (&nullfs_fs_type,0 ,"nullfs" ,NULL );if (IS_ERR (nullfs_mnt))
@@ -6218,12 +6220,14 @@ static void __init init_mount_tree(void) init_mnt_ns.nr_mounts++; } + nullfs_mnt =kern_mount (&nullfs_fs_type); +if (IS_ERR (nullfs_mnt)) +panic ("VFS: Failed to create private nullfs instance" ); + root.mnt = nullfs_mnt; + root.dentry = nullfs_mnt->mnt_root; + init_task.nsproxy->mnt_ns = &init_mnt_ns;get_mnt_ns (&init_mnt_ns); - -/* The root and pwd always point to the mutable rootfs. */ - root.mnt = mnt; - root.dentry = mnt->mnt_root;set_fs_pwd (current->fs, &root);set_fs_root (current->fs, &root);
Signature · 1 line
2.47.3
Re: [PATCH RFC v4 23/25] fs: start all kthreads in nullfs
Hi Christian,
Quoted 40 lines · Christian Brauner
Point init_task's
fs_struct(root and pwd) at a private nullfs instance instead of the mutable rootfs. All kthreads now start isolated in nullfs and must usescoped_with_init_fs()for any path resolution.PID 1 is moved from nullfs into the initramfs by
init_userspace_fs(). Usermodehelper threads useuserspace_init_fsvia the umh flag incopy_fs(). All subsystems that need init's filesystem state for path resolution already usescoped_with_init_fs()from earlier commits in this series.This isolates kthreads from userspace filesystem state and makes it hard to perform filesystem operations from kthread context.
Signed-off-by Christian Brauner (Amutable) <[email protected]>--- fs/namespace.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-)fs/namespace.c +4
-2@@ -6173,12 +6173,14 @@ static void __init init_mount_tree(void)struct path root;/* -* We create two mounts: +* We create three mounts: * * (1) nullfs with mount id 1 * (2) mutable rootfs with mount id 2 +* (3) private nullfs for kthreads (SB_KERNMOUNT) * -* with (2) mounted on top of (1). +* with (2) mounted on top of (1). The init_task's root and pwd +* are pointed at (3) so all kthreads start isolated in nullfs. */ nullfs_mnt =vfs_kern_mount (&nullfs_fs_type,0 ,"nullfs" ,NULL );if (IS_ERR (nullfs_mnt))
fs/namespace.c static void __init init_mount_tree(void) · line 6221
Quoted 2 lines
fs/namespace.c +0
-0@@ -6218,12 +6220,14 @@ static void __init init_mount_tree(void) init_mnt_ns.nr_mounts++; }
| LOCK_MOUNT_EXACT(mp, &root);
| if (unlikely(IS_ERR(mp.parent)))
| panic("VFS: Failed to mount rootfs on nullfs");
| scoped_guard(mount_writer)
| attach_mnt(real_mount(mnt), mp.parent, mp.mp);fs/namespace.c static void __init init_mount_tree(void) · line 6227
Quoted 6 lines
fs/namespace.c +5
-0+ nullfs_mnt =kern_mount (&nullfs_fs_type); +if (IS_ERR (nullfs_mnt)) +panic ("VFS: Failed to create private nullfs instance" ); + root.mnt = nullfs_mnt; + root.dentry = nullfs_mnt->mnt_root;
The following lockdep splat can be triggered on mainline, which is built with arm64's defconfig plus
CONFIG_SHRINKER_DEBUG
CONFIG_PROVE_LOCKING
CONFIG_FTRACE
. Reverting this patch (as pointed out by AI) makes this warn disappear. Please have a look :-) .
Thanks,
Zenghui
---8<---
======================================================
WARNING: possible circular locking dependency detected 7.3.0-rc3+ #17 Not tainted
------------------------------------------------------
rasdaemon/4449 is trying to acquire lock:
ffff80008246cb78 (namespace_sem){++++}-{4:4}, at: lock_mount_exact+0x4c/0x308
but task is already holding lock:
ffff002080496980 (&sb->s_type->i_mutex_key#17){++++}-{4:4}, at: lock_mount_exact+0x3c/0x308
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #3 (&sb->s_type->i_mutex_key#17){++++}-{4:4}:
down_read+0x48/0x164
lookup_slow+0x30/0x68
lookup_noperm_unlocked+0x58/0x5c
debugfs_change_name+0xd4/0x33c
shrinker_debugfs_rename+0xa8/0x118
setup_bdev_super+0x130/0x260
get_tree_bdev_flags+0x12c/0x1ec
get_tree_bdev+0x14/0x20
ext4_get_tree+0x18/0x24
vfs_get_tree+0x28/0xec
path_mount+0x3ec/0xbb8
__arm64_sys_mount+0x190/0x2d8
invoke_syscall+0x54/0x110
el0_svc_common.constprop.0+0x40/0xe0
do_el0_svc+0x1c/0x28
el0_svc+0x4c/0x3a4
el0t_64_sync_handler+0xa0/0xe4
el0t_64_sync+0x198/0x19c-> #2 (shrinker_mutex){+.+.}-{4:4}:
__mutex_lock+0x90/0x870
mutex_lock_nested+0x24/0x30
shrinker_alloc+0x158/0x4a0
sget_fc+0x2fc/0x7b8
get_tree_nodev+0x2c/0xb8
nullfs_fs_get_tree+0x18/0x24
vfs_get_tree+0x28/0xec
vfs_kern_mount.part.0+0xcc/0x130
mnt_init+0x12c/0x470
vfs_caches_init+0x120/0x294
start_kernel+0x824/0x93c
__primary_switched+0x88/0x90-> #1 (&type->s_umount_key#2/1){+.+.}-{4:4}:
down_write_nested+0x34/0xcc
sget_fc+0x14c/0x7b8
get_tree_nodev+0x2c/0xb8
nullfs_fs_get_tree+0x18/0x24
vfs_get_tree+0x28/0xec
vfs_kern_mount.part.0+0xcc/0x130
mnt_init+0x2b0/0x470 -> kern_mount()
vfs_caches_init+0x120/0x294
start_kernel+0x824/0x93c
__primary_switched+0x88/0x90-> #0 (namespace_sem){++++}-{4:4}:
__lock_acquire+0x1490/0x21b8
lock_acquire+0x1d8/0x404
down_write+0x38/0xd0
lock_mount_exact+0x4c/0x308
finish_automount+0x70/0x134
__traverse_mounts+0xd4/0x22c
step_into_slowpath+0x2ec/0x390
path_openat+0x2b0/0x8d4
do_file_open+0x98/0x158
do_sys_openat2+0x78/0xfc
__arm64_sys_openat+0x70/0xbc
invoke_syscall+0x54/0x110
el0_svc_common.constprop.0+0x40/0xe0
do_el0_svc+0x1c/0x28
el0_svc+0x4c/0x3a4
el0t_64_sync_handler+0xa0/0xe4
el0t_64_sync+0x198/0x19cother info that might help us debug this:
Chain exists of: namespace_sem --> shrinker_mutex --> &sb->s_type->i_mutex_key#17 Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&sb->s_type->i_mutex_key#17);
lock(shrinker_mutex);
lock(&sb->s_type->i_mutex_key#17); lock(namespace_sem);
*** DEADLOCK ***
locks held by rasdaemon/4449: 1, last CPU#95:
#0: ffff002080496980 (&sb->s_type->i_mutex_key#17){++++}-{4:4}, at: lock_mount_exact+0x3c/0x308
stack backtrace: CPU: 95 UID: 0 PID: 4449 Comm: rasdaemon Not tainted 7.3.0-rc3+ #17 PREEMPT Hardware name: Huawei TaiShan 2280 V2/BC82AMDDA, BIOS 1.05 09/18/2019 Call trace: show_stack+0x18/0x24 (C) dump_stack_lvl+0x90/0xd0 dump_stack+0x18/0x24 print_circular_bug+0x294/0x378 check_noncircular+0x164/0x178 __lock_acquire+0x1490/0x21b8 lock_acquire+0x1d8/0x404 down_write+0x38/0xd0 lock_mount_exact+0x4c/0x308 finish_automount+0x70/0x134 __traverse_mounts+0xd4/0x22c step_into_slowpath+0x2ec/0x390 path_openat+0x2b0/0x8d4 do_file_open+0x98/0x158 do_sys_openat2+0x78/0xfc __arm64_sys_openat+0x70/0xbc invoke_syscall+0x54/0x110 el0_svc_common.constprop.0+0x40/0xe0 do_el0_svc+0x1c/0x28 el0_svc+0x4c/0x3a4 el0t_64_sync_handler+0xa0/0xe4 el0t_64_sync+0x198/0x19c
Christian Brauner
maintainerRe: [PATCH RFC v4 23/25] fs: start all kthreads in nullfs
Quoted 8 lines
The following lockdep splat can be triggered on mainline, which is built with arm64's defconfig plus
CONFIG_SHRINKER_DEBUG
CONFIG_PROVE_LOCKING
CONFIG_FTRACE. Reverting this patch (as pointed out by AI) makes this warn disappear.
This is benign and caused by holding LOCK_MOUNT_EXACT() for longer than necessary. I'm adding the appended fix to vfs.fixes.
From a6bd269dceeb76f92d5e8d378fed2482dd208085 Mon Sep 17 00:00:00 2001
From: Christian Brauner <[email protected]>
Date: Thu, 17 Sep 2026 13:20:25 +0200
Subject: [PATCH] fs: don't create the private nullfs mount under namespace_sem
init_mount_tree() mounts the mutable rootfs on top of nullfs via LOCK_MOUNT_EXACT(). That declares a pinned mountpoint with a cleanup attribute in the scope of the whole function so the nullfs root inode lock and namespace_sem are only dropped when init_mount_tree() returns.
This became a problem when the private nullfs instance for kthreads was added. kern_mount() allocates a new superblock and alloc_super() takes the new s_umount with SINGLE_DEPTH_NESTING and then shrinker_mutex via shrinker_alloc(). Doing that with namespace_sem held teaches lockdep the dependency
namespace_sem -> s_umount/1 -> shrinker_mutex
With CONFIG_SHRINKER_DEBUG shrinker_debugfs_rename() takes the debugfs directory inode lock under shrinker_mutex every time a block device is mounted and lock_mount_exact() takes namespace_sem under the inode lock of the mountpoint for every mount. So mounting anything on debugfs, e.g. the tracefs automount on /sys/kernel/debug/tracing, closes the cycle:
WARNING: possible circular locking dependency detected
7.3.0-rc3+ #17 Not tainted
------------------------------------------------------
rasdaemon/4449 is trying to acquire lock:
(namespace_sem){++++}-{4:4}, at: lock_mount_exact+0x4c/0x308
but task is already holding lock:
(&sb->s_type->i_mutex_key#17){++++}-{4:4}, at: lock_mount_exact+0x3c/0x308
which lock already depends on the new lock.
...
Chain exists of:
namespace_sem --> shrinker_mutex --> &sb->s_type->i_mutex_key#17This can't actually deadlock. init_mount_tree() runs single-threaded during early boot before any other task exists and nothing allocates a superblock under namespace_sem after that. But lockdep can't know that and disables itself for the rest of the boot.
Move mounting the rootfs on top of nullfs into a helper so the locks are dropped when it returns.
--- fs/namespace.c | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-)
fs/namespace.c +16 -9
@@ -6184,6 +6184,21 @@ struct mnt_namespace init_mnt_ns = { .poll = __WAIT_QUEUE_HEAD_INITIALIZER(init_mnt_ns.poll), }; +static void __init mount_rootfs_on_nullfs (struct vfsmount *mnt, +struct vfsmount *nullfs_mnt) +{ +struct path root = { + .mnt = nullfs_mnt, + .dentry = nullfs_mnt->mnt_root, + }; + +LOCK_MOUNT_EXACT (mp, &root); +if (unlikely (IS_ERR (mp.parent))) +panic ("VFS: Failed to mount rootfs on nullfs" ); +scoped_guard (mount_writer) + attach_mnt(real_mount(mnt), mp.parent, mp.mp); +} +static void __init init_mount_tree (void ) {struct vfsmount *mnt, *nullfs_mnt;
@@ -6215,15 +6230,7 @@ static void __init init_mount_tree(void) mnt_root =real_mount (nullfs_mnt); init_mnt_ns.root = mnt_root; -/* Mount mutable rootfs on top of nullfs. */ - root.mnt = nullfs_mnt; - root.dentry = nullfs_mnt->mnt_root; - -LOCK_MOUNT_EXACT (mp, &root); -if (unlikely (IS_ERR (mp.parent))) -panic ("VFS: Failed to mount rootfs on nullfs" ); -scoped_guard (mount_writer) - attach_mnt(real_mount(mnt), mp.parent, mp.mp); +mount_rootfs_on_nullfs (mnt, nullfs_mnt);pr_info ("VFS: Finished mounting rootfs on nullfs\n" );
Signature · 1 line
2.53.0
Zenghui Yu
Tested-byRe: [PATCH RFC v4 23/25] fs: start all kthreads in nullfs
Quoted 11 lines · Christian Brauner
Quoted 8 lines
The following lockdep splat can be triggered on mainline, which is built with arm64's defconfig plus
CONFIG_SHRINKER_DEBUG
CONFIG_PROVE_LOCKING
CONFIG_FTRACE. Reverting this patch (as pointed out by AI) makes this warn disappear.
This is benign and caused by holding
LOCK_MOUNT_EXACT()for longer than necessary. I'm adding the appended fix to vfs.fixes.
Thanks!
Zenghui
Christian Brauner
maintainerRFC PATCH v4 24/25 fs: stop rewriting kthread fs structs
In reply to Christian BraunerNow that we isolated kthreads filesystem state completely from userspace stop rewriting their state.
--- fs/fs_struct.c | 4 ++++ 1 file changed, 4 insertions(+)
fs/fs_struct.c +4 -0
@@ -61,6 +61,10 @@ void chroot_fs_refs(const struct path *old_root, const struct path *new_root)read_lock (&tasklist_lock);for_each_process_thread (g, p) { +/* leave kthreads alone */ +if (p->flags &PF_KTHREAD ) +continue ; +task_lock (p); fs = p->real_fs;if (fs) {
Signature · 1 line
2.47.3
Christian Brauner
maintainerRFC PATCH v4 25/25 fs: stop rewriting paths for PF_EXITING | PF_DUMPCORE
In reply to Christian BraunerSkip exiting and core-dumping tasks when rewriting fs_struct paths in chroot_fs_refs(). Such a task is about to release its fs_struct via exit_fs() anyway, so the worst case is that it lingers on a stale root/pwd until it does.
This isn't entirely free: a skipped task keeps its reference on the old root, so after a pivot_root() the old root can't be torn down until the task is gone. With umount2(MNT_DETACH) that only defers destruction of the old rootfs; a plain umount() could in principle fail with -EBUSY. In practice this doesn't matter -- pivot_root(2) is meant to be paired with MNT_DETACH and isn't issued while other tasks are actively using the mount namespace -- so the transient pin is harmless.
--- fs/fs_struct.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/fs_struct.c +1 -2
@@ -61,8 +61,7 @@ void chroot_fs_refs(const struct path *old_root, const struct path *new_root)read_lock (&tasklist_lock);for_each_process_thread (g, p) { -/* leave kthreads alone */ -if (p->flags &PF_KTHREAD ) +if (p->flags & (PF_KTHREAD |PF_EXITING |PF_DUMPCORE ))continue ;task_lock (p);
Signature · 1 line
2.47.3
Christian Brauner <[email protected]>:
Quoted 13 lines
We now also warn and notice when pid 1 simply stops sharing filesystem state with us, i.e., abandons it's
userspace_init_fs.On older kernels if PID 1 unshared its filesystem state with us the kernel simply used the stale
fs_structstate implicitly pinning anything that PID 1 had last used. Even if PID 1 might've moved on to some completely differentfs_structstate and might've even unmounted the old root.This has hilarious consequences: Think continuing to dump coredump state into an implicitly pinned directory somewhere. Calling random binaries in the old rootfs via usermodehelpers.
Quoted 6 lines
Be aggressive about this: We simply reject operating on stale
fs_structstate by revertinguserspace_init_fsto nullfs. Every kworker that does lookups after this point will fail. Every usermodehelper call will fail. This is a lot stronger but I wouldn't know what it means for pid 1 to simply stop sharing its fs state with the kernel. Clearly it wanted to separate so cut all ties.
Your approach means that you introduced new degraded system state:
"PID 1 unshared its fs_struct, so we switched all kernel threads to nullfs".
I don't like this. If PID 1 tries to unshare its fs_struct, then, please, just do nothing and return error to userspace.
(I already said this in one of previous threads about this. It seems you missed this, so I'm saying this again.)
Signature · 1 line
Askar Safin
Christian Brauner <[email protected]>:
Quoted 2 lines
So this is a bit of a crazy series. When the kernel is started it roughly goes like this:
You mention "nullfs" in comments. But we now have two nullfses:
for kthreads and for userspace. And it is not obvious which you mean.
For example:
+ * Be aggressive about this: We simply reject operating on stale
+ * fs_struct state by reverting to nullfs. Every kworker that does
+void __init init_userspace_fs(void)
+{
+ struct mount *m;
+ struct path root;
+
+ /* Move PID 1 from nullfs into the initramfs. */
+ m = topmost_overmount(current->nsproxy->mnt_ns->root);
So, please, create two terms for referring to these two nullfses and use them everywhere.
Okay, I have to admit: I found two uses of "nullfs" in comments only. But I still think that having terminology is valuable. For example, for documentation.
Signature · 1 line
Askar Safin