mount-related stuff
Subsystems (5)
Al Viro
maintainerPATCH v2 60/63 preparations to taking MNT_WRITE_HOLD out of ->mnt_flags
In reply to Al ViroWe have an unpleasant wart in accessibility rules for struct mount. There are per-superblock lists of mounts, used by sb_prepare_remount_readonly() to check if any of those is currently claimed for write access and to block further attempts to get write access on those until we are done.
As soon as it is attached to a filesystem, mount becomes reachable via that list. Only sb_prepare_remount_readonly() traverses it and it only accesses a few members of struct mount. Unfortunately, ->mnt_flags is one of those and it is modified - MNT_WRITE_HOLD set and then cleared. It is done under mount_lock, so from the locking rules POV everything's fine.
However, it has easily overlooked implications - once mount has been attached to a filesystem, it has to be treated as globally visible. In particular, initializing ->mnt_flags *must* be done either prior to that point or under mount_lock. All other members are still private at that point.
Life gets simpler if we move that bit (and that's *all* that can get touched by access via this list) out of ->mnt_flags. It's not even hard to do - currently the list is implemented as list_head one, anchored in super_block->s_mounts and linked via mount->mnt_instance.
As the first step, switch it to hlist-like open-coded structure - address of the first mount in the set is stored in ->s_mounts and ->mnt_instance replaced with ->mnt_next_for_sb and ->mnt_pprev_for_sb - the former either NULL or pointing to the next mount in set, the latter - address of either ->s_mounts or ->mnt_next_for_sb in the previous element of the set.
In the next commit we'll steal the LSB of ->mnt_pprev_for_sb as replacement for MNT_WRITE_HOLD.
--- fs/mount.h | 3 ++- fs/namespace.c | 38 +++++++++++++++++++++++++++++--------- fs/super.c | 3 +-- include/linux/fs.h | 4 +++- 4 files changed, 35 insertions(+), 13 deletions(-)
fs/mount.h +2 -1
@@ -64,7 +64,8 @@ struct mount {#endif struct list_head mnt_mounts;/* list of children, anchored here */ struct list_head mnt_child;/* and going through their mnt_child */ -struct list_head mnt_instance;/* mount instance on sb->s_mounts */ +struct mount *mnt_next_for_sb;/* the next two fields are hlist_node, */ +struct mount **mnt_pprev_for_sb;/* except that LSB of pprev will be stolen */ const char *mnt_devname;/* Name of device e.g. /dev/dsk/hda1 */ struct list_head mnt_list;struct list_head mnt_expire;/* link in fs-specific expiry list */
fs/namespace.c +29 -9
@@ -729,6 +729,27 @@ static inline void mnt_unhold_writers(struct mount *mnt) mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; } +static inline void mnt_del_instance (struct mount *m) +{ +struct mount **p = m->mnt_pprev_for_sb; +struct mount *next = m->mnt_next_for_sb; + +if (next) + next->mnt_pprev_for_sb = p; + *p = next; +} + +static inline void mnt_add_instance (struct mount *m,struct super_block *s) +{ +struct mount *first = s->s_mounts; + +if (first) + first->mnt_pprev_for_sb = &m->mnt_next_for_sb; + m->mnt_next_for_sb = first; + m->mnt_pprev_for_sb = &s->s_mounts; + s->s_mounts = m; +} +static int mnt_make_readonly (struct mount *mnt) {int ret;
@@ -742,7 +763,6 @@ static int mnt_make_readonly(struct mount *mnt)int sb_prepare_remount_readonly (struct super_block *sb) { -struct mount *mnt;int err =0 ;/* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */
@@ -750,9 +770,9 @@ int sb_prepare_remount_readonly(struct super_block *sb)return -EBUSY ;lock_mount_hash (); -list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) { -if (!(mnt->mnt.mnt_flags &MNT_READONLY )) { - err =mnt_hold_writers (mnt); +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { +if (!(m->mnt.mnt_flags &MNT_READONLY )) { + err =mnt_hold_writers (m);if (err)break ; }
@@ -762,9 +782,9 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (!err)sb_start_ro_state_change (sb); -list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) { -if (mnt->mnt.mnt_flags &MNT_WRITE_HOLD ) - mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { +if (m->mnt.mnt_flags &MNT_WRITE_HOLD ) + m->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; }unlock_mount_hash ();
@@ -1206,7 +1226,7 @@ static void setup_mnt(struct mount *m, struct dentry *root) m->mnt_parent = m;lock_mount_hash (); -list_add_tail (&m->mnt_instance, &s->s_mounts); +mnt_add_instance (m, s);unlock_mount_hash (); }
@@ -1424,7 +1444,7 @@ static void mntput_no_expire(struct mount *mnt) mnt->mnt.mnt_flags |=MNT_DOOMED ;rcu_read_unlock (); -list_del (&mnt->mnt_instance); +mnt_del_instance (mnt);if (unlikely (!list_empty (&mnt->mnt_expire)))list_del (&mnt->mnt_expire);
fs/super.c +1 -2
@@ -323,7 +323,6 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags,if (!s)return NULL ; -INIT_LIST_HEAD (&s->s_mounts); s->s_user_ns =get_user_ns (user_ns);init_rwsem (&s->s_umount);lockdep_set_class (&s->s_umount, &type->s_umount_key);
@@ -408,7 +407,7 @@ static void __put_super(struct super_block *s)list_del_init (&s->s_list);WARN_ON (s->s_dentry_lru.node);WARN_ON (s->s_inode_lru.node); -WARN_ON (!list_empty (&s->s_mounts)); +WARN_ON (s->s_mounts);call_rcu (&s->rcu, destroy_super_rcu); } }
include/linux/fs.h +3 -1
@@ -1324,6 +1324,8 @@ struct sb_writers {struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS ]; }; +struct mount ; +struct super_block {struct list_head s_list;/* Keep this first */ dev_t s_dev;/* search index; _not_ kdev_t */
@@ -1358,7 +1360,7 @@ struct super_block {__u16 s_encoding_flags;#endif struct hlist_bl_head s_roots;/* alternate root dentries for NFS */ -struct list_head s_mounts;/* list of mounts; _not_ for fs use */ +struct mount *s_mounts;/* list of mounts; _not_ for fs use */ struct block_device *s_bdev;/* can go away once we use an accessor for @s_bdev_file */ struct file *s_bdev_file;struct backing_dev_info *s_bdi;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v2 61/63 struct mount: relocate MNT_WRITE_HOLD bit
In reply to Al Viro... from ->mnt_flags to LSB of ->mnt_pprev_for_sb.
This is safe - we always set and clear it within the same mount_lock scope, so we won't interfere with list operations - traversals are always forward, so they don't even look at ->mnt_prev_for_sb and both insertions and removals are in mount_lock scopes of their own, so that bit will be clear in *all* mount instances during those.
--- fs/mount.h | 3 ++- fs/namespace.c | 50 +++++++++++++++++++++---------------------- include/linux/fs.h | 4 +--- include/linux/mount.h | 3 +-- 4 files changed, 29 insertions(+), 31 deletions(-)
fs/mount.h +2 -1
@@ -65,7 +65,8 @@ struct mount {struct list_head mnt_mounts;/* list of children, anchored here */ struct list_head mnt_child;/* and going through their mnt_child */ struct mount *mnt_next_for_sb;/* the next two fields are hlist_node, */ -struct mount **mnt_pprev_for_sb;/* except that LSB of pprev will be stolen */ +unsigned long mnt_pprev_for_sb;/* except that LSB of pprev is stolen */ +#define WRITE_HOLD 1/* ... for use by mnt_hold_writers() */ const char *mnt_devname;/* Name of device e.g. /dev/dsk/hda1 */ struct list_head mnt_list;struct list_head mnt_expire;/* link in fs-specific expiry list */
fs/namespace.c +25 -25
145 lines not on this page · raw message
include/linux/fs.h +1 -3
@@ -1324,8 +1324,6 @@ struct sb_writers {struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS ]; }; -struct mount ; -struct super_block {struct list_head s_list;/* Keep this first */ dev_t s_dev;/* search index; _not_ kdev_t */
@@ -1360,7 +1358,7 @@ struct super_block {__u16 s_encoding_flags;#endif struct hlist_bl_head s_roots;/* alternate root dentries for NFS */ -struct mount *s_mounts;/* list of mounts; _not_ for fs use */ +void *s_mounts;/* list of mounts; _not_ for fs use */ struct block_device *s_bdev;/* can go away once we use an accessor for @s_bdev_file */ struct file *s_bdev_file;struct backing_dev_info *s_bdi;
include/linux/mount.h +1 -2
@@ -33,7 +33,6 @@ enum mount_flags {MNT_NOSYMFOLLOW =0x80 ,MNT_SHRINKABLE =0x100 , -MNT_WRITE_HOLD =0x200 , MNT_INTERNAL = 0x4000,
@@ -52,7 +51,7 @@ enum mount_flags { | MNT_READONLY | MNT_NOSYMFOLLOW,MNT_ATIME_MASK =MNT_NOATIME |MNT_NODIRATIME |MNT_RELATIME , -MNT_INTERNAL_FLAGS =MNT_WRITE_HOLD |MNT_INTERNAL |MNT_DOOMED | +MNT_INTERNAL_FLAGS =MNT_INTERNAL |MNT_DOOMED | MNT_SYNC_UMOUNT | MNT_LOCKED };
Signature · 1 line
2.47.2
Re: [PATCH v2 61/63] struct mount: relocate MNT_WRITE_HOLD bit
Quoted 2 lines · Al Viro
... from ->mnt_flags to LSB of ->mnt_pprev_for_sb.
Ugh. This one I'm not happy with.
The random new casts:
fs/namespace.c static inline int mnt_hold_writers(struct mount *mnt) · line 740
Quoted 11 lines
static inline void
mnt_del_instance(struct mount *m){fs/namespace.c +2
-2-struct mount **p = m->mnt_pprev_for_sb; +struct mount **p = (void *)m->mnt_pprev_for_sb;struct mount *next = m->mnt_next_for_sb;if (next) - next->mnt_pprev_for_sb = p; + next->mnt_pprev_for_sb = (unsigned long )p; *p = next; }
are just nasty. And it's there in multiple places (ie mnt_add_instance() has more of them).
Making things even *worse*, the other case you changed (s_mounts) it's a "void *", which means that it does *not* have casts in other places, and you still do things like
for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) {so that 's_mounts' thing is just silently cast from a untyped 'void *' to the 'struct mount *' that it used to be.
So no - this is *not* acceptable.
Same largely goes for that
fs/mount.h struct mount { · line 68
Quoted 2 lines
fs/mount.h +1
-1-struct mount **mnt_pprev_for_sb;/* except that LSB of pprev will be stolen */ +unsigned long mnt_pprev_for_sb;/* except that LSB of pprev is stolen */
change, but at least there it's now a 'unsigned long', so it will *always* complain if a cast is missing in either direction. That's better, but still horrendously ugly.
If you want to use an opaque type, then please make it be truly opaque. Not 'unsigned long'. And certainly not 'void *'. Make it be something that is still type-safe - you can make up a pointer to struct name that is never actually declared, so that it's basically a unique type (or two separate types for mnt_pprev_for_sb and
I'm not even clear on why you did this change, but if you want to have specific types for some reason, make them *really* specific. Don't make them 'void *', and 'unsigned long'.
Linus
Al Viro
maintainerRe: [PATCH v2 61/63] struct mount: relocate MNT_WRITE_HOLD bit
Quoted 15 lines · Linus Torvalds
Same largely goes for that
fs/mount.h struct mount { · line 68
Quoted 2 lines
fs/mount.h +1
-1-struct mount **mnt_pprev_for_sb;/* except that LSB of pprev will be stolen */ +unsigned long mnt_pprev_for_sb;/* except that LSB of pprev is stolen */ change, but at least there it's now a 'unsigned long', so it will *always* complain if a cast is missing in either direction. That's better, but still horrendously ugly.
If you want to use an opaque type, then please make it be truly opaque. Not 'unsigned long'. And certainly not 'void *'. Make it be something that is still type-safe - you can make up a pointer to struct name that is never actually declared, so that it's basically a unique type (or two separate types for
mnt_pprev_for_sband
Quoted 3 lines
I'm not even clear on why you did this change, but if you want to have specific types for some reason, make them *really* specific. Don't make them 'void *', and 'unsigned long'.
What I want to avoid is compiler seeing something like
(unsigned long)READ_ONCE(m->mnt_pprev_for_sb) & 1
and going "that thing is a pointer to struct mount *, either the address is even or it's an undefined behaviour and I can do whatever I want anyway; optimize it to 0".
unsigned long is a brute-force way to avoid that - it avoids UB (OK, avoids it as long as no struct mount instance has an odd address), so compiler can't start playing silly buggers.
If you have a prettier approach, I'd like to hear it - I obviously do not enjoy the way this one looks.
Re: [PATCH v2 61/63] struct mount: relocate MNT_WRITE_HOLD bit
Quoted 6 lines · Al Viro
What I want to avoid is compiler seeing something like
(unsigned long)READ_ONCE(m->mnt_pprev_for_sb) & 1and going "that thing is a pointer to struct mount *, either the address is even or it's an undefined behaviour and I can do whatever I want anyway; optimize it to 0".
Have you actually seen that? Because if some compiler does this, we have tons of other places that will hit this, and we'll need to try to figure out some generic solution, or - more likely - just disable said compiler "optimization".
And if you really want to deal with this theoretical issue, please just use a union for it, having both the proper pointer type and the 'unsigned long', and using the appropriate field instead of any type casts.
Linus
Al Viro
maintainerRe: [PATCH v2 61/63] struct mount: relocate MNT_WRITE_HOLD bit
Quoted 8 lines · Linus Torvalds
Quoted 6 lines · Al Viro
What I want to avoid is compiler seeing something like
(unsigned long)READ_ONCE(m->mnt_pprev_for_sb) & 1and going "that thing is a pointer to struct mount *, either the address is even or it's an undefined behaviour and I can do whatever I want anyway; optimize it to 0".
Quoted 4 lines
Have you actually seen that? Because if some compiler does this, we have tons of other places that will hit this, and we'll need to try to figure out some generic solution, or - more likely - just disable said compiler "optimization".
list_bl.h being an obvious victim... OK, convinced. No, I hadn't seen that, and I agree that we'll get some very visible breakage if that ever happens.
Anyway, I think I've come up with a trick that would be proof against that kind of idiocy:
struct mount *__aligned(1) *mnt_pprev_for_sb;
IOW, tell compiler that this member contains a pointer to a possibly unaligned object containing a pointer to struct mount.
Since the member is declared as pointer to unaligned object, compiler is not allowed to make any assumptions about the LSB of its value.
For any type T, we are fine with
T __aligned(1) *p; ... T *q = p;
and as long as the value of p is actually aligned, no nasal daemons should fly.
Since we never dereference them directly ('add' doesn't dereference them at all, 'del' copies to local struct mount ** and dereferences that), all generated memory accesses will be aligned ones.
Since the only values we'll ever assign to that member will be addresses of normally aligned objects, we should be fine.
Sure, __attribute__((__aligned__(...))) is not standard, but AFAICS we should not step into any UB in a compiler implementing it...
Replacements for the 59..62 in followups (I've reordered them - easier that way).
Al Viro
maintainerPATCH 59/63 simplify the callers of mnt_unhold_writers()
The logics in cleanup on failure in mount_setattr_prepare() is simplified by having the mnt_hold_writers() failure followed by advancing m to the next node in the tree before leaving the loop.
And since all calls are preceded by the same check that flag has been set and the function is inlined, let's just shift the check into it.
--- fs/namespace.c | 34 ++++++++++------------------------ 1 file changed, 10 insertions(+), 24 deletions(-)
fs/namespace.c +10 -24
@@ -714,13 +714,14 @@ static inline int mnt_hold_writers(struct mount *mnt)* Stop preventing write access to @mnt allowing callers to gain write access * to @mnt again. * -* This function can only be called after a successful call to -* mnt_hold_writers(). +* This function can only be called after a call to mnt_hold_writers(). * * Context: This function expects lock_mount_hash() to be held. */ static inline void mnt_unhold_writers (struct mount *mnt) { +if (!(mnt->mnt_flags &MNT_WRITE_HOLD )) +return ;/* * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers * that become unheld will see MNT_READONLY.
@@ -4773,8 +4774,10 @@ static int mount_setattr_prepare(struct mount_kattr *kattr, struct mount *mnt)if (!mnt_allow_writers (kattr, m)) { err =mnt_hold_writers (m); -if (err) +if (err) { + m =next_mnt (m, mnt);break ; + } }if (!(kattr->kflags &MOUNT_KATTR_RECURSE ))
@@ -4782,25 +4785,9 @@ static int mount_setattr_prepare(struct mount_kattr *kattr, struct mount *mnt) }if (err) { -struct mount *p; - -/* -* If we had to call mnt_hold_writers() MNT_WRITE_HOLD will -* be set in @mnt_flags. The loop unsets MNT_WRITE_HOLD for all -* mounts and needs to take care to include the first mount. -*/ -for (p = mnt; p; p =next_mnt (p, mnt)) { -/* If we had to hold writers unblock them. */ -if (p->mnt.mnt_flags &MNT_WRITE_HOLD ) -mnt_unhold_writers (p); - -/* -* We're done once the first mount we changed got -* MNT_WRITE_HOLD unset. -*/ -if (p == m) -break ; - } +/* undo all mnt_hold_writers() we'd done */ +for (struct mount *p = mnt; p != m; p =next_mnt (p, mnt)) +mnt_unhold_writers (p); }return err; }
@@ -4831,8 +4818,7 @@ static void mount_setattr_commit(struct mount_kattr *kattr, struct mount *mnt)WRITE_ONCE (m->mnt.mnt_flags, flags);/* If we had to hold writers unblock them. */ -if (m->mnt.mnt_flags &MNT_WRITE_HOLD ) -mnt_unhold_writers (m); +mnt_unhold_writers (m);if (kattr->propagation)change_mnt_propagation (m, kattr->propagation);
Signature · 1 line
2.47.2
Re: [59/63] simplify the callers of mnt_unhold_writers()
Quoted 9 lines · Al Viro
The logics in cleanup on failure in
mount_setattr_prepare()is simplified by having themnt_hold_writers()failure followed by advancing m to the next node in the tree before leaving the loop.And since all calls are preceded by the same check that flag has been set and the function is inlined, let's just shift the check into it.
Signed-off-by Al Viro <[email protected]>---
Al Viro
maintainerPATCH 60/63 setup_mnt(): primitive for connecting a mount to filesystem
In reply to Al ViroTake the identical logics in vfs_create_mount() and clone_mnt() into a new helper that takes an empty struct mount and attaches it to given dentry (sub)tree.
Should be called once in the lifetime of every mount, prior to making it visible in any data structures.
After that point ->mnt_root and ->mnt_sb never change; ->mnt_root is a counting reference to dentry and ->mnt_sb - an active reference to superblock.
Mount remains associated with that dentry tree all the way until the call of cleanup_mnt(), when the refcount eventually drops to zero.
--- fs/namespace.c | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-)
fs/namespace.c +17 -17
@@ -1196,6 +1196,21 @@ static void commit_tree(struct mount *mnt)touch_mnt_namespace (n); } +static void setup_mnt (struct mount *m,struct dentry *root) +{ +struct super_block *s = root->d_sb; + +atomic_inc (&s->s_active); + m->mnt.mnt_sb = s; + m->mnt.mnt_root =dget (root); + m->mnt_mountpoint = m->mnt.mnt_root; + m->mnt_parent = m; + +lock_mount_hash (); +list_add_tail (&m->mnt_instance, &s->s_mounts); +unlock_mount_hash (); +} +/** * vfs_create_mount - Create a mount for a configured superblock * @fc: The configuration context with the superblock attached
@@ -1219,15 +1234,8 @@ struct vfsmount *vfs_create_mount(struct fs_context *fc)if (fc->sb_flags &SB_KERNMOUNT ) mnt->mnt.mnt_flags =MNT_INTERNAL ; -atomic_inc (&fc->root->d_sb->s_active); - mnt->mnt.mnt_sb = fc->root->d_sb; - mnt->mnt.mnt_root =dget (fc->root); - mnt->mnt_mountpoint = mnt->mnt.mnt_root; - mnt->mnt_parent = mnt; +setup_mnt (mnt, fc->root); -lock_mount_hash (); -list_add_tail (&mnt->mnt_instance, &mnt->mnt.mnt_sb->s_mounts); -unlock_mount_hash ();return &mnt->mnt; }EXPORT_SYMBOL (vfs_create_mount);
@@ -1285,7 +1293,6 @@ EXPORT_SYMBOL_GPL(vfs_kern_mount);static struct mount *clone_mnt (struct mount *old,struct dentry *root,int flag) { -struct super_block *sb = old->mnt.mnt_sb;struct mount *mnt;int err;
@@ -1310,16 +1317,9 @@ static struct mount *clone_mnt(struct mount *old, struct dentry *root,if (mnt->mnt_group_id)set_mnt_shared (mnt); -atomic_inc (&sb->s_active); mnt->mnt.mnt_idmap =mnt_idmap_get (mnt_idmap (&old->mnt)); - mnt->mnt.mnt_sb = sb; - mnt->mnt.mnt_root =dget (root); - mnt->mnt_mountpoint = mnt->mnt.mnt_root; - mnt->mnt_parent = mnt; -lock_mount_hash (); -list_add_tail (&mnt->mnt_instance, &sb->s_mounts); -unlock_mount_hash (); +setup_mnt (mnt, root);if (flag &CL_PRIVATE )// we are done with it return mnt;
Signature · 1 line
2.47.2
Christian Brauner
maintainerRe: [60/63] setup_mnt(): primitive for connecting a mount to filesystem
Quoted 11 lines · Al Viro
Take the identical logics in
vfs_create_mount()andclone_mnt()into a new helper that takes an empty struct mount and attaches it to given dentry (sub)tree.Should be called once in the lifetime of every mount, prior to making it visible in any data structures.
After that point ->mnt_root and ->mnt_sb never change; ->mnt_root is a counting reference to dentry and ->mnt_sb - an active reference to superblock.
Quoted 6 lines
Mount remains associated with that dentry tree all the way until the call of
cleanup_mnt(), when the refcount eventually drops to zero.Signed-off-by Al Viro <[email protected]>---
Is this supposed to be the v3? I'm confused what I need to be looking at since it's a reply to v2 and some earlier review comments...
Al Viro
maintainerRe: [60/63] setup_mnt(): primitive for connecting a mount to filesystem
Quoted 16 lines · Christian Brauner
Quoted 15 lines · Al Viro
Take the identical logics in
vfs_create_mount()andclone_mnt()into a new helper that takes an empty struct mount and attaches it to given dentry (sub)tree.Should be called once in the lifetime of every mount, prior to making it visible in any data structures.
After that point ->mnt_root and ->mnt_sb never change; ->mnt_root is a counting reference to dentry and ->mnt_sb - an active reference to superblock.
Mount remains associated with that dentry tree all the way until the call of
cleanup_mnt(), when the refcount eventually drops to zero.
Quoted 5 lines
Quoted 2 lines
Signed-off-by Al Viro <[email protected]>---
Is this supposed to be the v3? I'm confused what I need to be looking at since it's a reply to v2 and some earlier review comments...
It would be in v3, but I didn't feel like sending another 63-patch mailbomb for the sake of these 4 changed commits (well, and a cosmetical change in #33, with matching modification in #35, ending with both being cleaner - with the same resulting tree after #35).
These 4 do repace #59..#62 in v3.
Al Viro
maintainerRe: [60/63] setup_mnt(): primitive for connecting a mount to filesystem
Quoted 6 lines · Al Viro
It would be in v3, but I didn't feel like sending another 63-patch mailbomb for the sake of these 4 changed commits (well, and a cosmetical change in #33, with matching modification in #35, ending with both being cleaner - with the same resulting tree after #35).
These 4 do repace #59..#62 in v3.
Speaking of v3 - does anybody have objections to the following?
1) allow ->show_path() to return -EOPNOTSUPP, interpreted as
"fall back to default seq_path(...)"? E.g. kernfs_sop_show_path() could return that if there's no ->scops->show_path().
2) pass the sodding escape set as explicit argument, made
an argument of fs/namespace.c:show_path() as well.
3) similar for ->show_devname().
4) ... and to hell with those string_unescape_inplace() calls
in there.
Al Viro
maintainer[RFC] does # really need to be escaped in devnames?
On one hand, we have commit ed5fce76b5ea "vfs: escape hash as
well" which added # to the escape set for devname in /prov/*/mount*; on another there's nfs_show_devname() doing
seq_escape(m, devname, " \t\n\\");
and similar for btrfs. And then there is afs_show_devname() that outright
includes # in that thing on regular basis:
char pref = '%';
...
switch (volume->type) {
case AFSVL_RWVOL:
break;
case AFSVL_ROVOL:
pref = '#';
if (volume->type_force)
suf = ".readonly";
break;
case AFSVL_BACKVOL:
pref = '#';
suf = ".backup";
break;
}
seq_printf(m, "%c%s:%s%s", pref, cell->name, volume->name, suf);For NFS and btrfs ones I might be convinced to add # to escape set; for AFS, though, I strongly suspect that userland would be very unhappy, and that's userland predating whatever code that "aims to parse fstab as well as /proc/mounts with the same logic" ed5fce76b5ea is refering to.
So... Siddhesh, could you clarify the claim about breaking getmntent(3)? Does it or does it not happen on every system that has readonly AFS volumes mounted?
Re: [RFC] does # really need to be escaped in devnames?
Quoted 4 lines · Al Viro
So... Siddhesh, could you clarify the claim about breaking getmntent(3)? Does it or does it not happen on every system that has readonly AFS volumes mounted?
Hmm. Looking at various source trees using Debian code search, at least dietlibc doesn't treat '#' specially at all.
And glibc seems to treat only a line that *starts* with a '#' (possibly preceded by space/tab combinations) as an empty line.
klibc checks for '#' at the beginning of the file (without any potential space skipping before)
Busybox seems to do the same "skip whitespace, then skip lines starting with '#'" that glibc does.
So I think the '#'-escaping logic is wrong. We should only escape '#' marks at the beginning of a line (since we already escape spaces and tabs, the "preceded by whitespace" doesn't matter).
And that means that we shouldn't do it in 'mangle()' at all - because it's irrelevant for any field but the first.
And the first field in /proc/mounts is that 'r->mnt_devname' (or show_devname), and again, that should only trigger on the first character, not every character.
Now, could there be other libraries that get this even worse wrong? Of course. But
Linus
Al Viro
maintainerRe: [RFC] does # really need to be escaped in devnames?
Quoted 22 lines · Linus Torvalds
Quoted 4 lines · Al Viro
So... Siddhesh, could you clarify the claim about breaking getmntent(3)? Does it or does it not happen on every system that has readonly AFS volumes mounted?
Hmm. Looking at various source trees using Debian code search, at least dietlibc doesn't treat '#' specially at all.
And glibc seems to treat only a line that *starts* with a '#' (possibly preceded by space/tab combinations) as an empty line.
klibc checks for '#' at the beginning of the file (without any potential space skipping before)
Busybox seems to do the same "skip whitespace, then skip lines starting with '#'" that glibc does.
So I think the '#'-escaping logic is wrong. We should only escape '#' marks at the beginning of a line (since we already escape spaces and tabs, the "preceded by whitespace" doesn't matter).
Quoted 6 lines
And that means that we shouldn't do it in '
mangle()' at all - because it's irrelevant for any field but the first.And the first field in
/proc/mountsis that 'r->mnt_devname' (orshow_devname), and again, that should only trigger on the first character, not every character.
*nod*
Amusingly enough, glibc addmntent(3) does *not* consider # for an octal escape.
BTW, another amuzing bogosity:
seq_escape(m, "blah", "X") => "blah" seq_escape(m, "blah", "b") => "\142lah" seq_escape(m, "blah", "") => "\142\154\141\150"
IOW, about 10 years ago an empty string switched meaning from "escape nothing" to "escape everything"...
Re: [RFC] does # really need to be escaped in devnames?
In reply to Linus TorvaldsQuoted 15 lines · Linus Torvalds
Quoted 4 lines · Al Viro
So... Siddhesh, could you clarify the claim about breaking getmntent(3)? Does it or does it not happen on every system that has readonly AFS volumes mounted?
Hmm. Looking at various source trees using Debian code search, at least dietlibc doesn't treat '#' specially at all.
And glibc seems to treat only a line that *starts* with a '#' (possibly preceded by space/tab combinations) as an empty line.
klibc checks for '#' at the beginning of the file (without any potential space skipping before)
Quoted 6 lines
Busybox seems to do the same "skip whitespace, then skip lines starting with '#'" that glibc does.
So I think the '#'-escaping logic is wrong. We should only escape '#' marks at the beginning of a line (since we already escape spaces and tabs, the "preceded by whitespace" doesn't matter).
This was actually the original issue I had tried to address, escaping '#' in the beginning of the devname because it ends up in the beginning of the line, thus masking out the entire line in mounts. I don't remember at what point I concluded that escaping '#' always was the answer (maybe to protect against any future instances where userspace ends up ignoring the rest of the line following the '#'), but it appears to be wrong.
Sid
Re: [RFC] does # really need to be escaped in devnames?
Quoted 8 lines · Siddhesh Poyarekar
This was actually the original issue I had tried to address, escaping '#' in the beginning of the devname because it ends up in the beginning of the line, thus masking out the entire line in mounts. I don't remember at what point I concluded that escaping '#' always was the answer (maybe to protect against any future instances where userspace ends up ignoring the rest of the line following the '#'), but it appears to be wrong.
I wonder if instead of escaping hash-marks we could just disallow them as the first character in devname.
How did this issue with hash-marks get found? Is there some real use - in which case we obviously can't disallow them - or was this from some fuzzing test that happened to hit it?
Linus
Re: [RFC] does # really need to be escaped in devnames?
Quoted 10 lines · Linus Torvalds
Quoted 8 lines · Siddhesh Poyarekar
This was actually the original issue I had tried to address, escaping '#' in the beginning of the devname because it ends up in the beginning of the line, thus masking out the entire line in mounts. I don't remember at what point I concluded that escaping '#' always was the answer (maybe to protect against any future instances where userspace ends up ignoring the rest of the line following the '#'), but it appears to be wrong.
Quoted 6 lines
I wonder if instead of escaping hash-marks we could just disallow them as the first character in devname.
How did this issue with hash-marks get found? Is there some real use - in which case we obviously can't disallow them - or was this from some fuzzing test that happened to hit it?
The original issue was that devname being blank broke parsing of mounts, which was fixed with Ian's patch[1]. While debugging that issue I stumbled onto the fact that if the devname started with #, it would make the mount invisible to getmntent in glibc, since it ignores lines starting with #.
Sid
David Howells
maintainerRe: [RFC] does # really need to be escaped in devnames?
In reply to Linus TorvaldsQuoted 10 lines · Linus Torvalds
Quoted 8 lines · Siddhesh Poyarekar
This was actually the original issue I had tried to address, escaping '#' in the beginning of the devname because it ends up in the beginning of the line, thus masking out the entire line in mounts. I don't remember at what point I concluded that escaping '#' always was the answer (maybe to protect against any future instances where userspace ends up ignoring the rest of the line following the '#'), but it appears to be wrong.
Quoted 2 lines
I wonder if instead of escaping hash-marks we could just disallow them as the first character in devname.
The problem with that is that it appears that people are making use of this.
Mount /afs with "-o dynroot" isn't a problem as that shouldn't be given a device name - and that's the main way people access AFS. With OpenAFS I don't think you can do this at all since it has a single superblock that it crams everything under. For AuriStor, I think you can mount individual volumes, but I'm not sure how it works. For Linux's AFS, I made every volume have its own superblock.
The standard format of AFS volume names is [%#][<cell>:]<volume-name-or-id> but I could make it an option to stick something on the front and use that internally and display that in /proc/mounts, e.g.:
mount afs:#openafs.org:afs.root /mnt
which would at least mean that sh and bash wouldn't need the "#" escaping.
The problem is that the # and the % have specific documented meanings, so if I was to get rid of the '#' entirely, I would need some other marker. Maybe it would be sufficient to just go on the presence or not of a '%'.
Maybe I could go with something like:
openafs.org:root.cell:ro
openafs.org:root.cell:rw
openafs.org:root.cell:bak
rather than use #/%.
I don't think there should be a problem with still accepting lines beginning with '#' in mount() if I display them with an appropriate prefix. That would at least permit backward compatibility.
David
Re: [RFC] does # really need to be escaped in devnames?
Quoted 2 lines · David Howells
The problem with that is that it appears that people are making use of this.
Ok. So disallowing it isn't in the cards, but let's try to minimize the impact.
Quoted 5 lines
The standard format of AFS volume names is [%#][<cell>:]<volume-name-or-id> but I could make it an option to stick something on the front and use that internally and display that in
/proc/mounts, e.g.:mount afs:#openafs.org:afs.root /mnt
Yeah, let's aim for trying to avoid the '#' at the beginning when all possible, by trying to make at least the default formats not start with a hash.
And then make the escaping logic only escape the hashmark if it's the first character.
Quoted 3 lines
I don't think there should be a problem with still accepting lines beginning with '#' in
mount()if I display them with an appropriate prefix. That would at least permit backward compatibility.
Well, right now we obviously escape it everywhere, but how about we make it the rule that 'show_devname()' at least doesn't use it as the first character, and then if somebody uses '#' for the mount name from user space, we would just do the octal-escape then.
Something ENTIRELY UNTESTED like this, in other words?
Linus
fs/afs/super.c | 2 +- fs/proc_namespace.c | 9 +++++++-- 2 files changed, 8 insertions(+), 3 deletions(-)
fs/afs/super.c +1 -1
@@ -180,7 +180,7 @@ static int afs_show_devname(struct seq_file *m, struct dentry *root)break ; } -seq_printf (m,"%c%s:%s%s" , pref, cell->name, volume->name, suf); +seq_printf (m,"afs-%c%s:%s%s" , pref, cell->name, volume->name, suf);return 0 ; }
fs/proc_namespace.c +7 -2
@@ -86,7 +86,7 @@ static void show_vfsmnt_opts(struct seq_file *m, struct vfsmount *mnt)static inline void mangle (struct seq_file *m,const char *s) { -seq_escape (m, s," \t\n\\#" ); +seq_escape (m, s," \t\n\\" ); }static void show_type (struct seq_file *m,struct super_block *sb)
@@ -111,7 +111,12 @@ static int show_vfsmnt(struct seq_file *m, struct vfsmount *mnt)if (err) goto out; }else { -mangle (m, r->mnt_devname); +const char *mnt_devname = r->mnt_devname; +if (*mnt_devname =='#' ) { +seq_printf (m,"\\%o" ,'#' ); + mnt_devname++; + } +mangle (m, mnt_devname); }seq_putc (m,' ' );/* mountpoints outside of chroot jail will give SEQ_SKIP on this */
David Howells
maintainerRe: [RFC] does # really need to be escaped in devnames?
How about the attached? I've changed the way the volume is displayed in /proc/mounts to use the numeric volume ID, e.g.:
openafs.org:536870922~root.doc on /afs/openafs.org/doc type afs (ro,relatime,flock=local)
but included the volume name as kind of a comment as it's easier for human eye to comprehend. I've also altered the afs mount devname parser so that it can handle this sort of devname and to discard the "comment".
We don't actually need to display the [#%] preference marker or the .readonly/.backup suffixes as they're only really relevant when resolving a mountpoint. See:
https://docs.openafs.org/AdminGuide/HDRWQ208.html#HDRWQ209
(we only need to know what sort of mount we're on and if we're given an explicit instruction).
David
---
afs: Fix devname used in /proc/mounts
There's an issue with the way kafs mounts are displayed in /proc/mounts and supplied in the mount device name: the devname may begin with either a '#' or a '%'. The former is a problem, however, as some tools interpret this as a comment (e.g. getmntent(3)).
There is another pair of issues as well in that the volume name may be changed whilst the volume is mounted and the volume name may be remapped to a different volume. Really, the volume name should only be considered during mount and the volume ID (which is part of the primary key to sget()) should be used instead where possible. That said, it's more user-friendly to see the volume name in /proc/mounts.
Fix this by:
(1) Change the kafs device name used in /proc/mounts such that it shows the cell and the volume number with the current volume name after a tilda, e.g.:
openafs.org:536870922~root.doc on /afs/grand.central.org/doc type afs (ro,relatime,flock=local)
(2) Alter the mount name parsing so that it accepts:
"[<cell>:]<volid>[~comment]"
as the device name, thereby allowing stuff scraped from /proc/mounts to be fed back, e.g.:
mount -t afs openafs.org:536870922~root.doc /mnt mount -t afs openafs.org:536870922 /mnt mount -t afs 536870922 /mnt
The "comment" is ignored, allowing the current volume name (which is subject to third party changes) to also be displayed.
The parsing of the AFS mountpoint target format is retained both for backward compatibility and to be able to handle automounting, e.g.:
mount -t afs \#openafs.org:root.doc /mnt
ls /afs/openafs.org/doc
Note that this may surprise any tools that expect to see the old forms of kafs line in /proc/mounts.
--- fs/afs/internal.h | 1 fs/afs/super.c | 105 +++++++++++++++++++++++++++++++----------------------- 2 files changed, 63 insertions(+), 43 deletions(-)
fs/afs/internal.h +1 -0
@@ -53,6 +53,7 @@ struct afs_fs_context {bool autocell;/* T if set auto mount operation */ bool dyn_root;/* T if dynamic root */ bool no_cell;/* T if the source is "none" (for dynroot) */ +bool by_vid;/* T if mount by volume ID */ enum afs_flock_mode flock_mode;/* Partial file-locking emulation mode */ afs_voltype_t type;/* type of volume requested */ unsigned int volnamesz;/* size of volume name */
fs/afs/super.c +62 -43
166 lines not on this page · raw message
Re: [60/63] setup_mnt(): primitive for connecting a mount to filesystem
In reply to Al ViroQuoted 11 lines · Al Viro
Take the identical logics in
vfs_create_mount()andclone_mnt()into a new helper that takes an empty struct mount and attaches it to given dentry (sub)tree.Should be called once in the lifetime of every mount, prior to making it visible in any data structures.
After that point ->mnt_root and ->mnt_sb never change; ->mnt_root is a counting reference to dentry and ->mnt_sb - an active reference to superblock.
Quoted 6 lines
Mount remains associated with that dentry tree all the way until the call of
cleanup_mnt(), when the refcount eventually drops to zero.Signed-off-by Al Viro <[email protected]>---
Al Viro
maintainerPATCH 61/63 preparations to taking MNT_WRITE_HOLD out of ->mnt_flags
In reply to Al ViroWe have an unpleasant wart in accessibility rules for struct mount. There are per-superblock lists of mounts, used by sb_prepare_remount_readonly() to check if any of those is currently claimed for write access and to block further attempts to get write access on those until we are done.
As soon as it is attached to a filesystem, mount becomes reachable via that list. Only sb_prepare_remount_readonly() traverses it and it only accesses a few members of struct mount. Unfortunately, ->mnt_flags is one of those and it is modified - MNT_WRITE_HOLD set and then cleared. It is done under mount_lock, so from the locking rules POV everything's fine.
However, it has easily overlooked implications - once mount has been attached to a filesystem, it has to be treated as globally visible. In particular, initializing ->mnt_flags *must* be done either prior to that point or under mount_lock. All other members are still private at that point.
Life gets simpler if we move that bit (and that's *all* that can get touched by access via this list) out of ->mnt_flags. It's not even hard to do - currently the list is implemented as list_head one, anchored in super_block->s_mounts and linked via mount->mnt_instance.
As the first step, switch it to hlist-like open-coded structure - address of the first mount in the set is stored in ->s_mounts and ->mnt_instance replaced with ->mnt_next_for_sb and ->mnt_pprev_for_sb - the former either NULL or pointing to the next mount in set, the latter - address of either ->s_mounts or ->mnt_next_for_sb in the previous element of the set.
In the next commit we'll steal the LSB of ->mnt_pprev_for_sb as replacement for MNT_WRITE_HOLD.
--- fs/mount.h | 4 +++- fs/namespace.c | 38 +++++++++++++++++++++++++++++--------- fs/super.c | 3 +-- include/linux/fs.h | 4 +++- 4 files changed, 36 insertions(+), 13 deletions(-)
fs/mount.h +3 -1
@@ -64,7 +64,9 @@ struct mount {#endif struct list_head mnt_mounts;/* list of children, anchored here */ struct list_head mnt_child;/* and going through their mnt_child */ -struct list_head mnt_instance;/* mount instance on sb->s_mounts */ +struct mount *mnt_next_for_sb;/* the next two fields are hlist_node, */ +struct mount *__aligned(1) *mnt_pprev_for_sb; +/* except that LSB of pprev will be stolen */ const char *mnt_devname;/* Name of device e.g. /dev/dsk/hda1 */ struct list_head mnt_list;struct list_head mnt_expire;/* link in fs-specific expiry list */
fs/namespace.c +29 -9
@@ -730,6 +730,27 @@ static inline void mnt_unhold_writers(struct mount *mnt) mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; } +static inline void mnt_del_instance (struct mount *m) +{ +struct mount **p = m->mnt_pprev_for_sb; +struct mount *next = m->mnt_next_for_sb; + +if (next) + next->mnt_pprev_for_sb = p; + *p = next; +} + +static inline void mnt_add_instance (struct mount *m,struct super_block *s) +{ +struct mount *first = s->s_mounts; + +if (first) + first->mnt_pprev_for_sb = &m->mnt_next_for_sb; + m->mnt_next_for_sb = first; + m->mnt_pprev_for_sb = &s->s_mounts; + s->s_mounts = m; +} +static int mnt_make_readonly (struct mount *mnt) {int ret;
@@ -743,7 +764,6 @@ static int mnt_make_readonly(struct mount *mnt)int sb_prepare_remount_readonly (struct super_block *sb) { -struct mount *mnt;int err =0 ;/* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */
@@ -751,9 +771,9 @@ int sb_prepare_remount_readonly(struct super_block *sb)return -EBUSY ;lock_mount_hash (); -list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) { -if (!(mnt->mnt.mnt_flags &MNT_READONLY )) { - err =mnt_hold_writers (mnt); +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { +if (!(m->mnt.mnt_flags &MNT_READONLY )) { + err =mnt_hold_writers (m);if (err)break ; }
@@ -763,9 +783,9 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (!err)sb_start_ro_state_change (sb); -list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) { -if (mnt->mnt.mnt_flags &MNT_WRITE_HOLD ) - mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { +if (m->mnt.mnt_flags &MNT_WRITE_HOLD ) + m->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; }unlock_mount_hash ();
@@ -1207,7 +1227,7 @@ static void setup_mnt(struct mount *m, struct dentry *root) m->mnt_parent = m;lock_mount_hash (); -list_add_tail (&m->mnt_instance, &s->s_mounts); +mnt_add_instance (m, s);unlock_mount_hash (); }
@@ -1425,7 +1445,7 @@ static void mntput_no_expire(struct mount *mnt) mnt->mnt.mnt_flags |=MNT_DOOMED ;rcu_read_unlock (); -list_del (&mnt->mnt_instance); +mnt_del_instance (mnt);if (unlikely (!list_empty (&mnt->mnt_expire)))list_del (&mnt->mnt_expire);
fs/super.c +1 -2
@@ -323,7 +323,6 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags,if (!s)return NULL ; -INIT_LIST_HEAD (&s->s_mounts); s->s_user_ns =get_user_ns (user_ns);init_rwsem (&s->s_umount);lockdep_set_class (&s->s_umount, &type->s_umount_key);
@@ -408,7 +407,7 @@ static void __put_super(struct super_block *s)list_del_init (&s->s_list);WARN_ON (s->s_dentry_lru.node);WARN_ON (s->s_inode_lru.node); -WARN_ON (!list_empty (&s->s_mounts)); +WARN_ON (s->s_mounts);call_rcu (&s->rcu, destroy_super_rcu); } }
include/linux/fs.h +3 -1
@@ -1324,6 +1324,8 @@ struct sb_writers {struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS ]; }; +struct mount ; +struct super_block {struct list_head s_list;/* Keep this first */ dev_t s_dev;/* search index; _not_ kdev_t */
@@ -1358,7 +1360,7 @@ struct super_block {__u16 s_encoding_flags;#endif struct hlist_bl_head s_roots;/* alternate root dentries for NFS */ -struct list_head s_mounts;/* list of mounts; _not_ for fs use */ +struct mount *s_mounts;/* list of mounts; _not_ for fs use */ struct block_device *s_bdev;/* can go away once we use an accessor for @s_bdev_file */ struct file *s_bdev_file;struct backing_dev_info *s_bdi;
Signature · 1 line
2.47.2
Re: [61/63] preparations to taking MNT_WRITE_HOLD out of ->mnt_flags
Quoted 30 lines · Al Viro
We have an unpleasant wart in accessibility rules for struct mount. There are per-superblock lists of mounts, used by
sb_prepare_remount_readonly()to check if any of those is currently claimed for write access and to block further attempts to get write access on those until we are done.As soon as it is attached to a filesystem, mount becomes reachable via that list. Only
sb_prepare_remount_readonly()traverses it and it only accesses a few members of struct mount. Unfortunately, ->mnt_flags is one of those and it is modified -MNT_WRITE_HOLDset and then cleared. It is done undermount_lock, so from the locking rules POV everything's fine.However, it has easily overlooked implications - once mount has been attached to a filesystem, it has to be treated as globally visible. In particular, initializing ->mnt_flags *must* be done either prior to that point or under
mount_lock. All other members are still private at that point.Life gets simpler if we move that bit (and that's *all* that can get touched by access via this list) out of ->mnt_flags. It's not even hard to do - currently the list is implemented as
list_headone, anchored insuper_block->s_mountsand linked viamount->mnt_instance.As the first step, switch it to hlist-like open-coded structure - address of the first mount in the set is stored in ->s_mounts and ->mnt_instance replaced with ->mnt_next_for_sb and ->mnt_pprev_for_sb - the former either NULL or pointing to the next mount in set, the latter - address of either ->s_mounts or ->mnt_next_for_sb in the previous element of the set.
Quoted 5 lines
In the next commit we'll steal the LSB of ->mnt_pprev_for_sb as replacement for
MNT_WRITE_HOLD.Signed-off-by Al Viro <[email protected]>---
Al Viro
maintainerPATCH 62/63 struct mount: relocate MNT_WRITE_HOLD bit
In reply to Al Viro... from ->mnt_flags to LSB of ->mnt_pprev_for_sb.
This is safe - we always set and clear it within the same mount_lock scope, so we won't interfere with list operations - traversals are always forward, so they don't even look at ->mnt_prev_for_sb and both insertions and removals are in mount_lock scopes of their own, so that bit will be clear in *all* mount instances during those.
--- fs/mount.h | 25 ++++++++++++++++++++++++- fs/namespace.c | 34 +++++++++++++++++----------------- include/linux/mount.h | 3 +-- 3 files changed, 42 insertions(+), 20 deletions(-)
fs/mount.h +24 -1
@@ -66,7 +66,8 @@ struct mount {struct list_head mnt_child;/* and going through their mnt_child */ struct mount *mnt_next_for_sb;/* the next two fields are hlist_node, */ struct mount *__aligned(1) *mnt_pprev_for_sb; -/* except that LSB of pprev will be stolen */ +/* except that LSB of pprev is stolen */ +#define WRITE_HOLD 1/* ... for use by mnt_hold_writers() */ const char *mnt_devname;/* Name of device e.g. /dev/dsk/hda1 */ struct list_head mnt_list;struct list_head mnt_expire;/* link in fs-specific expiry list */
@@ -244,4 +245,26 @@ static inline struct mount *topmost_overmount(struct mount *m)return m; } +static inline bool __test_write_hold (struct mount *__aligned(1) *val) +{ +return (unsigned long )val &WRITE_HOLD ; +} + +static inline bool test_write_hold (const struct mount *m) +{ +return __test_write_hold (m->mnt_pprev_for_sb); +} + +static inline void set_write_hold (struct mount *m) +{ + m->mnt_pprev_for_sb = (void *)((unsigned long )m->mnt_pprev_for_sb + |WRITE_HOLD ); +} + +static inline void clear_write_hold (struct mount *m) +{ + m->mnt_pprev_for_sb = (void *)((unsigned long )m->mnt_pprev_for_sb + & ~WRITE_HOLD ); +} +struct mnt_namespace *mnt_ns_from_dentry (struct dentry *dentry);
fs/namespace.c +17 -17
@@ -509,20 +509,20 @@ int mnt_get_write_access(struct vfsmount *m)mnt_inc_writers (mnt);/* * The store to mnt_inc_writers must be visible before we pass -* MNT_WRITE_HOLD loop below, so that the slowpath can see our -* incremented count after it has set MNT_WRITE_HOLD. +* WRITE_HOLD loop below, so that the slowpath can see our +* incremented count after it has set WRITE_HOLD. */ smp_mb ();might_lock (&mount_lock.lock); -while (READ_ONCE (mnt->mnt.mnt_flags) &MNT_WRITE_HOLD ) { +while (__test_write_hold (READ_ONCE (mnt->mnt_pprev_for_sb))) {if (!IS_ENABLED (CONFIG_PREEMPT_RT )) {cpu_relax (); }else {/* * This prevents priority inversion, if the task -* setting MNT_WRITE_HOLD got preempted on a remote +* setting WRITE_HOLD got preempted on a remote * CPU, and it prevents life lock if the task setting -* MNT_WRITE_HOLD has a lower priority and is bound to +* WRITE_HOLD has a lower priority and is bound to * the same CPU as the task that is spinning here. */ preempt_enable ();
@@ -533,7 +533,7 @@ int mnt_get_write_access(struct vfsmount *m) }/* * The barrier pairs with the barrier sb_start_ro_state_change() making -* sure that if we see MNT_WRITE_HOLD cleared, we will also see +* sure that if we see WRITE_HOLD cleared, we will also see * s_readonly_remount set (or even SB_RDONLY / MNT_READONLY flags) in * mnt_is_readonly() and bail in case we are racing with remount * read-only.
@@ -672,15 +672,15 @@ EXPORT_SYMBOL(mnt_drop_write_file);* @mnt. * * Context: This function expects lock_mount_hash() to be held serializing -* setting MNT_WRITE_HOLD. +* setting WRITE_HOLD. * Return: On success 0 is returned. * On error, -EBUSY is returned. */ static inline int mnt_hold_writers (struct mount *mnt) { - mnt->mnt.mnt_flags |=MNT_WRITE_HOLD ; +set_write_hold (mnt);/* -* After storing MNT_WRITE_HOLD, we'll read the counters. This store +* After storing WRITE_HOLD, we'll read the counters. This store * should be visible before we do. */ smp_mb ();
@@ -696,9 +696,9 @@ static inline int mnt_hold_writers(struct mount *mnt)* sum up each counter, if we read a counter before it is incremented, * but then read another CPU's count which it has been subsequently * decremented from -- we would see more decrements than we should. -* MNT_WRITE_HOLD protects against this scenario, because +* WRITE_HOLD protects against this scenario, because * mnt_want_write first increments count, then smp_mb, then spins on -* MNT_WRITE_HOLD, so it can't be decremented by another CPU while +* WRITE_HOLD, so it can't be decremented by another CPU while * we're counting up here. */ if (mnt_get_writers (mnt) >0 )
@@ -720,14 +720,14 @@ static inline int mnt_hold_writers(struct mount *mnt)*/ static inline void mnt_unhold_writers (struct mount *mnt) { -if (!(mnt->mnt_flags &MNT_WRITE_HOLD )) +if (!test_write_hold (mnt))return ;/* -* MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers +* MNT_READONLY must become visible before ~WRITE_HOLD, so writers * that become unheld will see MNT_READONLY. */ smp_wmb (); - mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; +clear_write_hold (mnt); }static inline void mnt_del_instance (struct mount *m)
@@ -766,7 +766,7 @@ int sb_prepare_remount_readonly(struct super_block *sb) {int err =0 ; -/* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */ +/* Racy optimization. Recheck the counter under WRITE_HOLD */ if (atomic_long_read (&sb->s_remove_count))return -EBUSY ;
@@ -784,8 +784,8 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (!err)sb_start_ro_state_change (sb);for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { -if (m->mnt.mnt_flags &MNT_WRITE_HOLD ) - m->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; +if (test_write_hold (m)) +clear_write_hold (m); }unlock_mount_hash ();
include/linux/mount.h +1 -2
@@ -33,7 +33,6 @@ enum mount_flags {MNT_NOSYMFOLLOW =0x80 ,MNT_SHRINKABLE =0x100 , -MNT_WRITE_HOLD =0x200 , MNT_INTERNAL = 0x4000,
@@ -52,7 +51,7 @@ enum mount_flags { | MNT_READONLY | MNT_NOSYMFOLLOW,MNT_ATIME_MASK =MNT_NOATIME |MNT_NODIRATIME |MNT_RELATIME , -MNT_INTERNAL_FLAGS =MNT_WRITE_HOLD |MNT_INTERNAL |MNT_DOOMED | +MNT_INTERNAL_FLAGS =MNT_INTERNAL |MNT_DOOMED | MNT_SYNC_UMOUNT | MNT_LOCKED };
Signature · 1 line
2.47.2
Re: [62/63] struct mount: relocate MNT_WRITE_HOLD bit
Quoted 44 lines · Al Viro
... from ->mnt_flags to LSB of ->mnt_pprev_for_sb.
This is safe - we always set and clear it within the same
mount_lockscope, so we won't interfere with list operations - traversals are always forward, so they don't even look at ->mnt_prev_for_sb and both insertions and removals are inmount_lockscopes of their own, so that bit will be clear in *all* mount instances during those.Signed-off-by Al Viro <[email protected]>--- fs/mount.h | 25 ++++++++++++++++++++++++- fs/namespace.c | 34 +++++++++++++++++----------------- include/linux/mount.h | 3 +-- 3 files changed, 42 insertions(+), 20 deletions(-)fs/mount.h +13
-1@@ -66,7 +66,8 @@ struct mount {struct list_head mnt_child;/* and going through their mnt_child */ struct mount *mnt_next_for_sb;/* the next two fields are hlist_node, */ struct mount *__aligned(1) *mnt_pprev_for_sb; -/* except that LSB of pprev will be stolen */ +/* except that LSB of pprev is stolen */ +#define WRITE_HOLD 1/* ... for use by mnt_hold_writers() */ const char *mnt_devname;/* Name of device e.g. /dev/dsk/hda1 */ struct list_head mnt_list;struct list_head mnt_expire;/* link in fs-specific expiry list */ @@ -244,4 +245,26 @@ static inline struct mount *topmost_overmount(struct mount *m)return m; } +static inline bool __test_write_hold (struct mount *__aligned(1) *val) +{ +return (unsigned long )val &WRITE_HOLD ; +} + +static inline bool test_write_hold (const struct mount *m) +{ +return __test_write_hold (m->mnt_pprev_for_sb); +} + +static inline void set_write_hold (struct mount *m)
fs/mount.h static inline struct mount *topmost_overmount(struct mount *m) · line 268
Quoted 10 lines
fs/mount.h +10
-0+{ + m->mnt_pprev_for_sb = (void *)((unsigned long )m->mnt_pprev_for_sb + |WRITE_HOLD ); +} + +static inline void clear_write_hold (struct mount *m) +{ + m->mnt_pprev_for_sb = (void *)((unsigned long )m->mnt_pprev_for_sb + & ~WRITE_HOLD ); +}
I have to say that I find this really unpleasant but... I've seen issues withe current MNT_WRITE_HOLD handling before when it interacted with MNT_ONRB (I killed that a while ago),
Al Viro
maintainerPATCH v2 62/63 simplify the callers of mnt_unhold_writers()
In reply to Al ViroThe logics in cleanup on failure in mount_setattr_prepare() is simplified by having the mnt_hold_writers() failure followed by advancing m to the next node in the tree before leaving the loop.
And since all calls are preceded by the same check that flag has been set and the function is inlined, let's just shift the check into it.
--- fs/namespace.c | 34 ++++++++++------------------------ 1 file changed, 10 insertions(+), 24 deletions(-)
fs/namespace.c +10 -24
@@ -714,13 +714,14 @@ static inline int mnt_hold_writers(struct mount *mnt)* Stop preventing write access to @mnt allowing callers to gain write access * to @mnt again. * -* This function can only be called after a successful call to -* mnt_hold_writers(). +* This function can only be called after a call to mnt_hold_writers(). * * Context: This function expects lock_mount_hash() to be held. */ static inline void mnt_unhold_writers (struct mount *mnt) { +if (!(mnt->mnt_pprev_for_sb &WRITE_HOLD )) +return ;/* * MNT_READONLY must become visible before ~WRITE_HOLD, so writers * that become unheld will see MNT_READONLY.
@@ -4793,8 +4794,10 @@ static int mount_setattr_prepare(struct mount_kattr *kattr, struct mount *mnt)if (!mnt_allow_writers (kattr, m)) { err =mnt_hold_writers (m); -if (err) +if (err) { + m =next_mnt (m, mnt);break ; + } }if (!(kattr->kflags &MOUNT_KATTR_RECURSE ))
@@ -4802,25 +4805,9 @@ static int mount_setattr_prepare(struct mount_kattr *kattr, struct mount *mnt) }if (err) { -struct mount *p; - -/* -* If we had to call mnt_hold_writers() WRITE_HOLD will -* be set in @mnt_flags. The loop unsets WRITE_HOLD for all -* mounts and needs to take care to include the first mount. -*/ -for (p = mnt; p; p =next_mnt (p, mnt)) { -/* If we had to hold writers unblock them. */ -if (p->mnt_pprev_for_sb &WRITE_HOLD ) -mnt_unhold_writers (p); - -/* -* We're done once the first mount we changed got -* WRITE_HOLD unset. -*/ -if (p == m) -break ; - } +/* undo all mnt_hold_writers() we'd done */ +for (struct mount *p = mnt; p != m; p =next_mnt (p, mnt)) +mnt_unhold_writers (p); }return err; }
@@ -4851,8 +4838,7 @@ static void mount_setattr_commit(struct mount_kattr *kattr, struct mount *mnt)WRITE_ONCE (m->mnt.mnt_flags, flags);/* If we had to hold writers unblock them. */ -if (mnt->mnt_pprev_for_sb &WRITE_HOLD ) -mnt_unhold_writers (m); +mnt_unhold_writers (m);if (kattr->propagation)change_mnt_propagation (m, kattr->propagation);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v2 63/63 WRITE_HOLD machinery: no need for to bump mount_lock seqcount
In reply to Al Viro... neither for insertion into the list of instances, nor for mnt_{un,}hold_writers(), nor for mnt_get_write_access() deciding to be nice to RT during a busy-wait loop - all of that only needs the spinlock side of mount_lock.
IOW, it's mount_locked_reader, not mount_writer.
Clarify the comment re locking rules for mnt_unhold_writers() - it's not just that mount_lock needs to be held when calling that, it must have been held all along since the matching mnt_hold_writers().
--- fs/namespace.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
fs/namespace.c +8 -8
@@ -526,8 +526,8 @@ int mnt_get_write_access(struct vfsmount *m)* the same CPU as the task that is spinning here. */ preempt_enable (); -lock_mount_hash (); -unlock_mount_hash (); +read_seqlock_excl (&mount_lock); +read_sequnlock_excl (&mount_lock);preempt_disable (); } }
@@ -671,7 +671,7 @@ EXPORT_SYMBOL(mnt_drop_write_file);* a call to mnt_unhold_writers() in order to stop preventing write access to * @mnt. * -* Context: This function expects lock_mount_hash() to be held serializing +* Context: This function expects to be in mount_locked_reader scope serializing * setting WRITE_HOLD. * Return: On success 0 is returned. * On error, -EBUSY is returned.
@@ -716,7 +716,8 @@ static inline int mnt_hold_writers(struct mount *mnt)* * This function can only be called after a call to mnt_hold_writers(). * -* Context: This function expects lock_mount_hash() to be held. +* Context: This function expects to be in the same mount_locked_reader scope +* as the matching mnt_hold_writers(). */ static inline void mnt_unhold_writers (struct mount *mnt) {
@@ -770,7 +771,8 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (atomic_long_read (&sb->s_remove_count))return -EBUSY ; -lock_mount_hash (); +guard (mount_locked_reader)(); +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) {if (!(m->mnt.mnt_flags &MNT_READONLY )) { err =mnt_hold_writers (m);
@@ -787,7 +789,6 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (m->mnt_pprev_for_sb &WRITE_HOLD ) m->mnt_pprev_for_sb &= ~WRITE_HOLD ; } -unlock_mount_hash ();return err; }
@@ -1226,9 +1227,8 @@ static void setup_mnt(struct mount *m, struct dentry *root) m->mnt_mountpoint = m->mnt.mnt_root; m->mnt_parent = m; -lock_mount_hash (); +guard (mount_locked_reader)();mnt_add_instance (m, s); -unlock_mount_hash (); }/**
Signature · 1 line
2.47.2
Re: [PATCH v2 63/63] WRITE_HOLD machinery: no need for to bump mount_lock seqcount
Quoted 5 lines · Al Viro
... neither for insertion into the list of instances, nor for mnt_{un,}hold_writers(), nor for
mnt_get_write_access()deciding to be nice to RT during a busy-wait loop - all of that only needs the spinlock side ofmount_lock.
Quoted 8 lines
IOW, it's
mount_locked_reader, notmount_writer.Clarify the comment re locking rules for
mnt_unhold_writers()- it's not just thatmount_lockneeds to be held when calling that, it must have been held all along since the matchingmnt_hold_writers().Signed-off-by Al Viro <[email protected]>---
Al Viro
maintainerRFC PATCH v3 1/1 mount-related stuff
In reply to Al ViroBranch force-pushed intogit://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs.git #work.mount (also visible as #v3.mount, #v[12].mount being the previous versions) Individual patches in followups.
If nobody objects, this goes into #for-next.
Changes since v2 (other than applied r-b):
#26: typo fix in description (do_new_mount_rc -> do_new_mount_fc) #33, #35: massage suggested by Linus
#35: where_to_mount() massage, more or less along the lines of
Christian's suggestion.
between #52 and #53: document locking in patch_check_mount() and useguard() in its caller (path_has_submounts()).
#56 (now #57): fixed editing braino in commit message
#58 (now #59): restored lost mnt_ns_tree_add()
#59..63 (now #60..64): rewritten (as posted last week)
added in the end of the series: constify {__,}mnt_is_readonly()Diffstat:
fs/dcache.c | 4 +- fs/ecryptfs/dentry.c | 14 +- fs/ecryptfs/ecryptfs_kernel.h | 27 +- fs/ecryptfs/file.c | 15 +- fs/ecryptfs/inode.c | 19 +- fs/ecryptfs/main.c | 24 +- fs/internal.h | 4 +- fs/mount.h | 39 +- fs/namespace.c | 992 ++++++++++++++++++++---------------------- fs/pnode.c | 75 +++- fs/pnode.h | 1 + fs/super.c | 3 +- include/linux/fs.h | 4 +- include/linux/mount.h | 9 +- kernel/audit_tree.c | 12 +- 15 files changed, 603 insertions(+), 639 deletions(-)
Al Viro
maintainerPATCH v3 1/65 fs/namespace.c: fix the namespace_sem guard mess
If anything, namespace_lock should be DEFINE_LOCK_GUARD_0, not DEFINE_GUARD. That way we
* do not need to feed it a bogus argument
* do not get gcc trying to compare an address of static in
file variable with -4097 - and, if we are unlucky, trying to keep it in a register, with spills and all such.
The same problems apply to grabbing namespace_sem shared.
Rename it to namespace_excl, add namespace_shared, convert the existing users:
guard(namespace_lock, &namespace_sem) => guard(namespace_excl)() guard(rwsem_read, &namespace_sem) => guard(namespace_shared)() scoped_guard(namespace_lock, &namespace_sem) => scoped_guard(namespace_excl) scoped_guard(rwsem_read, &namespace_sem) => scoped_guard(namespace_shared)
--- fs/namespace.c | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-)
fs/namespace.c +11 -7
@@ -82,6 +82,12 @@ static LIST_HEAD(ex_mountpoints); /* protected by namespace_sem */static struct mnt_namespace *emptied_ns;/* protected by namespace_sem */ static DEFINE_SEQLOCK (mnt_ns_tree_lock); +static inline void namespace_lock (void ); +static void namespace_unlock (void ); +DEFINE_LOCK_GUARD_0(namespace_excl, namespace_lock(), namespace_unlock()) +DEFINE_LOCK_GUARD_0 (namespace_shared,down_read (&namespace_sem), + up_read(&namespace_sem)) +#ifdef CONFIG_FSNOTIFY LIST_HEAD (notify_list);/* protected by namespace_sem */ #endif
@@ -1776,8 +1782,6 @@ static inline void namespace_lock(void)down_write (&namespace_sem); } -DEFINE_GUARD(namespace_lock, struct rw_semaphore *, namespace_lock(), namespace_unlock()) -enum umount_tree_flags {UMOUNT_SYNC =1 ,UMOUNT_PROPAGATE =2 ,
@@ -2306,7 +2310,7 @@ struct path *collect_paths(const struct path *path,struct path *res = prealloc, *to_free =NULL ;unsigned n =0 ; -guard (rwsem_read)(&namespace_sem); +guard (namespace_shared)();if (!check_mnt (root))return ERR_PTR (-EINVAL );
@@ -2361,7 +2365,7 @@ void dissolve_on_fput(struct vfsmount *mnt)return ; } - scoped_guard(namespace_lock, &namespace_sem) { +scoped_guard (namespace_excl) {if (!anon_ns_root (m))return ;
@@ -2435,7 +2439,7 @@ struct vfsmount *clone_private_mount(const struct path *path)struct mount *old_mnt =real_mount (path->mnt);struct mount *new_mnt; -guard (rwsem_read)(&namespace_sem); +guard (namespace_shared)();if (IS_MNT_UNBINDABLE (old_mnt))return ERR_PTR (-EINVAL );
@@ -5957,7 +5961,7 @@ SYSCALL_DEFINE4(statmount, const struct mnt_id_req __user *, req,if (ret)return ret; -scoped_guard (rwsem_read, &namespace_sem) +scoped_guard (namespace_shared) ret =do_statmount (ks, kreq.mnt_id, kreq.mnt_ns_id, ns);if (!ret)
@@ -6079,7 +6083,7 @@ SYSCALL_DEFINE4(listmount, const struct mnt_id_req __user *, req,* We only need to guard against mount topology changes as * listmount() doesn't care about any mount properties. */ -scoped_guard (rwsem_read, &namespace_sem) +scoped_guard (namespace_shared) ret =do_listmount (ns, kreq.mnt_id, last_mnt_id, kmnt_ids, nr_mnt_ids, (flags &LISTMOUNT_REVERSE ));if (ret <=0 )
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 2/65 introduced guards for mount_lock
mount_writer: write_seqlock; that's an equivalent of {un,}lock_mount_hash()mount_locked_reader: read_seqlock_excl; these tend to be open-coded.
No bulk conversions, please - if nothing else, quite a few places take use mount_writer form when mount_locked_reader is sufficent. It needs to be dealt with carefully.
--- fs/mount.h | 5 +++++ 1 file changed, 5 insertions(+)
fs/mount.h +5 -0
@@ -154,6 +154,11 @@ static inline void get_mnt_ns(struct mnt_namespace *ns)extern seqlock_t mount_lock; +DEFINE_LOCK_GUARD_0 (mount_writer,write_seqlock (&mount_lock), + write_sequnlock(&mount_lock)) +DEFINE_LOCK_GUARD_0 (mount_locked_reader,read_seqlock_excl (&mount_lock), + read_sequnlock_excl(&mount_lock)) +struct proc_mounts {struct mnt_namespace *ns;struct path root;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 3/65 fs/namespace.c: allow to drop vfsmount references via __free(mntput)
In reply to Al ViroNote that just as path_put, it should never be done in scope of namespace_sem, be it shared or exclusive.
--- fs/namespace.c | 2 ++ 1 file changed, 2 insertions(+)
fs/namespace.c +2 -0
@@ -88,6 +88,8 @@ DEFINE_LOCK_GUARD_0(namespace_excl, namespace_lock(), namespace_unlock())DEFINE_LOCK_GUARD_0 (namespace_shared,down_read (&namespace_sem), up_read(&namespace_sem)) +DEFINE_FREE(mntput, struct vfsmount *, if (!IS_ERR(_T)) mntput(_T)) +#ifdef CONFIG_FSNOTIFY LIST_HEAD (notify_list);/* protected by namespace_sem */ #endif
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 4/65 __detach_mounts(): use guards
In reply to Al ViroClean fit for guards use; guards can't be weaker due to umount_tree() calls.
--- fs/namespace.c | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-)
fs/namespace.c +4 -6
@@ -2032,10 +2032,11 @@ void __detach_mounts(struct dentry *dentry)struct pinned_mountpoint mp = {};struct mount *mnt; -namespace_lock (); -lock_mount_hash (); +guard (namespace_excl)(); +guard (mount_writer)(); +if (!lookup_mountpoint (dentry, &mp)) - goto out_unlock; +return ; event++;while (mp.node.next) {
@@ -2047,9 +2048,6 @@ void __detach_mounts(struct dentry *dentry)else umount_tree (mnt,UMOUNT_CONNECTED ); }unpin_mountpoint (&mp); -out_unlock: -unlock_mount_hash (); -namespace_unlock (); }/*
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 5/65 __is_local_mountpoint(): use guards
In reply to Al Viroclean fit; namespace_shared due to iterating through ns->mounts.
--- fs/namespace.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-)
fs/namespace.c +6 -9
@@ -906,17 +906,14 @@ bool __is_local_mountpoint(const struct dentry *dentry) {struct mnt_namespace *ns = current->nsproxy->mnt_ns;struct mount *mnt, *n; -bool is_covered = false; -down_read (&namespace_sem); -rbtree_postorder_for_each_entry_safe (mnt, n, &ns->mounts, mnt_node) { - is_covered = (mnt->mnt_mountpoint == dentry); -if (is_covered) -break ; - } -up_read (&namespace_sem); +guard (namespace_shared)(); + +rbtree_postorder_for_each_entry_safe (mnt, n, &ns->mounts, mnt_node) +if (mnt->mnt_mountpoint == dentry) +return true; -return is_covered; +return false; }struct pinned_mountpoint {
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 6/65 do_change_type(): use guards
In reply to Al Viroclean fit; namespace_excl to modify propagation graph
--- fs/namespace.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-)
fs/namespace.c +6 -7
@@ -2899,7 +2899,7 @@ static int do_change_type(struct path *path, int ms_flags)struct mount *mnt =real_mount (path->mnt);int recurse = ms_flags &MS_REC ;int type; -int err =0 ; +int err;if (!path_mounted (path))return -EINVAL ;
@@ -2908,23 +2908,22 @@ static int do_change_type(struct path *path, int ms_flags)if (!type)return -EINVAL ; -namespace_lock (); +guard (namespace_excl)(); + err =may_change_propagation (mnt);if (err) - goto out_unlock; +return err;if (type ==MS_SHARED ) { err =invent_group_ids (mnt, recurse);if (err) - goto out_unlock; +return err; }for (m = mnt; m; m = (recurse ?next_mnt (m, mnt) :NULL ))change_mnt_propagation (m, type); - out_unlock: -namespace_unlock (); -return err; +return 0 ; }/* may_copy_tree() - check if a mount tree can be copied
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 7/65 do_set_group(): use guards
In reply to Al Viroclean fit; namespace_excl to modify propagation graph
--- fs/namespace.c | 33 +++++++++++++-------------------- 1 file changed, 13 insertions(+), 20 deletions(-)
fs/namespace.c +13 -20
@@ -3349,47 +3349,44 @@ static inline int tree_contains_unbindable(struct mount *mnt)static int do_set_group (struct path *from_path,struct path *to_path) { -struct mount *from, *to; +struct mount *from =real_mount (from_path->mnt); +struct mount *to =real_mount (to_path->mnt);int err; - from =real_mount (from_path->mnt); - to =real_mount (to_path->mnt); - -namespace_lock (); +guard (namespace_excl)(); err =may_change_propagation (from);if (err) - goto out; +return err; err =may_change_propagation (to);if (err) - goto out; +return err; - err = -EINVAL ;/* To and From paths should be mount roots */ if (!path_mounted (from_path)) - goto out; +return -EINVAL ;if (!path_mounted (to_path)) - goto out; +return -EINVAL ;/* Setting sharing groups is only allowed across same superblock */ if (from->mnt.mnt_sb != to->mnt.mnt_sb) - goto out; +return -EINVAL ;/* From mount root should be wider than To mount root */ if (!is_subdir (to->mnt.mnt_root, from->mnt.mnt_root)) - goto out; +return -EINVAL ;/* From mount should not have locked children in place of To's root */ if (__has_locked_children (from, to->mnt.mnt_root)) - goto out; +return -EINVAL ;/* Setting sharing groups is only allowed on private mounts */ if (IS_MNT_SHARED (to) ||IS_MNT_SLAVE (to)) - goto out; +return -EINVAL ;/* From should not be private */ if (!IS_MNT_SHARED (from) && !IS_MNT_SLAVE (from)) - goto out; +return -EINVAL ;if (IS_MNT_SLAVE (from)) {hlist_add_behind (&to->mnt_slave, &from->mnt_slave);
@@ -3401,11 +3398,7 @@ static int do_set_group(struct path *from_path, struct path *to_path)list_add (&to->mnt_share, &from->mnt_share);set_mnt_shared (to); } - - err =0 ; -out: -namespace_unlock (); -return err; +return 0 ; }/**
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 8/65 mark_mounts_for_expiry(): use guards
In reply to Al ViroClean fit; guards can't be weaker due to umount_tree() calls.
--- fs/namespace.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
fs/namespace.c +2 -4
@@ -3886,8 +3886,8 @@ void mark_mounts_for_expiry(struct list_head *mounts)if (list_empty (mounts))return ; -namespace_lock (); -lock_mount_hash (); +guard (namespace_excl)(); +guard (mount_writer)();/* extract from the expiration list every vfsmount that matches the * following criteria:
@@ -3909,8 +3909,6 @@ void mark_mounts_for_expiry(struct list_head *mounts)touch_mnt_namespace (mnt->mnt_ns);umount_tree (mnt,UMOUNT_PROPAGATE |UMOUNT_SYNC ); } -unlock_mount_hash (); -namespace_unlock (); }EXPORT_SYMBOL_GPL (mark_mounts_for_expiry);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 9/65 put_mnt_ns(): use guards
In reply to Al Viroclean fit; guards can't be weaker due to umount_tree() call. Setting emptied_ns requires namespace_excl, but not anything mount_lock-related.
--- fs/namespace.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
fs/namespace.c +2 -4
@@ -6153,12 +6153,10 @@ void put_mnt_ns(struct mnt_namespace *ns) {if (!refcount_dec_and_test (&ns->ns.count))return ; -namespace_lock (); +guard (namespace_excl)(); emptied_ns = ns; -lock_mount_hash (); +guard (mount_writer)();umount_tree (ns->root,0 ); -unlock_mount_hash (); -namespace_unlock (); }struct vfsmount *kern_mount (struct file_system_type *type)
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 10/65 mnt_already_visible(): use guards
In reply to Al Viroclean fit; namespace_shared due to iterating through ns->mounts.
--- fs/namespace.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-)
fs/namespace.c +3 -7
@@ -6232,9 +6232,8 @@ static bool mnt_already_visible(struct mnt_namespace *ns, {int new_flags = *new_mnt_flags;struct mount *mnt, *n; -bool visible = false; -down_read (&namespace_sem); +guard (namespace_shared)();rbtree_postorder_for_each_entry_safe (mnt, n, &ns->mounts, mnt_node) {struct mount *child;int mnt_flags;
@@ -6281,13 +6280,10 @@ static bool mnt_already_visible(struct mnt_namespace *ns,/* Preserve the locked attributes */ *new_mnt_flags |= mnt_flags & (MNT_LOCK_READONLY | \MNT_LOCK_ATIME ); - visible = true; - goto found; +return true; next: ; } -found: -up_read (&namespace_sem); -return visible; +return false; }static bool mount_too_revealing (const struct super_block *sb,int *new_mnt_flags)
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 11/65 check_for_nsfs_mounts(): no need to take locks
In reply to Al ViroCurrently we are taking mount_writer; what that function needs is either mount_locked_reader (we are not changing anything, we just want to iterate through the subtree) or namespace_shared and a reference held by caller on the root of subtree - that's also enough to stabilize the topology.
The thing is, all callers are already holding at least namespace_shared as well as a reference to the root of subtree.
Let's make the callers provide locking warranties - don't mess with mount_lock in check_for_nsfs_mounts() itself and document the locking requirements.
--- fs/namespace.c | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-)
fs/namespace.c +5 -11
@@ -2402,21 +2402,15 @@ bool has_locked_children(struct mount *mnt, struct dentry *dentry)* specified subtree. Such references can act as pins for mount namespaces * that aren't checked by the mount-cycle checking code, thereby allowing * cycles to be made. +* +* locks: mount_locked_reader || namespace_shared && pinned(subtree) */ static bool check_for_nsfs_mounts (struct mount *subtree) { -struct mount *p; -bool ret = false; - -lock_mount_hash (); -for (p = subtree; p; p =next_mnt (p, subtree)) +for (struct mount *p = subtree; p; p =next_mnt (p, subtree))if (mnt_ns_loop (p->mnt.mnt_root)) - goto out; - - ret = true; -out: -unlock_mount_hash (); -return ret; +return false; +return true; }/**
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 12/65 propagate_mnt(): use scoped_guard(mount_locked_reader) for mnt_set_mountpoint()
In reply to Al Viro--- fs/pnode.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
fs/pnode.c +2 -3
@@ -304,9 +304,8 @@ int propagate_mnt(struct mount *dest_mnt, struct mountpoint *dest_mp, err =PTR_ERR (this);break ; } -read_seqlock_excl (&mount_lock); -mnt_set_mountpoint (n, dest_mp, this); -read_sequnlock_excl (&mount_lock); +scoped_guard (mount_locked_reader) +mnt_set_mountpoint (n, dest_mp, this);if (n->mnt_master)SET_MNT_MARK (n->mnt_master); copy = this;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 13/65 has_locked_children(): use guards
In reply to Al Viro... and document the locking requirements of __has_locked_children()
--- fs/namespace.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
fs/namespace.c +3 -6
@@ -2373,6 +2373,7 @@ void dissolve_on_fput(struct vfsmount *mnt) } } +/* locks: namespace_shared && pinned(mnt) || mount_locked_reader */ static bool __has_locked_children (struct mount *mnt,struct dentry *dentry) {struct mount *child;
@@ -2389,12 +2390,8 @@ static bool __has_locked_children(struct mount *mnt, struct dentry *dentry)bool has_locked_children (struct mount *mnt,struct dentry *dentry) { -bool res; - -read_seqlock_excl (&mount_lock); - res =__has_locked_children (mnt, dentry); -read_sequnlock_excl (&mount_lock); -return res; +guard (mount_locked_reader)(); +return __has_locked_children (mnt, dentry); }/*
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 14/65 mnt_set_expiry(): use guards
In reply to Al ViroThe reason why it needs only mount_locked_reader is that there's no lockless accesses of expiry lists.
--- fs/namespace.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/namespace.c +1 -2
@@ -3858,9 +3858,8 @@ int finish_automount(struct vfsmount *m, const struct path *path)*/ void mnt_set_expiry (struct vfsmount *mnt,struct list_head *expiry_list) { -read_seqlock_excl (&mount_lock); +guard (mount_locked_reader)();list_add_tail (&real_mount (mnt)->mnt_expire, expiry_list); -read_sequnlock_excl (&mount_lock); }EXPORT_SYMBOL (mnt_set_expiry);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 15/65 path_is_under(): use guards
In reply to Al Viro... and document that locking requirements for is_path_reachable(). There is one questionable caller in do_listmount() where we are not holding mount_lock *and* might not have the first argument mounted. However, in that case it will immediately return true without having to look at the ancestors. Might be cleaner to move the check into non-LSTM_ROOT case which it really belongs in - there the check is not always true and is_mounted() is guaranteed.
Document the locking environments for is_path_reachable() callers:
get_peer_under_root()
get_dominating_id()
do_statmount()
do_listmount()
--- fs/namespace.c | 11 +++++------ fs/pnode.c | 3 ++- 2 files changed, 7 insertions(+), 7 deletions(-)
fs/namespace.c +5 -6
@@ -4592,7 +4592,7 @@ SYSCALL_DEFINE5(move_mount,/* * Return true if path is reachable from root * -* namespace_sem or mount_lock is held +* locks: mount_locked_reader || namespace_shared && is_mounted(mnt) */ bool is_path_reachable (struct mount *mnt,struct dentry *dentry,const struct path *root)
@@ -4606,11 +4606,8 @@ bool is_path_reachable(struct mount *mnt, struct dentry *dentry,bool path_is_under (const struct path *path1,const struct path *path2) { -bool res; -read_seqlock_excl (&mount_lock); - res =is_path_reachable (real_mount (path1->mnt), path1->dentry, path2); -read_sequnlock_excl (&mount_lock); -return res; +guard (mount_locked_reader)(); +return is_path_reachable (real_mount (path1->mnt), path1->dentry, path2); }EXPORT_SYMBOL (path_is_under);
@@ -5689,6 +5686,7 @@ static int grab_requested_root(struct mnt_namespace *ns, struct path *root) STATMOUNT_MNT_UIDMAP | \ STATMOUNT_MNT_GIDMAP) +/* locks: namespace_shared */ static int do_statmount (struct kstatmount *s,u64 mnt_id,u64 mnt_ns_id,struct mnt_namespace *ns) {
@@ -5949,6 +5947,7 @@ SYSCALL_DEFINE4(statmount, const struct mnt_id_req __user *, req,return ret; } +/* locks: namespace_shared */ static ssize_t do_listmount (struct mnt_namespace *ns,u64 mnt_parent_id,u64 last_mnt_id,u64 *mnt_ids,size_t nr_mnt_ids,bool reverse)
fs/pnode.c +2 -1
@@ -29,6 +29,7 @@ static inline struct mount *next_slave(struct mount *p) return hlist_entry(p->mnt_slave.next, struct mount, mnt_slave); } +/* locks: namespace_shared && is_mounted(mnt) */ static struct mount *get_peer_under_root (struct mount *mnt,struct mnt_namespace *ns,const struct path *root)
@@ -50,7 +51,7 @@ static struct mount *get_peer_under_root(struct mount *mnt,* Get ID of closest dominating peer group having a representative * under the given root. * -* Caller must hold namespace_sem +* locks: namespace_shared */ int get_dominating_id (struct mount *mnt,const struct path *root) {
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 16/65 current_chrooted(): don't bother with follow_down_one()
In reply to Al ViroAll we need here is to follow ->overmount on root mount of namespace...
--- fs/namespace.c | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-)
fs/namespace.c +8 -10
@@ -6194,24 +6194,22 @@ bool our_mnt(struct vfsmount *mnt)bool current_chrooted (void ) {/* Does the current process have a non-standard root */ -struct path ns_root; +struct mount *root = current->nsproxy->mnt_ns->root;struct path fs_root;bool chrooted; +get_fs_root (current->fs, &fs_root); +/* Find the namespace root */ - ns_root.mnt = ¤t->nsproxy->mnt_ns->root->mnt; - ns_root.dentry = ns_root.mnt->mnt_root; -path_get (&ns_root); -while (d_mountpoint (ns_root.dentry) &&follow_down_one (&ns_root)) - ; +read_seqlock_excl (&mount_lock); -get_fs_root (current->fs, &fs_root); +while (unlikely (root->overmount)) + root = root->overmount; - chrooted = !path_equal (&fs_root, &ns_root); + chrooted = fs_root.mnt != &root->mnt || !path_mounted (&fs_root); +read_sequnlock_excl (&mount_lock);path_put (&fs_root); -path_put (&ns_root); -return chrooted; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 17/65 current_chrooted(): use guards
In reply to Al Virohere a use of __free(path_put) for dropping fs_root is enough to make guard(mount_locked_reader) fit...
--- fs/namespace.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-)
fs/namespace.c +6 -9
@@ -6194,23 +6194,20 @@ bool our_mnt(struct vfsmount *mnt)bool current_chrooted (void ) {/* Does the current process have a non-standard root */ -struct mount *root = current->nsproxy->mnt_ns->root; -struct path fs_root; -bool chrooted; + struct path fs_root __free(path_put) = {}; +struct mount *root;get_fs_root (current->fs, &fs_root);/* Find the namespace root */ -read_seqlock_excl (&mount_lock); +guard (mount_locked_reader)(); + + root = current->nsproxy->mnt_ns->root;while (unlikely (root->overmount)) root = root->overmount; - chrooted = fs_root.mnt != &root->mnt || !path_mounted (&fs_root); - -read_sequnlock_excl (&mount_lock); -path_put (&fs_root); -return chrooted; +return fs_root.mnt != &root->mnt || !path_mounted (&fs_root); } static bool mnt_already_visible(struct mnt_namespace *ns,
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 18/65 switch do_new_mount_fc() to fc_mount()
In reply to Al ViroPrior to the call of do_new_mount_fc() the caller has just done successful vfs_get_tree(). Then do_new_mount_fc() does several checks on resulting superblock, and either does fc_drop_locked() and returns an error or proceeds to unlock the superblock and call vfs_create_mount().
The thing is, there's no reason to delay that unlock + vfs_create_mount() - the tests do not rely upon the state of ->s_umount and
fc_drop_locked()
put_fs_context()
is equivalent to
unlock ->s_umount put_fs_context()
Doing vfs_create_mount() before the checks allows us to move vfs_get_tree() from caller to do_new_mount_fc() and collapse it with vfs_create_mount() into an fc_mount() call.
--- fs/namespace.c | 29 ++++++++++++----------------- 1 file changed, 12 insertions(+), 17 deletions(-)
fs/namespace.c +12 -17
@@ -3705,25 +3705,20 @@ static bool mount_too_revealing(const struct super_block *sb, int *new_mnt_flagsstatic int do_new_mount_fc (struct fs_context *fc,struct path *mountpoint,unsigned int mnt_flags) { -struct vfsmount *mnt;struct pinned_mountpoint mp = {}; -struct super_block *sb = fc->root->d_sb; +struct super_block *sb; +struct vfsmount *mnt =fc_mount (fc);int error; +if (IS_ERR (mnt)) +return PTR_ERR (mnt); + + sb = fc->root->d_sb; error =security_sb_kern_mount (sb);if (!error &&mount_too_revealing (sb, &mnt_flags)) error = -EPERM ; - -if (unlikely (error)) { -fc_drop_locked (fc); -return error; - } - -up_write (&sb->s_umount); - - mnt =vfs_create_mount (fc); -if (IS_ERR (mnt)) -return PTR_ERR (mnt); +if (unlikely (error)) + goto out;mnt_warn_timestamp_expiry (mountpoint, mnt);
@@ -3731,10 +3726,12 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint,if (!error) { error =do_add_mount (real_mount (mnt), mp.mp, mountpoint, mnt_flags); +if (!error) + mnt =NULL ;// consumed on success unlock_mount (&mp); } -if (error <0 ) -mntput (mnt); +out: +mntput (mnt);return error; }
@@ -3788,8 +3785,6 @@ static int do_new_mount(struct path *path, const char *fstype, int sb_flags, err =parse_monolithic_mount_data (fc, data);if (!err && !mount_capable (fc)) err = -EPERM ; -if (!err) - err =vfs_get_tree (fc);if (!err) err =do_new_mount_fc (fc, path, mnt_flags);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 19/65 do_move_mount(): trim local variables
In reply to Al ViroBoth 'parent' and 'ns' are used at most once, no point precalculating those...
--- fs/namespace.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
fs/namespace.c +4 -8
@@ -3564,10 +3564,8 @@ static inline bool may_use_mount(struct mount *mnt)static int do_move_mount (struct path *old_path,struct path *new_path,enum mnt_tree_flags_t flags) { -struct mnt_namespace *ns;struct mount *p;struct mount *old; -struct mount *parent;struct pinned_mountpoint mp;int err;bool beneath = flags &MNT_TREE_BENEATH ;
@@ -3578,8 +3576,6 @@ static int do_move_mount(struct path *old_path, old =real_mount (old_path->mnt); p =real_mount (new_path->mnt); - parent = old->mnt_parent; - ns = old->mnt_ns; err = -EINVAL ;
@@ -3588,12 +3584,12 @@ static int do_move_mount(struct path *old_path,/* ... it should be detachable from parent */ if (!mnt_has_parent (old) ||IS_MNT_LOCKED (old)) goto out; +/* ... which should not be shared */ +if (IS_MNT_SHARED (old->mnt_parent)) + goto out;/* ... and the target should be in our namespace */ if (!check_mnt (p)) goto out; -/* parent of the source should not be shared */ -if (IS_MNT_SHARED (parent)) - goto out; }else {/* * otherwise the source must be the root of some anon namespace.
@@ -3605,7 +3601,7 @@ static int do_move_mount(struct path *old_path,* subsequent checks would've rejected that, but they lose * some corner cases if we check it early. */ -if (ns == p->mnt_ns) +if (old->mnt_ns == p->mnt_ns) goto out;/* * Target should be either in our namespace or in an acceptable
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 20/65 do_move_mount(): deal with the checks on old_path early
In reply to Al Viro1) checking that location we want to move does point to root of some mount can be done before anything else; that property is not going to change and having it already verified simplifies the analysis.
2) checking the type agreement between what we are trying to move and what we are trying to move it onto also belongs in the very beginning - do_lock_mount() might end up switching new_path to something that overmounts the original location, but... the same type agreement applies to overmounts, so we could just as well check against the original location.
3) since we know that old_path->dentry is the root of old_path->mnt, there's no point bothering with path_is_overmounted() in can_move_mount_beneath(); it's simply a check for the mount we are trying to move having non-NULL ->overmount. And with that, we can switch can_move_mount_beneath() to taking old instead of old_path, leaving no uses of old_path past the original checks.
--- fs/namespace.c | 29 +++++++++++++---------------- 1 file changed, 13 insertions(+), 16 deletions(-)
fs/namespace.c +13 -16
@@ -3433,7 +3433,7 @@ static bool mount_is_ancestor(const struct mount *p1, const struct mount *p2)/** * can_move_mount_beneath - check that we can mount beneath the top mount -* @from: mount to mount beneath +* @mnt_from: mount we are trying to move * @to: mount under which to mount * @mp: mountpoint of @to *
@@ -3443,7 +3443,7 @@ static bool mount_is_ancestor(const struct mount *p1, const struct mount *p2)* root or the rootfs of the namespace. * - Make sure that the caller can unmount the topmost mount ensuring * that the caller could reveal the underlying mountpoint. -* - Ensure that nothing has been mounted on top of @from before we +* - Ensure that nothing has been mounted on top of @mnt_from before we * grabbed @namespace_sem to avoid creating pointless shadow mounts. * - Prevent mounting beneath a mount if the propagation relationship * between the source mount, parent mount, and top mount would lead to
@@ -3452,12 +3452,11 @@ static bool mount_is_ancestor(const struct mount *p1, const struct mount *p2)* Context: This function expects namespace_lock() to be held. * Return: On success 0, and on error a negative error code is returned. */ -static int can_move_mount_beneath (const struct path *from, +static int can_move_mount_beneath (struct mount *mnt_from,const struct path *to,const struct mountpoint *mp) { -struct mount *mnt_from =real_mount (from->mnt), - *mnt_to =real_mount (to->mnt), +struct mount *mnt_to =real_mount (to->mnt), *parent_mnt_to = mnt_to->mnt_parent;if (!mnt_has_parent (mnt_to))
@@ -3470,7 +3469,7 @@ static int can_move_mount_beneath(const struct path *from,return -EINVAL ;/* Avoid creating shadow mounts during mount propagation. */ -if (path_overmounted (from)) +if (mnt_from->overmount)return -EINVAL ;/*
@@ -3565,16 +3564,21 @@ static int do_move_mount(struct path *old_path, struct path *new_path, enum mnt_tree_flags_t flags) { struct mount *p; -struct mount *old; +struct mount *old =real_mount (old_path->mnt);struct pinned_mountpoint mp;int err;bool beneath = flags &MNT_TREE_BENEATH ; +if (!path_mounted (old_path)) +return -EINVAL ; + +if (d_is_dir (new_path->dentry) !=d_is_dir (old_path->dentry)) +return -EINVAL ; + err =do_lock_mount (new_path, &mp, beneath);if (err)return err; - old =real_mount (old_path->mnt); p =real_mount (new_path->mnt); err = -EINVAL ;
@@ -3611,15 +3615,8 @@ static int do_move_mount(struct path *old_path, goto out; } -if (!path_mounted (old_path)) - goto out; - -if (d_is_dir (new_path->dentry) != -d_is_dir (old_path->dentry)) - goto out; -if (beneath) { - err =can_move_mount_beneath (old_path, new_path, mp.mp); + err =can_move_mount_beneath (old, new_path, mp.mp);if (err) goto out;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 21/65 move_mount(2): take sanity checks in 'beneath' case into do_lock_mount()
In reply to Al ViroWe want to mount beneath the given location. For that operation to make sense, location must be the root of some mount that has something under it. Currently we let it proceed if those requirements are not met, with rather meaningless results, and have that bogosity caught further down the road; let's fail early instead - do_lock_mount() doesn't make sense unless those conditions hold, and checking them there makes things simpler.
--- fs/namespace.c | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-)
fs/namespace.c +7 -8
@@ -2768,12 +2768,19 @@ static int do_lock_mount(struct path *path, struct pinned_mountpoint *pinned, bostruct path under = {};int err = -ENOENT ; +if (unlikely (beneath) && !path_mounted (path)) +return -EINVAL ; +for (;;) {struct mount *m =real_mount (mnt);if (beneath) {path_put (&under);read_seqlock_excl (&mount_lock); +if (unlikely (!mnt_has_parent (m))) { +read_sequnlock_excl (&mount_lock); +return -EINVAL ; + } under.mnt =mntget (&m->mnt_parent->mnt); under.dentry =dget (m->mnt_mountpoint);read_sequnlock_excl (&mount_lock);
@@ -3437,8 +3444,6 @@ static bool mount_is_ancestor(const struct mount *p1, const struct mount *p2)* @to: mount under which to mount * @mp: mountpoint of @to * -* - Make sure that @to->dentry is actually the root of a mount under -* which we can mount another mount. * - Make sure that nothing can be mounted beneath the caller's current * root or the rootfs of the namespace. * - Make sure that the caller can unmount the topmost mount ensuring
@@ -3459,12 +3464,6 @@ static int can_move_mount_beneath(struct mount *mnt_from,struct mount *mnt_to =real_mount (to->mnt), *parent_mnt_to = mnt_to->mnt_parent; -if (!mnt_has_parent (mnt_to)) -return -EINVAL ; - -if (!path_mounted (to)) -return -EINVAL ; -if (IS_MNT_LOCKED (mnt_to))return -EINVAL ;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 22/65 finish_automount(): simplify the ELOOP check
In reply to Al ViroIt's enough to check that dentries match; if path->dentry is equal to m->mnt_root, superblocks will match as well.
--- fs/namespace.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/namespace.c +1 -2
@@ -3798,8 +3798,7 @@ int finish_automount(struct vfsmount *m, const struct path *path) mnt =real_mount (m); -if (m->mnt_sb == path->mnt->mnt_sb && - m->mnt_root == dentry) { +if (m->mnt_root == path->dentry) { err = -ELOOP ; goto discard; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 23/65 do_loopback(): use __free(path_put) to deal with old_path
In reply to Al Viropreparations for making unlock_mount() a __cleanup(); can't have path_put() inside mount_lock scope.
--- fs/namespace.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
fs/namespace.c +3 -6
@@ -3014,7 +3014,7 @@ static struct mount *__do_loopback(struct path *old_path, int recurse)static int do_loopback (struct path *path,const char *old_name,int recurse) { -struct path old_path; + struct path old_path __free(path_put) = {};struct mount *mnt =NULL , *parent;struct pinned_mountpoint mp = {};int err;
@@ -3024,13 +3024,12 @@ static int do_loopback(struct path *path, const char *old_name,if (err)return err; - err = -EINVAL ;if (mnt_ns_loop (old_path.dentry)) - goto out; +return -EINVAL ; err =lock_mount (path, &mp);if (err) - goto out; +return err; parent =real_mount (path->mnt);if (!check_mnt (parent))
@@ -3050,8 +3049,6 @@ static int do_loopback(struct path *path, const char *old_name, } out2:unlock_mount (&mp); -out: -path_put (&old_path);return err; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 24/65 pivot_root(2): use __free() to deal with struct path in it
In reply to Al Viropreparations for making unlock_mount() a __cleanup(); can't have path_put() inside mount_lock scope.
--- fs/namespace.c | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-)
fs/namespace.c +7 -12
@@ -4622,7 +4622,9 @@ EXPORT_SYMBOL(path_is_under); SYSCALL_DEFINE2(pivot_root, const char __user *, new_root, const char __user *, put_old) { -struct path new, old, root; + struct path new __free(path_put) = {}; + struct path old __free(path_put) = {}; + struct path root __free(path_put) = {};struct mount *new_mnt, *root_mnt, *old_mnt, *root_parent, *ex_parent;struct pinned_mountpoint old_mp = {};int error;
@@ -4633,21 +4635,21 @@ SYSCALL_DEFINE2(pivot_root, const char __user *, new_root, error =user_path_at (AT_FDCWD , new_root,LOOKUP_FOLLOW |LOOKUP_DIRECTORY , &new);if (error) - goto out0; +return error; error =user_path_at (AT_FDCWD , put_old,LOOKUP_FOLLOW |LOOKUP_DIRECTORY , &old);if (error) - goto out1; +return error; error =security_sb_pivotroot (&old, &new);if (error) - goto out2; +return error;get_fs_root (current->fs, &root); error =lock_mount (&old, &old_mp);if (error) - goto out3; +return error; error = -EINVAL ; new_mnt =real_mount (new.mnt);
@@ -4705,13 +4707,6 @@ SYSCALL_DEFINE2(pivot_root, const char __user *, new_root, error =0 ; out4:unlock_mount (&old_mp); -out3: -path_put (&root); -out2: -path_put (&old); -out1: -path_put (&new); -out0:return error; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 25/65 finish_automount(): take the lock_mount() analogue into a helper
In reply to Al Virofinish_automount() can't use lock_mount() - it treats finding something already mounted as "quitely drop our mount and return 0", not as "mount on top of whatever mounted there". It's been open-coded; let's take it into a helper similar to lock_mount(). "something's already mounted" => -EBUSY, finish_automount() needs to distinguish it from the normal case and it can't happen in other failure cases.
--- fs/namespace.c | 42 +++++++++++++++++++++++++----------------- 1 file changed, 25 insertions(+), 17 deletions(-)
fs/namespace.c +25 -17
@@ -3781,9 +3781,29 @@ static int do_new_mount(struct path *path, const char *fstype, int sb_flags,return err; } -int finish_automount (struct vfsmount *m,const struct path *path) +static int lock_mount_exact (const struct path *path, +struct pinned_mountpoint *mp) {struct dentry *dentry = path->dentry; +int err; + +inode_lock (dentry->d_inode); +namespace_lock (); +if (unlikely (cant_mount (dentry))) + err = -ENOENT ; +else if (path_overmounted (path)) + err = -EBUSY ; +else + err =get_mountpoint (dentry, mp); +if (unlikely (err)) { +namespace_unlock (); +inode_unlock (dentry->d_inode); + } +return err; +} + +int finish_automount (struct vfsmount *m,const struct path *path) +{struct pinned_mountpoint mp = {};struct mount *mnt;int err;
@@ -3805,20 +3825,11 @@ int finish_automount(struct vfsmount *m, const struct path *path)* that overmounts our mountpoint to be means "quitely drop what we've * got", not "try to mount it on top". */ -inode_lock (dentry->d_inode); -namespace_lock (); -if (unlikely (cant_mount (dentry))) { - err = -ENOENT ; - goto discard_locked; - } -if (path_overmounted (path)) { - err =0 ; - goto discard_locked; + err =lock_mount_exact (path, &mp); +if (unlikely (err)) { +mntput (m); +return err == -EBUSY ?0 : err; } - err =get_mountpoint (dentry, &mp); -if (err) - goto discard_locked; - err =do_add_mount (mnt, mp.mp, path, path->mnt->mnt_flags |MNT_SHRINKABLE );unlock_mount (&mp);
@@ -3826,9 +3837,6 @@ int finish_automount(struct vfsmount *m, const struct path *path) goto discard;return 0 ; -discard_locked: -namespace_unlock (); -inode_unlock (dentry->d_inode); discard:mntput (m);return err;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 26/65 do_new_mount_fc(): use __free() to deal with dropping mnt on failure
In reply to Al Virodo_add_mount() consumes vfsmount on success; just follow it with conditional retain_and_null_ptr() on success and we can switch to __free() for mnt and be done with that - unlock_mount() is in the very end.
--- fs/namespace.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-)
fs/namespace.c +6 -7
@@ -3696,7 +3696,7 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint, {struct pinned_mountpoint mp = {};struct super_block *sb; -struct vfsmount *mnt =fc_mount (fc); + struct vfsmount *mnt __free(mntput) = fc_mount(fc);int error;if (IS_ERR (mnt))
@@ -3704,10 +3704,11 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint, sb = fc->root->d_sb; error =security_sb_kern_mount (sb); -if (!error &&mount_too_revealing (sb, &mnt_flags)) - error = -EPERM ;if (unlikely (error)) - goto out; +return error; + +if (unlikely (mount_too_revealing (sb, &mnt_flags))) +return -EPERM ;mnt_warn_timestamp_expiry (mountpoint, mnt);
@@ -3716,11 +3717,9 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint, error =do_add_mount (real_mount (mnt), mp.mp, mountpoint, mnt_flags);if (!error) - mnt =NULL ;// consumed on success +retain_and_null_ptr (mnt);// consumed on success unlock_mount (&mp); } -out: -mntput (mnt);return error; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 26/63 do_new_mount_rc(): use __free() to deal with dropping mnt on failure
In reply to Al Virodo_add_mount() consumes vfsmount on success; just follow it with conditional retain_and_null_ptr() on success and we can switch to __free() for mnt and be done with that - unlock_mount() is in the very end.
--- fs/namespace.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-)
fs/namespace.c +6 -7
@@ -3696,7 +3696,7 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint, {struct pinned_mountpoint mp = {};struct super_block *sb; -struct vfsmount *mnt =fc_mount (fc); + struct vfsmount *mnt __free(mntput) = fc_mount(fc);int error;if (IS_ERR (mnt))
@@ -3704,10 +3704,11 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint, sb = fc->root->d_sb; error =security_sb_kern_mount (sb); -if (!error &&mount_too_revealing (sb, &mnt_flags)) - error = -EPERM ;if (unlikely (error)) - goto out; +return error; + +if (unlikely (mount_too_revealing (sb, &mnt_flags))) +return -EPERM ;mnt_warn_timestamp_expiry (mountpoint, mnt);
@@ -3716,11 +3717,9 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint, error =do_add_mount (real_mount (mnt), mp.mp, mountpoint, mnt_flags);if (!error) - mnt =NULL ;// consumed on success +retain_and_null_ptr (mnt);// consumed on success unlock_mount (&mp); } -out: -mntput (mnt);return error; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 27/65 finish_automount(): use __free() to deal with dropping mnt on failure
In reply to Al Virosame story as with do_new_mount_fc().
--- fs/namespace.c | 22 ++++++++-------------- 1 file changed, 8 insertions(+), 14 deletions(-)
fs/namespace.c +8 -14
@@ -3801,8 +3801,9 @@ static int lock_mount_exact(const struct path *path,return err; } -int finish_automount (struct vfsmount *m,const struct path *path) +int finish_automount (struct vfsmount *__m,const struct path *path) { + struct vfsmount *m __free(mntput) = __m;struct pinned_mountpoint mp = {};struct mount *mnt;int err;
@@ -3814,10 +3815,8 @@ int finish_automount(struct vfsmount *m, const struct path *path) mnt =real_mount (m); -if (m->mnt_root == path->dentry) { - err = -ELOOP ; - goto discard; - } +if (m->mnt_root == path->dentry) +return -ELOOP ;/* * we don't want to use lock_mount() - in this case finding something
@@ -3825,19 +3824,14 @@ int finish_automount(struct vfsmount *m, const struct path *path)* got", not "try to mount it on top". */ err =lock_mount_exact (path, &mp); -if (unlikely (err)) { -mntput (m); +if (unlikely (err))return err == -EBUSY ?0 : err; - } + err =do_add_mount (mnt, mp.mp, path, path->mnt->mnt_flags |MNT_SHRINKABLE ); +if (likely (!err)) +retain_and_null_ptr (m);unlock_mount (&mp); -if (unlikely (err)) - goto discard; -return 0 ; - -discard: -mntput (m);return err; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 28/65 change calling conventions for lock_mount() et.al.
In reply to Al Viro1) pinned_mountpoint gets a new member - struct mount *parent. Set only if we locked the sucker; ERR_PTR() - on failed attempt.
2) do_lock_mount() et.al. return void and set ->parent to
* on success with !beneath - mount corresponding to path->mnt
* on success with beneath - the parent of mount corresponding
to path->mnt
* in case of error - ERR_PTR(-E...).
IOW, we get the mount we will be actually mounting upon or ERR_PTR().
3) we can't use CLASS, since the pinned_mountpoint is placed on hlist during initialization, so we define local macros:
LOCK_MOUNT(mp, path) LOCK_MOUNT_MAYBE_BENEATH(mp, path, beneath) LOCK_MOUNT_EXACT(mp, path)
All of them declare and initialize struct pinned_mountpoint mp, with unlock_mount done via __cleanup().
Users converted.
--- fs/namespace.c | 219 ++++++++++++++++++++++++------------------------- 1 file changed, 108 insertions(+), 111 deletions(-)
fs/namespace.c +108 -111
@@ -919,6 +919,7 @@ bool __is_local_mountpoint(const struct dentry *dentry)struct pinned_mountpoint {struct hlist_node node;struct mountpoint *mp; +struct mount *parent; };static bool lookup_mountpoint (struct dentry *dentry,struct pinned_mountpoint *m)
@@ -2728,48 +2729,47 @@ static int attach_recursive_mnt(struct mount *source_mnt, }/** -* do_lock_mount - lock mount and mountpoint -* @path: target path -* @beneath: whether the intention is to mount beneath @path +* do_lock_mount - acquire environment for mounting +* @path: target path +* @res: context to set up +* @beneath: whether the intention is to mount beneath @path * -* Follow the mount stack on @path until the top mount @mnt is found. If -* the initial @path->{mnt,dentry} is a mountpoint lookup the first -* mount stacked on top of it. Then simply follow @{mnt,mnt->mnt_root} -* until nothing is stacked on top of it anymore. +* To mount something at given location, we need +* namespace_sem locked exclusive +* inode of dentry we are mounting on locked exclusive +* struct mountpoint for that dentry +* struct mount we are mounting on * -* Acquire the inode_lock() on the top mount's ->mnt_root to protect -* against concurrent removal of the new mountpoint from another mount -* namespace. +* Results are stored in caller-supplied context (pinned_mountpoint); +* on success we have res->parent and res->mp pointing to parent and +* mountpoint respectively and res->node inserted into the ->m_list +* of the mountpoint, making sure the mountpoint won't disappear. +* On failure we have res->parent set to ERR_PTR(-E...), res->mp +* left NULL, res->node - empty. +* In case of success do_lock_mount returns with locks acquired (in +* proper order - inode lock nests outside of namespace_sem). * -* If @beneath is requested, acquire inode_lock() on @mnt's mountpoint -* @mp on @mnt->mnt_parent must be acquired. This protects against a -* concurrent unlink of @mp->mnt_dentry from another mount namespace -* where @mnt doesn't have a child mount mounted @mp. A concurrent -* removal of @mnt->mnt_root doesn't matter as nothing will be mounted -* on top of it for @beneath. +* Request to mount on overmounted location is treated as "mount on +* top of whatever's overmounting it"; request to mount beneath +* a location - "mount immediately beneath the topmost mount at that +* place". * -* In addition, @beneath needs to make sure that @mnt hasn't been -* unmounted or moved from its current mountpoint in between dropping -* @mount_lock and acquiring @namespace_sem. For the !@beneath case @mnt -* being unmounted would be detected later by e.g., calling -* check_mnt(mnt) in the function it's called from. For the @beneath -* case however, it's useful to detect it directly in do_lock_mount(). -* If @mnt hasn't been unmounted then @mnt->mnt_mountpoint still points -* to @mnt->mnt_mp->m_dentry. But if @mnt has been unmounted it will -* point to @mnt->mnt_root and @mnt->mnt_mp will be NULL. -* -* Return: Either the target mountpoint on the top mount or the top -* mount's mountpoint. +* In all cases the location must not have been unmounted and the +* chosen mountpoint must be allowed to be mounted on. For "beneath" +* case we also require the location to be at the root of a mount +* that has a parent (i.e. is not a root of some namespace). */ -static int do_lock_mount (struct path *path,struct pinned_mountpoint *pinned,bool beneath) +static void do_lock_mount (struct path *path,struct pinned_mountpoint *res,bool beneath) {struct vfsmount *mnt = path->mnt;struct dentry *dentry;struct path under = {};int err = -ENOENT ; -if (unlikely (beneath) && !path_mounted (path)) -return -EINVAL ; +if (unlikely (beneath) && !path_mounted (path)) { + res->parent =ERR_PTR (-EINVAL ); +return ; + }for (;;) {struct mount *m =real_mount (mnt);
@@ -2779,7 +2779,8 @@ static int do_lock_mount(struct path *path, struct pinned_mountpoint *pinned, boread_seqlock_excl (&mount_lock);if (unlikely (!mnt_has_parent (m))) {read_sequnlock_excl (&mount_lock); -return -EINVAL ; + res->parent =ERR_PTR (-EINVAL ); +return ; } under.mnt =mntget (&m->mnt_parent->mnt); under.dentry =dget (m->mnt_mountpoint);
@@ -2811,7 +2812,7 @@ static int do_lock_mount(struct path *path, struct pinned_mountpoint *pinned, bo path->dentry =dget (mnt->mnt_root);continue ;// got overmounted } - err =get_mountpoint (dentry, pinned); + err =get_mountpoint (dentry, res);if (err)break ;if (beneath) {
@@ -2822,22 +2823,25 @@ static int do_lock_mount(struct path *path, struct pinned_mountpoint *pinned, bo* we are not dropping the final references here). */ path_put (&under); + res->parent =real_mount (path->mnt)->mnt_parent; +return ; } -return 0 ; + res->parent =real_mount (path->mnt); +return ; }namespace_unlock ();inode_unlock (dentry->d_inode);if (beneath)path_put (&under); -return err; + res->parent =ERR_PTR (err); } -static inline int lock_mount (struct path *path,struct pinned_mountpoint *m) +static inline void lock_mount (struct path *path,struct pinned_mountpoint *m) { -return do_lock_mount (path, m, false); +do_lock_mount (path, m, false); } -static void unlock_mount (struct pinned_mountpoint *m) +static void __unlock_mount (struct pinned_mountpoint *m) {inode_unlock (m->mp->m_dentry->d_inode);read_seqlock_excl (&mount_lock);
@@ -2846,6 +2850,20 @@ static void unlock_mount(struct pinned_mountpoint *m)namespace_unlock (); } +static inline void unlock_mount (struct pinned_mountpoint *m) +{ +if (!IS_ERR (m->parent)) +__unlock_mount (m); +} + +#define LOCK_MOUNT_MAYBE_BENEATH (mp, path, beneath) \ + struct pinned_mountpoint mp __cleanup(unlock_mount) = {}; \ + do_lock_mount((path), &mp, (beneath)) +#define LOCK_MOUNT (mp, path) LOCK_MOUNT_MAYBE_BENEATH(mp, (path), false) +#define LOCK_MOUNT_EXACT (mp, path) \ + struct pinned_mountpoint mp __cleanup(unlock_mount) = {}; \ + lock_mount_exact((path), &mp) +static int graft_tree (struct mount *mnt,struct mount *p,struct mountpoint *mp) {if (mnt->mnt.mnt_sb->s_flags &SB_NOUSER )
@@ -3015,8 +3033,7 @@ static int do_loopback(struct path *path, const char *old_name, int recurse) { struct path old_path __free(path_put) = {}; -struct mount *mnt =NULL , *parent; -struct pinned_mountpoint mp = {}; +struct mount *mnt =NULL ;int err;if (!old_name || !*old_name)return -EINVAL ;
@@ -3027,28 +3044,23 @@ static int do_loopback(struct path *path, const char *old_name,if (mnt_ns_loop (old_path.dentry))return -EINVAL ; - err =lock_mount (path, &mp); -if (err) -return err; +LOCK_MOUNT (mp, path); +if (IS_ERR (mp.parent)) +return PTR_ERR (mp.parent); - parent =real_mount (path->mnt); -if (!check_mnt (parent)) - goto out2; +if (!check_mnt (mp.parent)) +return -EINVAL ; mnt =__do_loopback (&old_path, recurse); -if (IS_ERR (mnt)) { - err =PTR_ERR (mnt); - goto out2; - } +if (IS_ERR (mnt)) +return PTR_ERR (mnt); - err =graft_tree (mnt, parent, mp.mp); + err =graft_tree (mnt, mp.parent, mp.mp);if (err) {lock_mount_hash ();umount_tree (mnt,UMOUNT_SYNC );unlock_mount_hash (); } -out2: -unlock_mount (&mp);return err; }
@@ -3561,7 +3573,6 @@ static int do_move_mount(struct path *old_path, {struct mount *p;struct mount *old =real_mount (old_path->mnt); -struct pinned_mountpoint mp;int err;bool beneath = flags &MNT_TREE_BENEATH ;
@@ -3571,52 +3582,49 @@ static int do_move_mount(struct path *old_path,if (d_is_dir (new_path->dentry) !=d_is_dir (old_path->dentry))return -EINVAL ; - err =do_lock_mount (new_path, &mp, beneath); -if (err) -return err; +LOCK_MOUNT_MAYBE_BENEATH (mp, new_path, beneath); +if (IS_ERR (mp.parent)) +return PTR_ERR (mp.parent); p =real_mount (new_path->mnt); - err = -EINVAL ; -if (check_mnt (old)) {/* if the source is in our namespace... */ /* ... it should be detachable from parent */ if (!mnt_has_parent (old) ||IS_MNT_LOCKED (old)) - goto out; +return -EINVAL ;/* ... which should not be shared */ if (IS_MNT_SHARED (old->mnt_parent)) - goto out; +return -EINVAL ;/* ... and the target should be in our namespace */ if (!check_mnt (p)) - goto out; +return -EINVAL ; }else {/* * otherwise the source must be the root of some anon namespace. */ if (!anon_ns_root (old)) - goto out; +return -EINVAL ;/* * Bail out early if the target is within the same namespace - * subsequent checks would've rejected that, but they lose * some corner cases if we check it early. */ if (old->mnt_ns == p->mnt_ns) - goto out; +return -EINVAL ;/* * Target should be either in our namespace or in an acceptable * anon namespace, sensu check_anonymous_mnt(). */ if (!may_use_mount (p)) - goto out; +return -EINVAL ; }if (beneath) { err =can_move_mount_beneath (old, new_path, mp.mp);if (err) - goto out; +return err; - err = -EINVAL ; p = p->mnt_parent; }
@@ -3625,17 +3633,13 @@ static int do_move_mount(struct path *old_path,* mount which is shared. */ if (IS_MNT_SHARED (p) &&tree_contains_unbindable (old)) - goto out; - err = -ELOOP ; +return -EINVAL ;if (!check_for_nsfs_mounts (old)) - goto out; +return -ELOOP ;if (mount_is_ancestor (old, p)) - goto out; +return -ELOOP ; - err =attach_recursive_mnt (old, p, mp.mp); -out: -unlock_mount (&mp); -return err; +return attach_recursive_mnt (old, p, mp.mp); }static int do_move_mount_old (struct path *path,const char *old_name)
@@ -3694,7 +3698,6 @@ static bool mount_too_revealing(const struct super_block *sb, int *new_mnt_flagsstatic int do_new_mount_fc (struct fs_context *fc,struct path *mountpoint,unsigned int mnt_flags) { -struct pinned_mountpoint mp = {};struct super_block *sb; struct vfsmount *mnt __free(mntput) = fc_mount(fc);int error;
@@ -3712,13 +3715,14 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint,mnt_warn_timestamp_expiry (mountpoint, mnt); - error =lock_mount (mountpoint, &mp); -if (!error) { +LOCK_MOUNT (mp, mountpoint); +if (IS_ERR (mp.parent)) { +return PTR_ERR (mp.parent); + }else { error =do_add_mount (real_mount (mnt), mp.mp, mountpoint, mnt_flags);if (!error)retain_and_null_ptr (mnt);// consumed on success -unlock_mount (&mp); }return error; }
@@ -3780,8 +3784,8 @@ static int do_new_mount(struct path *path, const char *fstype, int sb_flags,return err; } -static int lock_mount_exact (const struct path *path, -struct pinned_mountpoint *mp) +static void lock_mount_exact (const struct path *path, +struct pinned_mountpoint *mp) {struct dentry *dentry = path->dentry;int err;
@@ -3797,14 +3801,15 @@ static int lock_mount_exact(const struct path *path,if (unlikely (err)) {namespace_unlock ();inode_unlock (dentry->d_inode); + mp->parent =ERR_PTR (err); + }else { + mp->parent =real_mount (path->mnt); } -return err; }int finish_automount (struct vfsmount *__m,const struct path *path) { struct vfsmount *m __free(mntput) = __m; -struct pinned_mountpoint mp = {};struct mount *mnt;int err;
@@ -3823,15 +3828,14 @@ int finish_automount(struct vfsmount *__m, const struct path *path)* that overmounts our mountpoint to be means "quitely drop what we've * got", not "try to mount it on top". */ - err =lock_mount_exact (path, &mp); -if (unlikely (err)) -return err == -EBUSY ?0 : err; +LOCK_MOUNT_EXACT (mp, path); +if (IS_ERR (mp.parent)) +return mp.parent ==ERR_PTR (-EBUSY ) ?0 :PTR_ERR (mp.parent); err =do_add_mount (mnt, mp.mp, path, path->mnt->mnt_flags |MNT_SHRINKABLE );if (likely (!err))retain_and_null_ptr (m); -unlock_mount (&mp);return err; }
@@ -4627,7 +4631,6 @@ SYSCALL_DEFINE2(pivot_root, const char __user *, new_root, struct path old __free(path_put) = {}; struct path root __free(path_put) = {};struct mount *new_mnt, *root_mnt, *old_mnt, *root_parent, *ex_parent; -struct pinned_mountpoint old_mp = {};int error;if (!may_mount ())
@@ -4648,45 +4651,42 @@ SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,return error;get_fs_root (current->fs, &root); - error =lock_mount (&old, &old_mp); -if (error) -return error; - error = -EINVAL ; +LOCK_MOUNT (old_mp, &old); + old_mnt = old_mp.parent; +if (IS_ERR (old_mnt)) +return PTR_ERR (old_mnt); + new_mnt =real_mount (new.mnt); root_mnt =real_mount (root.mnt); - old_mnt =real_mount (old.mnt); ex_parent = new_mnt->mnt_parent; root_parent = root_mnt->mnt_parent;if (IS_MNT_SHARED (old_mnt) ||IS_MNT_SHARED (ex_parent) ||IS_MNT_SHARED (root_parent)) - goto out4; +return -EINVAL ;if (!check_mnt (root_mnt) || !check_mnt (new_mnt)) - goto out4; +return -EINVAL ;if (new_mnt->mnt.mnt_flags &MNT_LOCKED ) - goto out4; - error = -ENOENT ; +return -EINVAL ;if (d_unlinked (new.dentry)) - goto out4; - error = -EBUSY ; +return -ENOENT ;if (new_mnt == root_mnt || old_mnt == root_mnt) - goto out4;/* loop, on the same file system */ - error = -EINVAL ; +return -EBUSY ;/* loop, on the same file system */ if (!path_mounted (&root)) - goto out4;/* not a mountpoint */ +return -EINVAL ;/* not a mountpoint */ if (!mnt_has_parent (root_mnt)) - goto out4;/* absolute root */ +return -EINVAL ;/* absolute root */ if (!path_mounted (&new)) - goto out4;/* not a mountpoint */ +return -EINVAL ;/* not a mountpoint */ if (!mnt_has_parent (new_mnt)) - goto out4;/* absolute root */ +return -EINVAL ;/* absolute root */ /* make sure we can reach put_old from new_root */ if (!is_path_reachable (old_mnt, old.dentry, &new)) - goto out4; +return -EINVAL ;/* make certain new is below the root */ if (!is_path_reachable (new_mnt, new.dentry, &root)) - goto out4; +return -EINVAL ;lock_mount_hash ();umount_mnt (new_mnt);if (root_mnt->mnt.mnt_flags &MNT_LOCKED ) {
@@ -4705,10 +4705,7 @@ SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,mnt_notify_add (root_mnt);mnt_notify_add (new_mnt);chroot_fs_refs (&root, &new); - error =0 ; -out4: -unlock_mount (&old_mp); -return error; +return 0 ; }static unsigned int recalc_flags (struct mount_kattr *kattr,struct mount *mnt)
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 29/65 do_move_mount(): use the parent mount returned by do_lock_mount()
In reply to Al ViroAfter successful do_lock_mount() call, mp.parent is set to either real_mount(path->mnt) (for !beneath case) or to ->mnt_parent of that (for beneath). p is set to real_mount(path->mnt) and after several uses it's made equal to mp.parent. All uses prior to that care only about p->mnt_ns and since p->mnt_ns == parent->mnt_ns, we might as well use mp.parent all along.
--- fs/namespace.c | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-)
fs/namespace.c +6 -11
@@ -3571,7 +3571,6 @@ static inline bool may_use_mount(struct mount *mnt)static int do_move_mount (struct path *old_path,struct path *new_path,enum mnt_tree_flags_t flags) { -struct mount *p;struct mount *old =real_mount (old_path->mnt);int err;bool beneath = flags &MNT_TREE_BENEATH ;
@@ -3586,8 +3585,6 @@ static int do_move_mount(struct path *old_path,if (IS_ERR (mp.parent))return PTR_ERR (mp.parent); - p =real_mount (new_path->mnt); -if (check_mnt (old)) {/* if the source is in our namespace... */ /* ... it should be detachable from parent */
@@ -3597,7 +3594,7 @@ static int do_move_mount(struct path *old_path,if (IS_MNT_SHARED (old->mnt_parent))return -EINVAL ;/* ... and the target should be in our namespace */ -if (!check_mnt (p)) +if (!check_mnt (mp.parent))return -EINVAL ; }else {/*
@@ -3610,13 +3607,13 @@ static int do_move_mount(struct path *old_path,* subsequent checks would've rejected that, but they lose * some corner cases if we check it early. */ -if (old->mnt_ns == p->mnt_ns) +if (old->mnt_ns == mp.parent->mnt_ns)return -EINVAL ;/* * Target should be either in our namespace or in an acceptable * anon namespace, sensu check_anonymous_mnt(). */ -if (!may_use_mount (p)) +if (!may_use_mount (mp.parent))return -EINVAL ; }
@@ -3624,22 +3621,20 @@ static int do_move_mount(struct path *old_path, err =can_move_mount_beneath (old, new_path, mp.mp);if (err)return err; - - p = p->mnt_parent; }/* * Don't move a mount tree containing unbindable mounts to a destination * mount which is shared. */ -if (IS_MNT_SHARED (p) &&tree_contains_unbindable (old)) +if (IS_MNT_SHARED (mp.parent) &&tree_contains_unbindable (old))return -EINVAL ;if (!check_for_nsfs_mounts (old))return -ELOOP ; -if (mount_is_ancestor (old, p)) +if (mount_is_ancestor (old, mp.parent))return -ELOOP ; -return attach_recursive_mnt (old, p, mp.mp); +return attach_recursive_mnt (old, mp.parent, mp.mp); }static int do_move_mount_old (struct path *path,const char *old_name)
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 30/65 do_add_mount(): switch to passing pinned_mountpoint instead of mountpoint + path
In reply to Al ViroBoth callers pass it a mountpoint reference picked from pinned_mountpoint and path it corresponds to.
First of all, path->dentry is equal to mp.mp->m_dentry. Furthermore, path->mnt is &mp.parent->mnt, making struct path contents redundant.
Pass it the address of that pinned_mountpoint instead; what's more, if we teach it to treat ERR_PTR(error) in ->parent as "bail out with that error" we can simplify the callers even more - do_add_mount() will do the right thing even when called after lock_mount() failure.
--- fs/namespace.c | 32 +++++++++++++++----------------- 1 file changed, 15 insertions(+), 17 deletions(-)
fs/namespace.c +15 -17
@@ -3657,10 +3657,13 @@ static int do_move_mount_old(struct path *path, const char *old_name)/* * add a mount into a namespace's mount tree */ -static int do_add_mount (struct mount *newmnt,struct mountpoint *mp, -const struct path *path,int mnt_flags) +static int do_add_mount (struct mount *newmnt,const struct pinned_mountpoint *mp, +int mnt_flags) { -struct mount *parent =real_mount (path->mnt); +struct mount *parent = mp->parent; + +if (IS_ERR (parent)) +return PTR_ERR (parent); mnt_flags &= ~MNT_INTERNAL_FLAGS ;
@@ -3674,14 +3677,15 @@ static int do_add_mount(struct mount *newmnt, struct mountpoint *mp, }/* Refuse the same filesystem on the same mount point */ -if (path->mnt->mnt_sb == newmnt->mnt.mnt_sb &&path_mounted (path)) +if (parent->mnt.mnt_sb == newmnt->mnt.mnt_sb && + parent->mnt.mnt_root == mp->mp->m_dentry)return -EBUSY ;if (d_is_symlink (newmnt->mnt.mnt_root))return -EINVAL ; newmnt->mnt.mnt_flags = mnt_flags; -return graft_tree (newmnt, parent, mp); +return graft_tree (newmnt, parent, mp->mp); }static bool mount_too_revealing (const struct super_block *sb,int *new_mnt_flags);
@@ -3711,14 +3715,9 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint,mnt_warn_timestamp_expiry (mountpoint, mnt);LOCK_MOUNT (mp, mountpoint); -if (IS_ERR (mp.parent)) { -return PTR_ERR (mp.parent); - }else { - error =do_add_mount (real_mount (mnt), mp.mp, - mountpoint, mnt_flags); -if (!error) -retain_and_null_ptr (mnt);// consumed on success - } + error =do_add_mount (real_mount (mnt), &mp, mnt_flags); +if (!error) +retain_and_null_ptr (mnt);// consumed on success return error; }
@@ -3824,11 +3823,10 @@ int finish_automount(struct vfsmount *__m, const struct path *path)* got", not "try to mount it on top". */ LOCK_MOUNT_EXACT (mp, path); -if (IS_ERR (mp.parent)) -return mp.parent ==ERR_PTR (-EBUSY ) ?0 :PTR_ERR (mp.parent); +if (mp.parent ==ERR_PTR (-EBUSY )) +return 0 ; - err =do_add_mount (mnt, mp.mp, path, - path->mnt->mnt_flags |MNT_SHRINKABLE ); + err =do_add_mount (mnt, &mp, path->mnt->mnt_flags |MNT_SHRINKABLE );if (likely (!err))retain_and_null_ptr (m);return err;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 31/65 graft_tree(), attach_recursive_mnt() - pass pinned_mountpoint
In reply to Al Viroparent and mountpoint always come from the same struct pinned_mountpoint now.
--- fs/namespace.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-)
fs/namespace.c +10 -10
@@ -2549,8 +2549,7 @@ enum mnt_tree_flags_t {/** * attach_recursive_mnt - attach a source mount tree * @source_mnt: mount tree to be attached -* @dest_mnt: mount that @source_mnt will be mounted on -* @dest_mp: the mountpoint @source_mnt will be mounted at +* @dest: the context for mounting at the place where the tree should go * * NOTE: in the table below explains the semantics when a source mount * of a given type is attached to a destination mount of a given type.
@@ -2613,10 +2612,11 @@ enum mnt_tree_flags_t {* Otherwise a negative error code is returned. */ static int attach_recursive_mnt (struct mount *source_mnt, -struct mount *dest_mnt, -struct mountpoint *dest_mp) +const struct pinned_mountpoint *dest) {struct user_namespace *user_ns = current->nsproxy->mnt_ns->user_ns; +struct mount *dest_mnt = dest->parent; +struct mountpoint *dest_mp = dest->mp;HLIST_HEAD (tree_list);struct mnt_namespace *ns = dest_mnt->mnt_ns;struct pinned_mountpoint root = {};
@@ -2864,16 +2864,16 @@ static inline void unlock_mount(struct pinned_mountpoint *m) struct pinned_mountpoint mp __cleanup(unlock_mount) = {}; \ lock_mount_exact((path), &mp) -static int graft_tree (struct mount *mnt,struct mount *p,struct mountpoint *mp) +static int graft_tree (struct mount *mnt,const struct pinned_mountpoint *mp) {if (mnt->mnt.mnt_sb->s_flags &SB_NOUSER )return -EINVAL ; -if (d_is_dir (mp->m_dentry) != +if (d_is_dir (mp->mp->m_dentry) !=d_is_dir (mnt->mnt.mnt_root))return -ENOTDIR ; -return attach_recursive_mnt (mnt, p, mp); +return attach_recursive_mnt (mnt, mp); }static int may_change_propagation (const struct mount *m)
@@ -3055,7 +3055,7 @@ static int do_loopback(struct path *path, const char *old_name,if (IS_ERR (mnt))return PTR_ERR (mnt); - err =graft_tree (mnt, mp.parent, mp.mp); + err =graft_tree (mnt, &mp);if (err) {lock_mount_hash ();umount_tree (mnt,UMOUNT_SYNC );
@@ -3634,7 +3634,7 @@ static int do_move_mount(struct path *old_path,if (mount_is_ancestor (old, mp.parent))return -ELOOP ; -return attach_recursive_mnt (old, mp.parent, mp.mp); +return attach_recursive_mnt (old, &mp); }static int do_move_mount_old (struct path *path,const char *old_name)
@@ -3685,7 +3685,7 @@ static int do_add_mount(struct mount *newmnt, const struct pinned_mountpoint *mpreturn -EINVAL ; newmnt->mnt.mnt_flags = mnt_flags; -return graft_tree (newmnt, parent, mp->mp); +return graft_tree (newmnt, mp); }static bool mount_too_revealing (const struct super_block *sb,int *new_mnt_flags);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 32/65 pivot_root(2): use old_mp.mp->m_dentry instead of old.dentry
In reply to Al ViroThat kills the last place where callers of lock_mount(path, &mp) used path->dentry.
--- fs/namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/namespace.c +1 -1
@@ -4675,7 +4675,7 @@ SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,if (!mnt_has_parent (new_mnt))return -EINVAL ;/* absolute root */ /* make sure we can reach put_old from new_root */ -if (!is_path_reachable (old_mnt, old.dentry, &new)) +if (!is_path_reachable (old_mnt, old_mp.mp->m_dentry, &new))return -EINVAL ;/* make certain new is below the root */ if (!is_path_reachable (new_mnt, new.dentry, &root))
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 33/65 don't bother passing new_path->dentry to can_move_mount_beneath()
In reply to Al Viro--- fs/namespace.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-)
fs/namespace.c +7 -6
@@ -3450,8 +3450,8 @@ static bool mount_is_ancestor(const struct mount *p1, const struct mount *p2)/** * can_move_mount_beneath - check that we can mount beneath the top mount * @mnt_from: mount we are trying to move -* @to: mount under which to mount -* @mp: mountpoint of @to +* @mnt_to: mount under which to mount +* @mp: mountpoint of @mnt_to * * - Make sure that nothing can be mounted beneath the caller's current * root or the rootfs of the namespace.
@@ -3467,11 +3467,10 @@ static bool mount_is_ancestor(const struct mount *p1, const struct mount *p2)* Return: On success 0, and on error a negative error code is returned. */ static int can_move_mount_beneath (struct mount *mnt_from, -const struct path *to, +struct mount *mnt_to,const struct mountpoint *mp) { -struct mount *mnt_to =real_mount (to->mnt), - *parent_mnt_to = mnt_to->mnt_parent; +struct mount *parent_mnt_to = mnt_to->mnt_parent;if (IS_MNT_LOCKED (mnt_to))return -EINVAL ;
@@ -3618,7 +3617,9 @@ static int do_move_mount(struct path *old_path, }if (beneath) { - err =can_move_mount_beneath (old, new_path, mp.mp); +struct mount *over =real_mount (new_path->mnt); + + err =can_move_mount_beneath (old, over, mp.mp);if (err)return err; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 34/65 new helper: topmost_overmount()
In reply to Al ViroReturns the final (topmost) mount in the chain of overmounts starting at given mount. Same locking rules as for any mount tree traversal - either the spinlock side of mount_lock, or rcu + sample the seqcount side of mount_lock before the call and recheck afterwards.
--- fs/mount.h | 7 +++++++ fs/namespace.c | 9 +++------ 2 files changed, 10 insertions(+), 6 deletions(-)
fs/mount.h +7 -0
@@ -235,4 +235,11 @@ static inline void mnt_notify_add(struct mount *m) }#endif +static inline struct mount *topmost_overmount (struct mount *m) +{ +while (m->overmount) + m = m->overmount; +return m; +} +struct mnt_namespace *mnt_ns_from_dentry (struct dentry *dentry);
fs/namespace.c +3 -6
@@ -2696,10 +2696,9 @@ static int attach_recursive_mnt(struct mount *source_mnt, child->mnt_mountpoint);commit_tree (child);if (q) { +struct mount *r =topmost_overmount (child);struct mountpoint *mp = root.mp; -struct mount *r = child; -while (unlikely (r->overmount)) - r = r->overmount; +if (unlikely (shorter) && child != source_mnt) mp = shorter;mnt_change_mountpoint (r, mp, q);
@@ -6173,9 +6172,7 @@ bool current_chrooted(void)guard (mount_locked_reader)(); - root = current->nsproxy->mnt_ns->root; -while (unlikely (root->overmount)) - root = root->overmount; + root =topmost_overmount (current->nsproxy->mnt_ns->root);return fs_root.mnt != &root->mnt || !path_mounted (&fs_root); }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 35/65 do_lock_mount(): don't modify path.
In reply to Al ViroCurrently do_lock_mount() has the target path switched to whatever might be overmounting it. We _do_ want to have the parent mount/mountpoint chosen on top of the overmounting pile; however, the way it's done has unpleasant races - if umount propagation removes the overmount while we'd been trying to set the environment up, we might end up failing if our target path strays into that overmount just before the overmount gets kicked out.
Users of do_lock_mount() do not need the target path changed - they have all information in res->{parent,mp}; only one place (in do_move_mount()) currently uses the resulting path->mnt, and that value is trivial to reconstruct by the original value of path->mnt + chosen parent mount.
Let's keep the target path unchanged; it avoids a bunch of subtle races and it's not hard to do:
do
as mount_locked_reader
find the prospective parent mount/mountpoint dentry grab references if it's not the original target
lock the prospective mountpoint dentry
take namespace_sem exclusive
if prospective parent/mountpoint would be different now
err = -EAGAIN
else if location has been unmounted
err = -ENOENT
else if mountpoint dentry is not allowed to be mounted on
err = -ENOENT
else if beneath and the top of the pile was the absolute root
err = -EINVAL
else
try to get struct mountpoint (by dentry), set err to 0 on success and -ENO{MEM,ENT} on failure
if err != 0
res->parent = ERR_PTR(err)
drop locks
else
res->parent = prospective parent
drop temporary references
while err == -EAGAIN
A somewhat subtle part is that dropping temporary references is allowed. Neither mounts nor dentries should be evicted by a thread that holds namespace_sem. On success we are dropping those references under namespace_sem, so we need to be sure that these are not the last references remaining. However, on success we'd already verified (under namespace_sem) that original target is still mounted and that mount and dentry we are about to drop are still reachable from it via the mount tree. That guarantees that we are not about to drop the last remaining references.
--- fs/namespace.c | 122 ++++++++++++++++++++++++++----------------------- 1 file changed, 65 insertions(+), 57 deletions(-)
fs/namespace.c +65 -57
@@ -2727,6 +2727,27 @@ static int attach_recursive_mnt(struct mount *source_mnt,return err; } +static inline struct mount *where_to_mount (const struct path *path, +struct dentry **dentry, +bool beneath) +{ +struct mount *m; + +if (unlikely (beneath)) { + m =topmost_overmount (real_mount (path->mnt)); + *dentry = m->mnt_mountpoint; +return m->mnt_parent; + } + m =__lookup_mnt (path->mnt, path->dentry); +if (unlikely (m)) { + m =topmost_overmount (m); + *dentry = m->mnt.mnt_root; +return m; + } + *dentry = path->dentry; +return real_mount (path->mnt); +} +/** * do_lock_mount - acquire environment for mounting * @path: target path
@@ -2758,84 +2779,69 @@ static int attach_recursive_mnt(struct mount *source_mnt,* case we also require the location to be at the root of a mount * that has a parent (i.e. is not a root of some namespace). */ -static void do_lock_mount (struct path *path,struct pinned_mountpoint *res,bool beneath) +static void do_lock_mount (const struct path *path, +struct pinned_mountpoint *res, +bool beneath) { -struct vfsmount *mnt = path->mnt; -struct dentry *dentry; -struct path under = {}; -int err = -ENOENT ; +int err;if (unlikely (beneath) && !path_mounted (path)) { res->parent =ERR_PTR (-EINVAL );return ; } -for (;;) { -struct mount *m =real_mount (mnt); - -if (beneath) { -path_put (&under); -read_seqlock_excl (&mount_lock); -if (unlikely (!mnt_has_parent (m))) { -read_sequnlock_excl (&mount_lock); - res->parent =ERR_PTR (-EINVAL ); -return ; +do { +struct dentry *dentry, *d; +struct mount *m, *n; + +scoped_guard (mount_locked_reader) { + m =where_to_mount (path, &dentry, beneath); +if (&m->mnt != path->mnt) { +mntget (&m->mnt); +dget (dentry); } - under.mnt =mntget (&m->mnt_parent->mnt); - under.dentry =dget (m->mnt_mountpoint); -read_sequnlock_excl (&mount_lock); - dentry = under.dentry; - }else { - dentry = path->dentry; }inode_lock (dentry->d_inode);namespace_lock (); -if (unlikely (cant_mount (dentry) || !is_mounted (mnt))) -break ;// not to be mounted on +// check if the chain of mounts (if any) has changed. +scoped_guard (mount_locked_reader) + n =where_to_mount (path, &d, beneath); -if (beneath &&unlikely (m->mnt_mountpoint != dentry || - &m->mnt_parent->mnt != under.mnt)) { -namespace_unlock (); -inode_unlock (dentry->d_inode); -continue ;// got moved - } +if (unlikely (n != m || dentry != d)) + err = -EAGAIN ;// something moved, retry +else if (unlikely (cant_mount (dentry) || !is_mounted (path->mnt))) + err = -ENOENT ;// not to be mounted on +else if (beneath && &m->mnt == path->mnt && !m->overmount) + err = -EINVAL ; +else + err =get_mountpoint (dentry, res); - mnt =lookup_mnt (path); -if (unlikely (mnt)) { +if (unlikely (err)) { + res->parent =ERR_PTR (err);namespace_unlock ();inode_unlock (dentry->d_inode); -path_put (path); - path->mnt = mnt; - path->dentry =dget (mnt->mnt_root); -continue ;// got overmounted + }else { + res->parent = m; } - err =get_mountpoint (dentry, res); -if (err) -break ; -if (beneath) { -/* -* @under duplicates the references that will stay -* at least until namespace_unlock(), so the path_put() -* below is safe (and OK to do under namespace_lock - -* we are not dropping the final references here). -*/ -path_put (&under); - res->parent =real_mount (path->mnt)->mnt_parent; -return ; +/* +* Drop the temporary references. This is subtle - on success +* we are doing that under namespace_sem, which would normally +* be forbidden. However, in that case we are guaranteed that +* refcounts won't reach zero, since we know that path->mnt +* is mounted and thus all mounts reachable from it are pinned +* and stable, along with their mountpoints and roots. +*/ +if (&m->mnt != path->mnt) { +dput (dentry); +mntput (&m->mnt); } - res->parent =real_mount (path->mnt); -return ; - } -namespace_unlock (); -inode_unlock (dentry->d_inode); -if (beneath) -path_put (&under); - res->parent =ERR_PTR (err); + }while (err == -EAGAIN ); } -static inline void lock_mount (struct path *path,struct pinned_mountpoint *m) +static inline void lock_mount (const struct path *path, +struct pinned_mountpoint *m) {do_lock_mount (path, m, false); }
@@ -3618,6 +3624,8 @@ static int do_move_mount(struct path *old_path,if (beneath) {struct mount *over =real_mount (new_path->mnt); +if (mp.parent != over->mnt_parent) + over = mp.parent->overmount; err =can_move_mount_beneath (old, over, mp.mp);if (err)return err;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 36/65 constify check_mnt()
In reply to Al Viro--- fs/namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/namespace.c +1 -1
@@ -1010,7 +1010,7 @@ static void unpin_mountpoint(struct pinned_mountpoint *m) } } -static inline int check_mnt (struct mount *mnt) +static inline int check_mnt (const struct mount *mnt) {return mnt->mnt_ns == current->nsproxy->mnt_ns; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 37/65 do_mount_setattr(): constify path argument
In reply to Al Viro--- fs/namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/namespace.c +1 -1
@@ -4865,7 +4865,7 @@ static void mount_setattr_commit(struct mount_kattr *kattr, struct mount *mnt)touch_mnt_namespace (mnt->mnt_ns); } -static int do_mount_setattr (struct path *path,struct mount_kattr *kattr) +static int do_mount_setattr (const struct path *path,struct mount_kattr *kattr) {struct mount *mnt =real_mount (path->mnt);int err =0 ;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 38/65 do_set_group(): constify path arguments
In reply to Al Viro--- fs/namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/namespace.c +1 -1
@@ -3359,7 +3359,7 @@ static inline int tree_contains_unbindable(struct mount *mnt)return 0 ; } -static int do_set_group (struct path *from_path,struct path *to_path) +static int do_set_group (const struct path *from_path,const struct path *to_path) {struct mount *from =real_mount (from_path->mnt);struct mount *to =real_mount (to_path->mnt);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 39/65 drop_collected_paths(): constify arguments
In reply to Al Viro... and use that to constify the pointers in callers
--- fs/namespace.c | 4 ++-- include/linux/mount.h | 2 +- kernel/audit_tree.c | 12 ++++++------ 3 files changed, 9 insertions(+), 9 deletions(-)
fs/namespace.c +2 -2
@@ -2334,9 +2334,9 @@ struct path *collect_paths(const struct path *path,return res; } -void drop_collected_paths (struct path *paths,struct path *prealloc) +void drop_collected_paths (const struct path *paths,struct path *prealloc) { -for (struct path *p = paths; p->mnt; p++) +for (const struct path *p = paths; p->mnt; p++)path_put (p);if (paths != prealloc)kfree (paths);
include/linux/mount.h +1 -1
@@ -105,7 +105,7 @@ extern int may_umount(struct vfsmount *);int do_mount (const char *,const char __user *,const char *,unsigned long ,void *);extern struct path *collect_paths (const struct path *,struct path *,unsigned ); -extern void drop_collected_paths (struct path *,struct path *); +extern void drop_collected_paths (const struct path *,struct path *);extern void kern_unmount_array (struct vfsmount *mnt[],unsigned int num);extern int cifs_root_data (char **dev,char **opts);
kernel/audit_tree.c +6 -6
@@ -678,7 +678,7 @@ void audit_trim_trees(void)struct audit_tree *tree;struct path path;struct audit_node *node; -struct path *paths; +const struct path *paths;struct path array[16 ];int err;
@@ -701,7 +701,7 @@ void audit_trim_trees(void)struct audit_chunk *chunk =find_chunk (node);/* this could be NULL if the watch is dying else where... */ node->index |=1U <<31 ; -for (struct path *p = paths; p->dentry; p++) { +for (const struct path *p = paths; p->dentry; p++) {struct inode *inode = p->dentry->d_inode;if (inode_to_key (inode) == chunk->key) { node->index &= ~(1U <<31 );
@@ -740,9 +740,9 @@ void audit_put_tree(struct audit_tree *tree)put_tree (tree); } -static int tag_mounts (struct path *paths,struct audit_tree *tree) +static int tag_mounts (const struct path *paths,struct audit_tree *tree) { -for (struct path *p = paths; p->dentry; p++) { +for (const struct path *p = paths; p->dentry; p++) {int err =tag_chunk (p->dentry->d_inode, tree);if (err)return err;
@@ -805,7 +805,7 @@ int audit_add_tree_rule(struct audit_krule *rule)struct audit_tree *seed = rule->tree, *tree;struct path path;struct path array[16 ]; -struct path *paths; +const struct path *paths;int err; rule->tree =NULL ;
@@ -877,7 +877,7 @@ int audit_tag_tree(char *old, char *new)int failed =0 ;struct path path1, path2;struct path array[16 ]; -struct path *paths; +const struct path *paths;int err; err =kern_path (new,0 , &path2);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 40/65 collect_paths(): constify the return value
In reply to Al Virocallers have no business modifying the paths they get
--- fs/namespace.c | 4 ++-- include/linux/mount.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-)
fs/namespace.c +2 -2
@@ -2300,7 +2300,7 @@ static inline bool extend_array(struct path **res, struct path **to_free,return p; } -struct path *collect_paths (const struct path *path, +const struct path *collect_paths (const struct path *path,struct path *prealloc,unsigned count) {struct mount *root =real_mount (path->mnt);
@@ -2334,7 +2334,7 @@ struct path *collect_paths(const struct path *path,return res; } -void drop_collected_paths (const struct path *paths,struct path *prealloc) +void drop_collected_paths (const struct path *paths,const struct path *prealloc) {for (const struct path *p = paths; p->mnt; p++)path_put (p);
include/linux/mount.h +2 -2
@@ -104,8 +104,8 @@ extern int may_umount_tree(struct vfsmount *);extern int may_umount (struct vfsmount *);int do_mount (const char *,const char __user *,const char *,unsigned long ,void *); -extern struct path *collect_paths (const struct path *,struct path *,unsigned ); -extern void drop_collected_paths (const struct path *,struct path *); +extern const struct path *collect_paths (const struct path *,struct path *,unsigned ); +extern void drop_collected_paths (const struct path *,const struct path *);extern void kern_unmount_array (struct vfsmount *mnt[],unsigned int num);extern int cifs_root_data (char **dev,char **opts);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 41/65 do_move_mount(), vfs_move_mount(), do_move_mount_old(): constify struct path argument(s)
In reply to Al Viro--- fs/namespace.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
fs/namespace.c +6 -4
@@ -3572,8 +3572,9 @@ static inline bool may_use_mount(struct mount *mnt)return check_anonymous_mnt (mnt); } -static int do_move_mount (struct path *old_path, -struct path *new_path,enum mnt_tree_flags_t flags) +static int do_move_mount (const struct path *old_path, +const struct path *new_path, +enum mnt_tree_flags_t flags) {struct mount *old =real_mount (old_path->mnt);int err;
@@ -3645,7 +3646,7 @@ static int do_move_mount(struct path *old_path,return attach_recursive_mnt (old, &mp); } -static int do_move_mount_old (struct path *path,const char *old_name) +static int do_move_mount_old (const struct path *path,const char *old_name) {struct path old_path;int err;
@@ -4475,7 +4476,8 @@ SYSCALL_DEFINE3(fsmount, int, fs_fd, unsigned int, flags,return ret; } -static inline int vfs_move_mount (struct path *from_path,struct path *to_path, +static inline int vfs_move_mount (const struct path *from_path, +const struct path *to_path,enum mnt_tree_flags_t mflags) {int ret;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 42/65 mnt_warn_timestamp_expiry(): constify struct path argument
In reply to Al Viro--- fs/namespace.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/namespace.c +2 -1
@@ -3230,7 +3230,8 @@ static void set_mount_attributes(struct mount *mnt, unsigned int mnt_flags)touch_mnt_namespace (mnt->mnt_ns); } -static void mnt_warn_timestamp_expiry (struct path *mountpoint,struct vfsmount *mnt) +static void mnt_warn_timestamp_expiry (const struct path *mountpoint, +struct vfsmount *mnt) {struct super_block *sb = mnt->mnt_sb;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 43/65 do_new_mount{,_fc}(): constify struct path argument
In reply to Al Viro--- fs/namespace.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
fs/namespace.c +4 -3
@@ -3704,7 +3704,7 @@ static bool mount_too_revealing(const struct super_block *sb, int *new_mnt_flags* Create a new mount using a superblock configuration and request it * be added to the namespace tree. */ -static int do_new_mount_fc (struct fs_context *fc,struct path *mountpoint, +static int do_new_mount_fc (struct fs_context *fc,const struct path *mountpoint,unsigned int mnt_flags) {struct super_block *sb;
@@ -3735,8 +3735,9 @@ static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint,* create a new mount for userspace and request it to be added into the * namespace's tree */ -static int do_new_mount (struct path *path,const char *fstype,int sb_flags, -int mnt_flags,const char *name,void *data) +static int do_new_mount (const struct path *path,const char *fstype, +int sb_flags,int mnt_flags, +const char *name,void *data) {struct file_system_type *type;struct fs_context *fc;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 44/65 do_{loopback,change_type,remount,reconfigure_mnt}(): constify struct path argument
In reply to Al Viro--- fs/namespace.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
fs/namespace.c +5 -5
@@ -2914,7 +2914,7 @@ static int flags_to_propagation_type(int ms_flags)/* * recursively change the type of the mountpoint. */ -static int do_change_type (struct path *path,int ms_flags) +static int do_change_type (const struct path *path,int ms_flags) {struct mount *m;struct mount *mnt =real_mount (path->mnt);
@@ -3034,8 +3034,8 @@ static struct mount *__do_loopback(struct path *old_path, int recurse)/* * do loopback mount. */ -static int do_loopback (struct path *path,const char *old_name, -int recurse) +static int do_loopback (const struct path *path,const char *old_name, +int recurse) { struct path old_path __free(path_put) = {};struct mount *mnt =NULL ;
@@ -3265,7 +3265,7 @@ static void mnt_warn_timestamp_expiry(const struct path *mountpoint,* superblock it refers to. This is triggered by specifying MS_REMOUNT|MS_BIND * to mount(2). */ -static int do_reconfigure_mnt (struct path *path,unsigned int mnt_flags) +static int do_reconfigure_mnt (const struct path *path,unsigned int mnt_flags) {struct super_block *sb = path->mnt->mnt_sb;struct mount *mnt =real_mount (path->mnt);
@@ -3302,7 +3302,7 @@ static int do_reconfigure_mnt(struct path *path, unsigned int mnt_flags)* If you've mounted a non-root directory somewhere and want to do remount * on it - tough luck. */ -static int do_remount (struct path *path,int ms_flags,int sb_flags, +static int do_remount (const struct path *path,int ms_flags,int sb_flags,int mnt_flags,void *data) {int err;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 45/65 path_mount(): constify struct path argument
In reply to Al Vironow it finally can be done.
--- fs/internal.h | 2 +- fs/namespace.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
fs/internal.h +1 -1
@@ -84,7 +84,7 @@ void mnt_put_write_access_file(struct file *file);extern void dissolve_on_fput (struct vfsmount *);extern bool may_mount (void ); -int path_mount (const char *dev_name,struct path *path, +int path_mount (const char *dev_name,const struct path *path,const char *type_page,unsigned long flags,void *data_page);int path_umount (struct path *path,int flags);
fs/namespace.c +1 -1
@@ -4018,7 +4018,7 @@ static char *copy_mount_string(const void __user *data)* Therefore, if this magic number is present, it carries no information * and must be discarded. */ -int path_mount (const char *dev_name,struct path *path, +int path_mount (const char *dev_name,const struct path *path,const char *type_page,unsigned long flags,void *data_page) {unsigned int mnt_flags =0 , sb_flags;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 46/65 may_copy_tree(), __do_loopback(): constify struct path argument
In reply to Al Viro--- fs/namespace.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/namespace.c +2 -2
@@ -2990,7 +2990,7 @@ static int do_change_type(const struct path *path, int ms_flags)* * Returns true if the mount tree can be copied, false otherwise. */ -static inline bool may_copy_tree (struct path *path) +static inline bool may_copy_tree (const struct path *path) {struct mount *mnt =real_mount (path->mnt);const struct dentry_operations *d_op;
@@ -3012,7 +3012,7 @@ static inline bool may_copy_tree(struct path *path) } -static struct mount *__do_loopback (struct path *old_path,int recurse) +static struct mount *__do_loopback (const struct path *old_path,int recurse) {struct mount *old =real_mount (old_path->mnt);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 47/65 path_umount(): constify struct path argument
In reply to Al Viro--- fs/internal.h | 2 +- fs/namespace.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
fs/internal.h +1 -1
@@ -86,7 +86,7 @@ extern bool may_mount(void);int path_mount (const char *dev_name,const struct path *path,const char *type_page,unsigned long flags,void *data_page); -int path_umount (struct path *path,int flags); +int path_umount (const struct path *path,int flags);int show_path (struct seq_file *m,struct dentry *root);
fs/namespace.c +1 -1
@@ -2084,7 +2084,7 @@ static int can_umount(const struct path *path, int flags) }// caller is responsible for flags being sane -int path_umount (struct path *path,int flags) +int path_umount (const struct path *path,int flags) {struct mount *mnt =real_mount (path->mnt);int ret;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 48/65 constify can_move_mount_beneath() arguments
In reply to Al Viro--- fs/namespace.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/namespace.c +2 -2
@@ -3472,8 +3472,8 @@ static bool mount_is_ancestor(const struct mount *p1, const struct mount *p2)* Context: This function expects namespace_lock() to be held. * Return: On success 0, and on error a negative error code is returned. */ -static int can_move_mount_beneath (struct mount *mnt_from, -struct mount *mnt_to, +static int can_move_mount_beneath (const struct mount *mnt_from, +const struct mount *mnt_to,const struct mountpoint *mp) {struct mount *parent_mnt_to = mnt_to->mnt_parent;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 49/65 do_move_mount_old(): use __free(path_put)
In reply to Al Viro--- fs/namespace.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
fs/namespace.c +2 -4
@@ -3649,7 +3649,7 @@ static int do_move_mount(const struct path *old_path,static int do_move_mount_old (const struct path *path,const char *old_name) { -struct path old_path; + struct path old_path __free(path_put) = {};int err;if (!old_name || !*old_name)
@@ -3659,9 +3659,7 @@ static int do_move_mount_old(const struct path *path, const char *old_name)if (err)return err; - err =do_move_mount (&old_path, path,0 ); -path_put (&old_path); -return err; +return do_move_mount (&old_path, path,0 ); }/*
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 50/65 do_mount(): use __free(path_put)
In reply to Al Viro--- fs/namespace.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
fs/namespace.c +2 -4
@@ -4098,15 +4098,13 @@ int path_mount(const char *dev_name, const struct path *path,int do_mount (const char *dev_name,const char __user *dir_name,const char *type_page,unsigned long flags,void *data_page) { -struct path path; + struct path path __free(path_put) = {};int ret; ret =user_path_at (AT_FDCWD , dir_name,LOOKUP_FOLLOW , &path);if (ret)return ret; - ret =path_mount (dev_name, &path, type_page, flags, data_page); -path_put (&path); -return ret; +return path_mount (dev_name, &path, type_page, flags, data_page); }static struct ucounts *inc_mnt_namespaces (struct user_namespace *ns)
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 51/65 umount_tree(): take all victims out of propagation graph at once
In reply to Al ViroFor each removed mount we need to calculate where the slaves will end up. To avoid duplicating that work, do it for all mounts to be removed at once, taking the mounts themselves out of propagation graph as we go, then do all transfers; the duplicate work on finding destinations is avoided since if we run into a mount that already had destination found, we don't need to trace the rest of the way. That's guaranteed O(removed mounts) for finding destinations and removing from propagation graph and O(surviving mounts that have master removed) for transfers.
--- fs/namespace.c | 3 ++- fs/pnode.c | 67 +++++++++++++++++++++++++++++++++++++++----------- fs/pnode.h | 1 + 3 files changed, 55 insertions(+), 16 deletions(-)
fs/namespace.c +2 -1
@@ -1846,6 +1846,8 @@ static void umount_tree(struct mount *mnt, enum umount_tree_flags how)if (how &UMOUNT_PROPAGATE )propagate_umount (&tmp_list); +bulk_make_private (&tmp_list); +while (!list_empty (&tmp_list)) {struct mnt_namespace *ns;bool disconnect;
@@ -1870,7 +1872,6 @@ static void umount_tree(struct mount *mnt, enum umount_tree_flags how)umount_mnt (p); } } -change_mnt_propagation (p,MS_PRIVATE );if (disconnect)hlist_add_head (&p->mnt_umount, &unmounted);
fs/pnode.c +52 -15
88 lines not on this page · raw message
fs/pnode.h +1 -0
@@ -42,6 +42,7 @@ static inline bool peers(const struct mount *m1, const struct mount *m2) }void change_mnt_propagation (struct mount *,int ); +void bulk_make_private (struct list_head *);int propagate_mnt (struct mount *,struct mountpoint *,struct mount *,struct hlist_head *);void propagate_umount (struct list_head *);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 52/65 ecryptfs: get rid of pointless mount references in ecryptfs dentries
In reply to Al Viro->lower_path.mnt has the same value for all dentries on given ecryptfs instance and if somebody goes for mountpoint-crossing variant where that would not be true, we can deal with that when it happens (and _not_ with duplicating these reference into each dentry).
As it is, we are better off just sticking a reference into ecryptfs-private part of superblock and keeping it pinned until ->kill_sb().
That way we can stick a reference to underlying dentry right into ->d_fsdata of ecryptfs one, getting rid of indirection through struct ecryptfs_dentry_info, along with the entire struct ecryptfs_dentry_info machinery.
--- fs/ecryptfs/dentry.c | 14 +------------- fs/ecryptfs/ecryptfs_kernel.h | 27 +++++++++++---------------- fs/ecryptfs/file.c | 15 +++++++-------- fs/ecryptfs/inode.c | 19 +++++-------------- fs/ecryptfs/main.c | 24 ++++++------------------ 5 files changed, 30 insertions(+), 69 deletions(-)
fs/ecryptfs/dentry.c +1 -13
@@ -59,14 +59,6 @@ static int ecryptfs_d_revalidate(struct inode *dir, const struct qstr *name,return rc; } -struct kmem_cache *ecryptfs_dentry_info_cache; - -static void ecryptfs_dentry_free_rcu (struct rcu_head *head) -{ -kmem_cache_free (ecryptfs_dentry_info_cache, - container_of(head, struct ecryptfs_dentry_info, rcu)); -} -/** * ecryptfs_d_release * @dentry: The ecryptfs dentry
@@ -75,11 +67,7 @@ static void ecryptfs_dentry_free_rcu(struct rcu_head *head)*/ static void ecryptfs_d_release (struct dentry *dentry) { -struct ecryptfs_dentry_info *p = dentry->d_fsdata; -if (p) { -path_put (&p->lower_path); -call_rcu (&p->rcu, ecryptfs_dentry_free_rcu); - } +dput (dentry->d_fsdata); }const struct dentry_operations ecryptfs_dops = {
fs/ecryptfs/ecryptfs_kernel.h +11 -16
@@ -258,13 +258,6 @@ struct ecryptfs_inode_info {struct ecryptfs_crypt_stat crypt_stat; }; -/* dentry private data. Each dentry must keep track of a lower -* vfsmount too. */ -struct ecryptfs_dentry_info { -struct path lower_path; -struct rcu_head rcu; -}; -/** * ecryptfs_global_auth_tok - A key used to encrypt all new files under the mountpoint * @flags: Status flags
@@ -348,6 +341,7 @@ struct ecryptfs_mount_crypt_stat {/* superblock private data. */ struct ecryptfs_sb_info {struct super_block *wsi_sb; +struct vfsmount *lower_mnt;struct ecryptfs_mount_crypt_stat mount_crypt_stat; };
@@ -494,22 +488,25 @@ ecryptfs_set_superblock_lower(struct super_block *sb, }static inline void -ecryptfs_set_dentry_private (struct dentry *dentry, -struct ecryptfs_dentry_info *dentry_info) +ecryptfs_set_dentry_lower (struct dentry *dentry, +struct dentry *lower_dentry) { - dentry->d_fsdata = dentry_info; + dentry->d_fsdata = lower_dentry; }static inline struct dentry *ecryptfs_dentry_to_lower (struct dentry *dentry) { -return ((struct ecryptfs_dentry_info *)dentry->d_fsdata)->lower_path.dentry; +return dentry->d_fsdata; } -static inline const struct path * -ecryptfs_dentry_to_lower_path (struct dentry *dentry) +static inline struct path +ecryptfs_lower_path (struct dentry *dentry) { -return &((struct ecryptfs_dentry_info *)dentry->d_fsdata)->lower_path; +return (struct path ){ + .mnt =ecryptfs_superblock_to_private (dentry->d_sb)->lower_mnt, + .dentry =ecryptfs_dentry_to_lower (dentry) + }; } #define ecryptfs_printk(type, fmt, arg...) \
@@ -532,7 +529,6 @@ extern unsigned int ecryptfs_number_of_users;extern struct kmem_cache *ecryptfs_auth_tok_list_item_cache;extern struct kmem_cache *ecryptfs_file_info_cache; -extern struct kmem_cache *ecryptfs_dentry_info_cache;extern struct kmem_cache *ecryptfs_inode_info_cache;extern struct kmem_cache *ecryptfs_sb_info_cache;extern struct kmem_cache *ecryptfs_header_cache;
@@ -557,7 +553,6 @@ int ecryptfs_encrypt_and_encode_filename(size_t *encoded_name_size, struct ecryptfs_mount_crypt_stat *mount_crypt_stat, const char *name, size_t name_size); -struct dentry *ecryptfs_lower_dentry (struct dentry *this_dentry);void ecryptfs_dump_hex (char *data,int bytes);int virt_to_scatterlist (const void *addr,int size,struct scatterlist *sg,int sg_size);
fs/ecryptfs/file.c +7 -8
@@ -33,13 +33,12 @@ static ssize_t ecryptfs_read_update_atime(struct kiocb *iocb, struct iov_iter *to) {ssize_t rc; -const struct path *path;struct file *file = iocb->ki_filp; rc =generic_file_read_iter (iocb, to);if (rc >=0 ) { - path =ecryptfs_dentry_to_lower_path (file->f_path.dentry); -touch_atime (path); +struct path path =ecryptfs_lower_path (file->f_path.dentry); +touch_atime (&path); }return rc; }
@@ -59,12 +58,11 @@ static ssize_t ecryptfs_splice_read_update_atime(struct file *in, loff_t *ppos, size_t len, unsigned int flags) { ssize_t rc; -const struct path *path; rc =filemap_splice_read (in, ppos, pipe, len, flags);if (rc >=0 ) { - path =ecryptfs_dentry_to_lower_path (in->f_path.dentry); -touch_atime (path); +struct path path =ecryptfs_lower_path (in->f_path.dentry); +touch_atime (&path); }return rc; }
@@ -283,6 +281,7 @@ static int ecryptfs_dir_open(struct inode *inode, struct file *file)* ecryptfs_lookup() */ struct ecryptfs_file_info *file_info;struct file *lower_file; +struct path path;/* Released in ecryptfs_release or end of function if failure */ file_info =kmem_cache_zalloc (ecryptfs_file_info_cache,GFP_KERNEL );
@@ -292,8 +291,8 @@ static int ecryptfs_dir_open(struct inode *inode, struct file *file) "Error attempting to allocate memory\n");return -ENOMEM ; } - lower_file =dentry_open (ecryptfs_dentry_to_lower_path (ecryptfs_dentry), - file->f_flags,current_cred ()); + path =ecryptfs_lower_path (ecryptfs_dentry); + lower_file =dentry_open (&path, file->f_flags,current_cred ());if (IS_ERR (lower_file)) {printk (KERN_ERR "%s: Error attempting to initialize " "the lower file for the dentry with name "
fs/ecryptfs/inode.c +5 -14
@@ -327,24 +327,15 @@ static int ecryptfs_i_size_read(struct dentry *dentry, struct inode *inode)static struct dentry *ecryptfs_lookup_interpose (struct dentry *dentry,struct dentry *lower_dentry) { -const struct path *path =ecryptfs_dentry_to_lower_path (dentry->d_parent); +struct dentry *lower_parent =ecryptfs_dentry_to_lower (dentry->d_parent);struct inode *inode, *lower_inode; -struct ecryptfs_dentry_info *dentry_info;int rc =0 ; - dentry_info =kmem_cache_alloc (ecryptfs_dentry_info_cache,GFP_KERNEL ); -if (!dentry_info) { -dput (lower_dentry); -return ERR_PTR (-ENOMEM ); - } -fsstack_copy_attr_atime (d_inode (dentry->d_parent), -d_inode (path->dentry)); +d_inode (lower_parent));BUG_ON (!d_count (lower_dentry)); -ecryptfs_set_dentry_private (dentry, dentry_info); - dentry_info->lower_path.mnt =mntget (path->mnt); - dentry_info->lower_path.dentry = lower_dentry; +ecryptfs_set_dentry_lower (dentry, lower_dentry);/* * negative dentry can go positive under us here - its parent is not
@@ -1022,10 +1013,10 @@ static int ecryptfs_getattr(struct mnt_idmap *idmap, {struct dentry *dentry = path->dentry;struct kstat lower_stat; +struct path lower_path =ecryptfs_lower_path (dentry);int rc; - rc =vfs_getattr_nosec (ecryptfs_dentry_to_lower_path (dentry), - &lower_stat, request_mask, flags); + rc =vfs_getattr_nosec (&lower_path, &lower_stat, request_mask, flags);if (!rc) {fsstack_copy_attr_all (d_inode (dentry),ecryptfs_inode_to_lower (d_inode (dentry)));
fs/ecryptfs/main.c +6 -18
@@ -106,15 +106,14 @@ static int ecryptfs_init_lower_file(struct dentry *dentry, struct file **lower_file) {const struct cred *cred =current_cred (); -const struct path *path =ecryptfs_dentry_to_lower_path (dentry); +struct path path =ecryptfs_lower_path (dentry);int rc; - rc =ecryptfs_privileged_open (lower_file, path->dentry, path->mnt, - cred); + rc =ecryptfs_privileged_open (lower_file, path.dentry, path.mnt, cred);if (rc) {printk (KERN_ERR "Error opening lower file " "for lower_dentry [0x%p] and lower_mnt [0x%p]; " -"rc = [%d]\n" , path->dentry, path->mnt, rc); +"rc = [%d]\n" , path.dentry, path.mnt, rc); (*lower_file) =NULL ; }return rc;
@@ -437,7 +436,6 @@ static int ecryptfs_get_tree(struct fs_context *fc)struct ecryptfs_fs_context *ctx = fc->fs_private;struct ecryptfs_sb_info *sbi = fc->s_fs_info;struct ecryptfs_mount_crypt_stat *mount_crypt_stat; -struct ecryptfs_dentry_info *root_info;const char *err ="Getting sb failed" ;struct inode *inode;struct path path;
@@ -543,14 +541,8 @@ static int ecryptfs_get_tree(struct fs_context *fc) goto out_free; } - rc = -ENOMEM ; - root_info =kmem_cache_zalloc (ecryptfs_dentry_info_cache,GFP_KERNEL ); -if (!root_info) - goto out_free; - -/* ->kill_sb() will take care of root_info */ -ecryptfs_set_dentry_private (s->s_root, root_info); - root_info->lower_path = path; +ecryptfs_set_dentry_lower (s->s_root, path.dentry); + sbi->lower_mnt = path.mnt; s->s_flags |=SB_ACTIVE ; fc->root =dget (s->s_root);
@@ -580,6 +572,7 @@ static void ecryptfs_kill_block_super(struct super_block *sb)kill_anon_super (sb);if (!sb_info)return ; +mntput (sb_info->lower_mnt);ecryptfs_destroy_mount_crypt_stat (&sb_info->mount_crypt_stat);kmem_cache_free (ecryptfs_sb_info_cache, sb_info); }
@@ -667,11 +660,6 @@ static struct ecryptfs_cache_info { .name = "ecryptfs_file_cache", .size = sizeof(struct ecryptfs_file_info), }, - { - .cache = &ecryptfs_dentry_info_cache, - .name = "ecryptfs_dentry_info_cache", - .size = sizeof(struct ecryptfs_dentry_info), - }, { .cache = &ecryptfs_inode_info_cache, .name = "ecryptfs_inode_cache",
Signature · 1 line
2.47.2
Al Viro
maintainerRe: [PATCH v3 52/65] ecryptfs: get rid of pointless mount references in ecryptfs dentries
fs/ecryptfs/main.c static int ecryptfs_get_tree(struct fs_context *fc) · line 545
Quoted 1 line · Al Viro
fs/ecryptfs/main.c +1
-0+ sbi->lower_mnt = path.mnt;
Argh... That should be
+ ecryptfs_superblock_to_private(s)->lower_mnt = path.mnt;
Kudos to Dan Carpenter for catching that and it looks like I need to deal with the gap in testing that had let it through ;-/
Al Viro
maintainerPATCH v3 53/65 fs/namespace.c: sanitize descriptions for {__,}lookup_mnt()
In reply to Al ViroComments regarding "shadow mounts" were stale - no such thing anymore. Document the locking requirements for __lookup_mnt().
--- fs/namespace.c | 41 ++++++++++++----------------------------- 1 file changed, 12 insertions(+), 29 deletions(-)
fs/namespace.c +12 -29
@@ -825,24 +825,16 @@ static bool legitimize_mnt(struct vfsmount *bastard, unsigned seq) }/** -* __lookup_mnt - find first child mount +* __lookup_mnt - mount hash lookup * @mnt: parent mount -* @dentry: mountpoint +* @dentry: dentry of mountpoint * -* If @mnt has a child mount @c mounted @dentry find and return it. +* If @mnt has a child mount @c mounted on @dentry find and return it. +* Caller must either hold the spinlock component of @mount_lock or +* hold rcu_read_lock(), sample the seqcount component before the call +* and recheck it afterwards. * -* Note that the child mount @c need not be unique. There are cases -* where shadow mounts are created. For example, during mount -* propagation when a source mount @mnt whose root got overmounted by a -* mount @o after path lookup but before @namespace_sem could be -* acquired gets copied and propagated. So @mnt gets copied including -* @o. When @mnt is propagated to a destination mount @d that already -* has another mount @n mounted at the same mountpoint then the source -* mount @mnt will be tucked beneath @n, i.e., @n will be mounted on -* @mnt and @mnt mounted on @d. Now both @n and @o are mounted at @mnt -* on @dentry. -* -* Return: The first child of @mnt mounted @dentry or NULL. +* Return: The child of @mnt mounted on @dentry or %NULL. */ struct mount *__lookup_mnt (struct vfsmount *mnt,struct dentry *dentry) {
@@ -855,21 +847,12 @@ struct mount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)return NULL ; } -/* -* lookup_mnt - Return the first child mount mounted at path -* -* "First" means first mounted chronologically. If you create the -* following mounts: -* -* mount /dev/sda1 /mnt -* mount /dev/sda2 /mnt -* mount /dev/sda3 /mnt -* -* Then lookup_mnt() on the base /mnt dentry in the root mount will -* return successively the root dentry and vfsmount of /dev/sda1, then -* /dev/sda2, then /dev/sda3, then NULL. +/** +* lookup_mnt - Return the child mount mounted at given location +* @path: location in the namespace * -* lookup_mnt takes a reference to the found vfsmount. +* Acquires and returns a new reference to mount at given location +* or %NULL if nothing is mounted there. */ struct vfsmount *lookup_mnt (const struct path *path) {
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 54/63 open_detached_copy(): don't bother with mount_lock_hash()
In reply to Al Virowe are holding namespace_sem and a reference to root of tree; iterating through that tree does not need mount_lock. Neither does the insertion into the rbtree of new namespace or incrementing the mount count of that namespace.
--- fs/namespace.c | 2 -- 1 file changed, 2 deletions(-)
fs/namespace.c +0 -2
@@ -3086,14 +3086,12 @@ static struct file *open_detached_copy(struct path *path, bool recursive)return ERR_CAST (mnt); } -lock_mount_hash ();for (p = mnt; p; p =next_mnt (p, mnt)) {mnt_add_to_ns (ns, p); ns->nr_mounts++; } ns->root = mnt;mntget (&mnt->mnt); -unlock_mount_hash ();namespace_unlock ();mntput (path->mnt);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 54/65 path_has_submounts(): use guard(mount_locked_reader)
In reply to Al ViroNeeded there since the callback passed to d_walk() (path_check_mount()) is using __path_is_mountpoint(), which uses __lookup_mnt().
Has to be taken in the caller - d_walk() might take rename_lock spinlock component and that nests inside mount_lock.
--- fs/dcache.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/dcache.c +2 -2
@@ -1390,6 +1390,7 @@ struct check_mount {unsigned int mounted; }; +/* locks: mount_locked_reader && dentry->d_lock */ static enum d_walk_ret path_check_mount (void *data,struct dentry *dentry) {struct check_mount *info = data;
@@ -1416,9 +1417,8 @@ int path_has_submounts(const struct path *parent) {struct check_mount data = { .mnt = parent->mnt, .mounted =0 }; -read_seqlock_excl (&mount_lock); +guard (mount_locked_reader)();d_walk (parent->dentry, &data, path_check_mount); -read_sequnlock_excl (&mount_lock);return data.mounted; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 55/65 open_detached_copy(): don't bother with mount_lock_hash()
In reply to Al Virowe are holding namespace_sem and a reference to root of tree; iterating through that tree does not need mount_lock. Neither does the insertion into the rbtree of new namespace or incrementing the mount count of that namespace.
--- fs/namespace.c | 2 -- 1 file changed, 2 deletions(-)
fs/namespace.c +0 -2
@@ -3086,14 +3086,12 @@ static struct file *open_detached_copy(struct path *path, bool recursive)return ERR_CAST (mnt); } -lock_mount_hash ();for (p = mnt; p; p =next_mnt (p, mnt)) {mnt_add_to_ns (ns, p); ns->nr_mounts++; } ns->root = mnt;mntget (&mnt->mnt); -unlock_mount_hash ();namespace_unlock ();mntput (path->mnt);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 55/63 open_detached_copy(): separate creation of namespace into helper
In reply to Al Viro... and convert the helper to use of a guard(namespace_excl)
--- fs/namespace.c | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-)
fs/namespace.c +15 -9
@@ -3053,18 +3053,17 @@ static int do_loopback(const struct path *path, const char *old_name,return err; } -static struct file *open_detached_copy (struct path *path,bool recursive) +static struct mnt_namespace *get_detached_copy (const struct path *path,bool recursive) {struct mnt_namespace *ns, *mnt_ns = current->nsproxy->mnt_ns, *src_mnt_ns;struct user_namespace *user_ns = mnt_ns->user_ns;struct mount *mnt, *p; -struct file *file; ns =alloc_mnt_ns (user_ns, true);if (IS_ERR (ns)) -return ERR_CAST (ns); +return ns; -namespace_lock (); +guard (namespace_excl)();/* * Record the sequence number of the source mount namespace.
@@ -3081,8 +3080,7 @@ static struct file *open_detached_copy(struct path *path, bool recursive) mnt =__do_loopback (path, recursive);if (IS_ERR (mnt)) { -namespace_unlock (); -free_mnt_ns (ns); + emptied_ns = ns;return ERR_CAST (mnt); }
@@ -3091,11 +3089,19 @@ static struct file *open_detached_copy(struct path *path, bool recursive) ns->nr_mounts++; } ns->root = mnt; -mntget (&mnt->mnt); -namespace_unlock (); +return ns; +} + +static struct file *open_detached_copy (struct path *path,bool recursive) +{ +struct mnt_namespace *ns =get_detached_copy (path, recursive); +struct file *file; + +if (IS_ERR (ns)) +return ERR_CAST (ns);mntput (path->mnt); - path->mnt = &mnt->mnt; + path->mnt =mntget (&ns->root->mnt); file =dentry_open (path,O_PATH ,current_cred ());if (IS_ERR (file))dissolve_on_fput (path->mnt);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 56/63 mnt_ns_tree_remove(): DTRT if mnt_ns had never been added to mnt_ns_list
In reply to Al ViroActual removal is done under the lock, but for checking if need to bother the lockless list_empty() is safe - either that namespace never had never been added to mnt_ns_tree, in which case the list will stay empty, or whoever had allocated it has called mnt_ns_tree_add() and it has already run to completion. After that point list_empty() will become false and will remain false, no matter what we do with the neighbors in mnt_ns_list.
--- fs/namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/namespace.c +1 -1
@@ -195,7 +195,7 @@ static void mnt_ns_release_rcu(struct rcu_head *rcu)static void mnt_ns_tree_remove (struct mnt_namespace *ns) {/* remove from global mount namespace list */ -if (!is_anon_ns (ns)) { +if (!list_empty (&ns->mnt_ns_list)) {mnt_ns_tree_write_lock ();rb_erase (&ns->mnt_ns_tree_node, &mnt_ns_tree);list_bidir_del_rcu (&ns->mnt_ns_list);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 56/65 open_detached_copy(): separate creation of namespace into helper
In reply to Al Viro... and convert the helper to use of a guard(namespace_excl)
--- fs/namespace.c | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-)
fs/namespace.c +15 -9
@@ -3053,18 +3053,17 @@ static int do_loopback(const struct path *path, const char *old_name,return err; } -static struct file *open_detached_copy (struct path *path,bool recursive) +static struct mnt_namespace *get_detached_copy (const struct path *path,bool recursive) {struct mnt_namespace *ns, *mnt_ns = current->nsproxy->mnt_ns, *src_mnt_ns;struct user_namespace *user_ns = mnt_ns->user_ns;struct mount *mnt, *p; -struct file *file; ns =alloc_mnt_ns (user_ns, true);if (IS_ERR (ns)) -return ERR_CAST (ns); +return ns; -namespace_lock (); +guard (namespace_excl)();/* * Record the sequence number of the source mount namespace.
@@ -3081,8 +3080,7 @@ static struct file *open_detached_copy(struct path *path, bool recursive) mnt =__do_loopback (path, recursive);if (IS_ERR (mnt)) { -namespace_unlock (); -free_mnt_ns (ns); + emptied_ns = ns;return ERR_CAST (mnt); }
@@ -3091,11 +3089,19 @@ static struct file *open_detached_copy(struct path *path, bool recursive) ns->nr_mounts++; } ns->root = mnt; -mntget (&mnt->mnt); -namespace_unlock (); +return ns; +} + +static struct file *open_detached_copy (struct path *path,bool recursive) +{ +struct mnt_namespace *ns =get_detached_copy (path, recursive); +struct file *file; + +if (IS_ERR (ns)) +return ERR_CAST (ns);mntput (path->mnt); - path->mnt = &mnt->mnt; + path->mnt =mntget (&ns->root->mnt); file =dentry_open (path,O_PATH ,current_cred ());if (IS_ERR (file))dissolve_on_fput (path->mnt);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 57/63 copy_mnt_ns(): use the regular mechanism for freeing empty mnt_ns on failure
In reply to Al ViroNow that free_mnt_ns() works prior to mnt_ns_tree_add(), there's no need for an open-coded analogue free_mnt_ns() there - yes, we do avoid one call_rcu() use per failing call of clone() or unshare(), if they fail due to OOM in that particular spot, but it's not really worth bothering.
--- fs/namespace.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
fs/namespace.c +1 -3
@@ -4190,10 +4190,8 @@ struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns, copy_flags |=CL_SLAVE ; new =copy_tree (old, old->mnt.mnt_root, copy_flags);if (IS_ERR (new)) { + emptied_ns = new_ns;namespace_unlock (); -ns_free_inum (&new_ns->ns); -dec_mnt_namespaces (new_ns->ucounts); -mnt_ns_release (new_ns);return ERR_CAST (new); }if (user_ns != ns->user_ns) {
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 57/65 mnt_ns_tree_remove(): DTRT if mnt_ns had never been added to mnt_ns_list
In reply to Al ViroActual removal is done under the lock, but for checking if need to bother the lockless list_empty() is safe - either that namespace had never been added to mnt_ns_tree, in which case the list will stay empty, or whoever had allocated it has called mnt_ns_tree_add() and it has already run to completion. After that point list_empty() will become false and will remain false, no matter what we do with the neighbors in mnt_ns_list.
--- fs/namespace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/namespace.c +1 -1
@@ -195,7 +195,7 @@ static void mnt_ns_release_rcu(struct rcu_head *rcu)static void mnt_ns_tree_remove (struct mnt_namespace *ns) {/* remove from global mount namespace list */ -if (!is_anon_ns (ns)) { +if (!list_empty (&ns->mnt_ns_list)) {mnt_ns_tree_write_lock ();rb_erase (&ns->mnt_ns_tree_node, &mnt_ns_tree);list_bidir_del_rcu (&ns->mnt_ns_list);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 58/63 copy_mnt_ns(): use guards
In reply to Al Viro* mntput() of rootmnt and pwdmnt done via __free(mntput)
* mnt_ns_tree_add() can be done within namespace_excl scope.
--- fs/namespace.c | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-)
fs/namespace.c +4 -13
@@ -4164,7 +4164,8 @@ struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns, struct user_namespace *user_ns, struct fs_struct *new_fs) { struct mnt_namespace *new_ns; -struct vfsmount *rootmnt =NULL , *pwdmnt =NULL ; + struct vfsmount *rootmnt __free(mntput) = NULL; + struct vfsmount *pwdmnt __free(mntput) = NULL;struct mount *p, *q;struct mount *old;struct mount *new;
@@ -4183,7 +4184,7 @@ struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns,if (IS_ERR (new_ns))return new_ns; -namespace_lock (); +guard (namespace_excl)();/* First pass: copy the tree topology */ copy_flags =CL_COPY_UNBINDABLE |CL_EXPIRE ;if (user_ns != ns->user_ns)
@@ -4191,13 +4192,11 @@ struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns, new =copy_tree (old, old->mnt.mnt_root, copy_flags);if (IS_ERR (new)) { emptied_ns = new_ns; -namespace_unlock ();return ERR_CAST (new); }if (user_ns != ns->user_ns) { -lock_mount_hash (); +guard (mount_writer)();lock_mnt_tree (new); -unlock_mount_hash (); } new_ns->root = new;
@@ -4229,14 +4228,6 @@ struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns,while (p->mnt.mnt_root != q->mnt.mnt_root) p =next_mnt (skip_mnt_tree (p), old); } -namespace_unlock (); - -if (rootmnt) -mntput (rootmnt); -if (pwdmnt) -mntput (pwdmnt); - -mnt_ns_tree_add (new_ns);return new_ns; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 58/65 copy_mnt_ns(): use the regular mechanism for freeing empty mnt_ns on failure
In reply to Al ViroNow that free_mnt_ns() works prior to mnt_ns_tree_add(), there's no need for an open-coded analogue free_mnt_ns() there - yes, we do avoid one call_rcu() use per failing call of clone() or unshare(), if they fail due to OOM in that particular spot, but it's not really worth bothering.
--- fs/namespace.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
fs/namespace.c +1 -3
@@ -4190,10 +4190,8 @@ struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns, copy_flags |=CL_SLAVE ; new =copy_tree (old, old->mnt.mnt_root, copy_flags);if (IS_ERR (new)) { + emptied_ns = new_ns;namespace_unlock (); -ns_free_inum (&new_ns->ns); -dec_mnt_namespaces (new_ns->ucounts); -mnt_ns_release (new_ns);return ERR_CAST (new); }if (user_ns != ns->user_ns) {
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 59/65 copy_mnt_ns(): use guards
In reply to Al Viro* mntput() of rootmnt and pwdmnt done via __free(mntput)
* mnt_ns_tree_add() can be done within namespace_excl scope.
--- fs/namespace.c | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-)
fs/namespace.c +4 -12
@@ -4164,7 +4164,8 @@ struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns, struct user_namespace *user_ns, struct fs_struct *new_fs) { struct mnt_namespace *new_ns; -struct vfsmount *rootmnt =NULL , *pwdmnt =NULL ; + struct vfsmount *rootmnt __free(mntput) = NULL; + struct vfsmount *pwdmnt __free(mntput) = NULL;struct mount *p, *q;struct mount *old;struct mount *new;
@@ -4183,7 +4184,7 @@ struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns,if (IS_ERR (new_ns))return new_ns; -namespace_lock (); +guard (namespace_excl)();/* First pass: copy the tree topology */ copy_flags =CL_COPY_UNBINDABLE |CL_EXPIRE ;if (user_ns != ns->user_ns)
@@ -4191,13 +4192,11 @@ struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns, new =copy_tree (old, old->mnt.mnt_root, copy_flags);if (IS_ERR (new)) { emptied_ns = new_ns; -namespace_unlock ();return ERR_CAST (new); }if (user_ns != ns->user_ns) { -lock_mount_hash (); +guard (mount_writer)();lock_mnt_tree (new); -unlock_mount_hash (); } new_ns->root = new;
@@ -4229,13 +4228,6 @@ struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns,while (p->mnt.mnt_root != q->mnt.mnt_root) p =next_mnt (skip_mnt_tree (p), old); } -namespace_unlock (); - -if (rootmnt) -mntput (rootmnt); -if (pwdmnt) -mntput (pwdmnt); -mnt_ns_tree_add (new_ns);return new_ns; }
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 59/63 simplify the callers of mnt_unhold_writers()
In reply to Al ViroThe logics in cleanup on failure in mount_setattr_prepare() is simplified by having the mnt_hold_writers() failure followed by advancing m to the next node in the tree before leaving the loop.
And since all calls are preceded by the same check that flag has been set and the function is inlined, let's just shift the check into it.
--- fs/namespace.c | 34 ++++++++++------------------------ 1 file changed, 10 insertions(+), 24 deletions(-)
fs/namespace.c +10 -24
@@ -714,13 +714,14 @@ static inline int mnt_hold_writers(struct mount *mnt)* Stop preventing write access to @mnt allowing callers to gain write access * to @mnt again. * -* This function can only be called after a successful call to -* mnt_hold_writers(). +* This function can only be called after a call to mnt_hold_writers(). * * Context: This function expects lock_mount_hash() to be held. */ static inline void mnt_unhold_writers (struct mount *mnt) { +if (!(mnt->mnt_flags &MNT_WRITE_HOLD )) +return ;/* * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers * that become unheld will see MNT_READONLY.
@@ -4773,8 +4774,10 @@ static int mount_setattr_prepare(struct mount_kattr *kattr, struct mount *mnt)if (!mnt_allow_writers (kattr, m)) { err =mnt_hold_writers (m); -if (err) +if (err) { + m =next_mnt (m, mnt);break ; + } }if (!(kattr->kflags &MOUNT_KATTR_RECURSE ))
@@ -4782,25 +4785,9 @@ static int mount_setattr_prepare(struct mount_kattr *kattr, struct mount *mnt) }if (err) { -struct mount *p; - -/* -* If we had to call mnt_hold_writers() MNT_WRITE_HOLD will -* be set in @mnt_flags. The loop unsets MNT_WRITE_HOLD for all -* mounts and needs to take care to include the first mount. -*/ -for (p = mnt; p; p =next_mnt (p, mnt)) { -/* If we had to hold writers unblock them. */ -if (p->mnt.mnt_flags &MNT_WRITE_HOLD ) -mnt_unhold_writers (p); - -/* -* We're done once the first mount we changed got -* MNT_WRITE_HOLD unset. -*/ -if (p == m) -break ; - } +/* undo all mnt_hold_writers() we'd done */ +for (struct mount *p = mnt; p != m; p =next_mnt (p, mnt)) +mnt_unhold_writers (p); }return err; }
@@ -4831,8 +4818,7 @@ static void mount_setattr_commit(struct mount_kattr *kattr, struct mount *mnt)WRITE_ONCE (m->mnt.mnt_flags, flags);/* If we had to hold writers unblock them. */ -if (m->mnt.mnt_flags &MNT_WRITE_HOLD ) -mnt_unhold_writers (m); +mnt_unhold_writers (m);if (kattr->propagation)change_mnt_propagation (m, kattr->propagation);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 60/63 setup_mnt(): primitive for connecting a mount to filesystem
In reply to Al ViroTake the identical logics in vfs_create_mount() and clone_mnt() into a new helper that takes an empty struct mount and attaches it to given dentry (sub)tree.
Should be called once in the lifetime of every mount, prior to making it visible in any data structures.
After that point ->mnt_root and ->mnt_sb never change; ->mnt_root is a counting reference to dentry and ->mnt_sb - an active reference to superblock.
Mount remains associated with that dentry tree all the way until the call of cleanup_mnt(), when the refcount eventually drops to zero.
--- fs/namespace.c | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-)
fs/namespace.c +17 -17
@@ -1196,6 +1196,21 @@ static void commit_tree(struct mount *mnt)touch_mnt_namespace (n); } +static void setup_mnt (struct mount *m,struct dentry *root) +{ +struct super_block *s = root->d_sb; + +atomic_inc (&s->s_active); + m->mnt.mnt_sb = s; + m->mnt.mnt_root =dget (root); + m->mnt_mountpoint = m->mnt.mnt_root; + m->mnt_parent = m; + +lock_mount_hash (); +list_add_tail (&m->mnt_instance, &s->s_mounts); +unlock_mount_hash (); +} +/** * vfs_create_mount - Create a mount for a configured superblock * @fc: The configuration context with the superblock attached
@@ -1219,15 +1234,8 @@ struct vfsmount *vfs_create_mount(struct fs_context *fc)if (fc->sb_flags &SB_KERNMOUNT ) mnt->mnt.mnt_flags =MNT_INTERNAL ; -atomic_inc (&fc->root->d_sb->s_active); - mnt->mnt.mnt_sb = fc->root->d_sb; - mnt->mnt.mnt_root =dget (fc->root); - mnt->mnt_mountpoint = mnt->mnt.mnt_root; - mnt->mnt_parent = mnt; +setup_mnt (mnt, fc->root); -lock_mount_hash (); -list_add_tail (&mnt->mnt_instance, &mnt->mnt.mnt_sb->s_mounts); -unlock_mount_hash ();return &mnt->mnt; }EXPORT_SYMBOL (vfs_create_mount);
@@ -1285,7 +1293,6 @@ EXPORT_SYMBOL_GPL(vfs_kern_mount);static struct mount *clone_mnt (struct mount *old,struct dentry *root,int flag) { -struct super_block *sb = old->mnt.mnt_sb;struct mount *mnt;int err;
@@ -1310,16 +1317,9 @@ static struct mount *clone_mnt(struct mount *old, struct dentry *root,if (mnt->mnt_group_id)set_mnt_shared (mnt); -atomic_inc (&sb->s_active); mnt->mnt.mnt_idmap =mnt_idmap_get (mnt_idmap (&old->mnt)); - mnt->mnt.mnt_sb = sb; - mnt->mnt.mnt_root =dget (root); - mnt->mnt_mountpoint = mnt->mnt.mnt_root; - mnt->mnt_parent = mnt; -lock_mount_hash (); -list_add_tail (&mnt->mnt_instance, &sb->s_mounts); -unlock_mount_hash (); +setup_mnt (mnt, root);if (flag &CL_PRIVATE )// we are done with it return mnt;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 60/65 simplify the callers of mnt_unhold_writers()
In reply to Al ViroThe logics in cleanup on failure in mount_setattr_prepare() is simplified by having the mnt_hold_writers() failure followed by advancing m to the next node in the tree before leaving the loop.
And since all calls are preceded by the same check that flag has been set and the function is inlined, let's just shift the check into it.
--- fs/namespace.c | 34 ++++++++++------------------------ 1 file changed, 10 insertions(+), 24 deletions(-)
fs/namespace.c +10 -24
@@ -714,13 +714,14 @@ static inline int mnt_hold_writers(struct mount *mnt)* Stop preventing write access to @mnt allowing callers to gain write access * to @mnt again. * -* This function can only be called after a successful call to -* mnt_hold_writers(). +* This function can only be called after a call to mnt_hold_writers(). * * Context: This function expects lock_mount_hash() to be held. */ static inline void mnt_unhold_writers (struct mount *mnt) { +if (!(mnt->mnt_flags &MNT_WRITE_HOLD )) +return ;/* * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers * that become unheld will see MNT_READONLY.
@@ -4774,8 +4775,10 @@ static int mount_setattr_prepare(struct mount_kattr *kattr, struct mount *mnt)if (!mnt_allow_writers (kattr, m)) { err =mnt_hold_writers (m); -if (err) +if (err) { + m =next_mnt (m, mnt);break ; + } }if (!(kattr->kflags &MOUNT_KATTR_RECURSE ))
@@ -4783,25 +4786,9 @@ static int mount_setattr_prepare(struct mount_kattr *kattr, struct mount *mnt) }if (err) { -struct mount *p; - -/* -* If we had to call mnt_hold_writers() MNT_WRITE_HOLD will -* be set in @mnt_flags. The loop unsets MNT_WRITE_HOLD for all -* mounts and needs to take care to include the first mount. -*/ -for (p = mnt; p; p =next_mnt (p, mnt)) { -/* If we had to hold writers unblock them. */ -if (p->mnt.mnt_flags &MNT_WRITE_HOLD ) -mnt_unhold_writers (p); - -/* -* We're done once the first mount we changed got -* MNT_WRITE_HOLD unset. -*/ -if (p == m) -break ; - } +/* undo all mnt_hold_writers() we'd done */ +for (struct mount *p = mnt; p != m; p =next_mnt (p, mnt)) +mnt_unhold_writers (p); }return err; }
@@ -4832,8 +4819,7 @@ static void mount_setattr_commit(struct mount_kattr *kattr, struct mount *mnt)WRITE_ONCE (m->mnt.mnt_flags, flags);/* If we had to hold writers unblock them. */ -if (m->mnt.mnt_flags &MNT_WRITE_HOLD ) -mnt_unhold_writers (m); +mnt_unhold_writers (m);if (kattr->propagation)change_mnt_propagation (m, kattr->propagation);
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 61/63 preparations to taking MNT_WRITE_HOLD out of ->mnt_flags
In reply to Al ViroWe have an unpleasant wart in accessibility rules for struct mount. There are per-superblock lists of mounts, used by sb_prepare_remount_readonly() to check if any of those is currently claimed for write access and to block further attempts to get write access on those until we are done.
As soon as it is attached to a filesystem, mount becomes reachable via that list. Only sb_prepare_remount_readonly() traverses it and it only accesses a few members of struct mount. Unfortunately, ->mnt_flags is one of those and it is modified - MNT_WRITE_HOLD set and then cleared. It is done under mount_lock, so from the locking rules POV everything's fine.
However, it has easily overlooked implications - once mount has been attached to a filesystem, it has to be treated as globally visible. In particular, initializing ->mnt_flags *must* be done either prior to that point or under mount_lock. All other members are still private at that point.
Life gets simpler if we move that bit (and that's *all* that can get touched by access via this list) out of ->mnt_flags. It's not even hard to do - currently the list is implemented as list_head one, anchored in super_block->s_mounts and linked via mount->mnt_instance.
As the first step, switch it to hlist-like open-coded structure - address of the first mount in the set is stored in ->s_mounts and ->mnt_instance replaced with ->mnt_next_for_sb and ->mnt_pprev_for_sb - the former either NULL or pointing to the next mount in set, the latter - address of either ->s_mounts or ->mnt_next_for_sb in the previous element of the set.
In the next commit we'll steal the LSB of ->mnt_pprev_for_sb as replacement for MNT_WRITE_HOLD.
--- fs/mount.h | 4 +++- fs/namespace.c | 38 +++++++++++++++++++++++++++++--------- fs/super.c | 3 +-- include/linux/fs.h | 4 +++- 4 files changed, 36 insertions(+), 13 deletions(-)
fs/mount.h +3 -1
@@ -64,7 +64,9 @@ struct mount {#endif struct list_head mnt_mounts;/* list of children, anchored here */ struct list_head mnt_child;/* and going through their mnt_child */ -struct list_head mnt_instance;/* mount instance on sb->s_mounts */ +struct mount *mnt_next_for_sb;/* the next two fields are hlist_node, */ +struct mount *__aligned(1) *mnt_pprev_for_sb; +/* except that LSB of pprev will be stolen */ const char *mnt_devname;/* Name of device e.g. /dev/dsk/hda1 */ struct list_head mnt_list;struct list_head mnt_expire;/* link in fs-specific expiry list */
fs/namespace.c +29 -9
@@ -730,6 +730,27 @@ static inline void mnt_unhold_writers(struct mount *mnt) mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; } +static inline void mnt_del_instance (struct mount *m) +{ +struct mount **p = m->mnt_pprev_for_sb; +struct mount *next = m->mnt_next_for_sb; + +if (next) + next->mnt_pprev_for_sb = p; + *p = next; +} + +static inline void mnt_add_instance (struct mount *m,struct super_block *s) +{ +struct mount *first = s->s_mounts; + +if (first) + first->mnt_pprev_for_sb = &m->mnt_next_for_sb; + m->mnt_next_for_sb = first; + m->mnt_pprev_for_sb = &s->s_mounts; + s->s_mounts = m; +} +static int mnt_make_readonly (struct mount *mnt) {int ret;
@@ -743,7 +764,6 @@ static int mnt_make_readonly(struct mount *mnt)int sb_prepare_remount_readonly (struct super_block *sb) { -struct mount *mnt;int err =0 ;/* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */
@@ -751,9 +771,9 @@ int sb_prepare_remount_readonly(struct super_block *sb)return -EBUSY ;lock_mount_hash (); -list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) { -if (!(mnt->mnt.mnt_flags &MNT_READONLY )) { - err =mnt_hold_writers (mnt); +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { +if (!(m->mnt.mnt_flags &MNT_READONLY )) { + err =mnt_hold_writers (m);if (err)break ; }
@@ -763,9 +783,9 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (!err)sb_start_ro_state_change (sb); -list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) { -if (mnt->mnt.mnt_flags &MNT_WRITE_HOLD ) - mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { +if (m->mnt.mnt_flags &MNT_WRITE_HOLD ) + m->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; }unlock_mount_hash ();
@@ -1207,7 +1227,7 @@ static void setup_mnt(struct mount *m, struct dentry *root) m->mnt_parent = m;lock_mount_hash (); -list_add_tail (&m->mnt_instance, &s->s_mounts); +mnt_add_instance (m, s);unlock_mount_hash (); }
@@ -1425,7 +1445,7 @@ static void mntput_no_expire(struct mount *mnt) mnt->mnt.mnt_flags |=MNT_DOOMED ;rcu_read_unlock (); -list_del (&mnt->mnt_instance); +mnt_del_instance (mnt);if (unlikely (!list_empty (&mnt->mnt_expire)))list_del (&mnt->mnt_expire);
fs/super.c +1 -2
@@ -323,7 +323,6 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags,if (!s)return NULL ; -INIT_LIST_HEAD (&s->s_mounts); s->s_user_ns =get_user_ns (user_ns);init_rwsem (&s->s_umount);lockdep_set_class (&s->s_umount, &type->s_umount_key);
@@ -408,7 +407,7 @@ static void __put_super(struct super_block *s)list_del_init (&s->s_list);WARN_ON (s->s_dentry_lru.node);WARN_ON (s->s_inode_lru.node); -WARN_ON (!list_empty (&s->s_mounts)); +WARN_ON (s->s_mounts);call_rcu (&s->rcu, destroy_super_rcu); } }
include/linux/fs.h +3 -1
@@ -1324,6 +1324,8 @@ struct sb_writers {struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS ]; }; +struct mount ; +struct super_block {struct list_head s_list;/* Keep this first */ dev_t s_dev;/* search index; _not_ kdev_t */
@@ -1358,7 +1360,7 @@ struct super_block {__u16 s_encoding_flags;#endif struct hlist_bl_head s_roots;/* alternate root dentries for NFS */ -struct list_head s_mounts;/* list of mounts; _not_ for fs use */ +struct mount *s_mounts;/* list of mounts; _not_ for fs use */ struct block_device *s_bdev;/* can go away once we use an accessor for @s_bdev_file */ struct file *s_bdev_file;struct backing_dev_info *s_bdi;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 61/65 setup_mnt(): primitive for connecting a mount to filesystem
In reply to Al ViroTake the identical logics in vfs_create_mount() and clone_mnt() into a new helper that takes an empty struct mount and attaches it to given dentry (sub)tree.
Should be called once in the lifetime of every mount, prior to making it visible in any data structures.
After that point ->mnt_root and ->mnt_sb never change; ->mnt_root is a counting reference to dentry and ->mnt_sb - an active reference to superblock.
Mount remains associated with that dentry tree all the way until the call of cleanup_mnt(), when the refcount eventually drops to zero.
--- fs/namespace.c | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-)
fs/namespace.c +17 -17
@@ -1196,6 +1196,21 @@ static void commit_tree(struct mount *mnt)touch_mnt_namespace (n); } +static void setup_mnt (struct mount *m,struct dentry *root) +{ +struct super_block *s = root->d_sb; + +atomic_inc (&s->s_active); + m->mnt.mnt_sb = s; + m->mnt.mnt_root =dget (root); + m->mnt_mountpoint = m->mnt.mnt_root; + m->mnt_parent = m; + +lock_mount_hash (); +list_add_tail (&m->mnt_instance, &s->s_mounts); +unlock_mount_hash (); +} +/** * vfs_create_mount - Create a mount for a configured superblock * @fc: The configuration context with the superblock attached
@@ -1219,15 +1234,8 @@ struct vfsmount *vfs_create_mount(struct fs_context *fc)if (fc->sb_flags &SB_KERNMOUNT ) mnt->mnt.mnt_flags =MNT_INTERNAL ; -atomic_inc (&fc->root->d_sb->s_active); - mnt->mnt.mnt_sb = fc->root->d_sb; - mnt->mnt.mnt_root =dget (fc->root); - mnt->mnt_mountpoint = mnt->mnt.mnt_root; - mnt->mnt_parent = mnt; +setup_mnt (mnt, fc->root); -lock_mount_hash (); -list_add_tail (&mnt->mnt_instance, &mnt->mnt.mnt_sb->s_mounts); -unlock_mount_hash ();return &mnt->mnt; }EXPORT_SYMBOL (vfs_create_mount);
@@ -1285,7 +1293,6 @@ EXPORT_SYMBOL_GPL(vfs_kern_mount);static struct mount *clone_mnt (struct mount *old,struct dentry *root,int flag) { -struct super_block *sb = old->mnt.mnt_sb;struct mount *mnt;int err;
@@ -1310,16 +1317,9 @@ static struct mount *clone_mnt(struct mount *old, struct dentry *root,if (mnt->mnt_group_id)set_mnt_shared (mnt); -atomic_inc (&sb->s_active); mnt->mnt.mnt_idmap =mnt_idmap_get (mnt_idmap (&old->mnt)); - mnt->mnt.mnt_sb = sb; - mnt->mnt.mnt_root =dget (root); - mnt->mnt_mountpoint = mnt->mnt.mnt_root; - mnt->mnt_parent = mnt; -lock_mount_hash (); -list_add_tail (&mnt->mnt_instance, &sb->s_mounts); -unlock_mount_hash (); +setup_mnt (mnt, root);if (flag &CL_PRIVATE )// we are done with it return mnt;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 62/65 preparations to taking MNT_WRITE_HOLD out of ->mnt_flags
In reply to Al ViroWe have an unpleasant wart in accessibility rules for struct mount. There are per-superblock lists of mounts, used by sb_prepare_remount_readonly() to check if any of those is currently claimed for write access and to block further attempts to get write access on those until we are done.
As soon as it is attached to a filesystem, mount becomes reachable via that list. Only sb_prepare_remount_readonly() traverses it and it only accesses a few members of struct mount. Unfortunately, ->mnt_flags is one of those and it is modified - MNT_WRITE_HOLD set and then cleared. It is done under mount_lock, so from the locking rules POV everything's fine.
However, it has easily overlooked implications - once mount has been attached to a filesystem, it has to be treated as globally visible. In particular, initializing ->mnt_flags *must* be done either prior to that point or under mount_lock. All other members are still private at that point.
Life gets simpler if we move that bit (and that's *all* that can get touched by access via this list) out of ->mnt_flags. It's not even hard to do - currently the list is implemented as list_head one, anchored in super_block->s_mounts and linked via mount->mnt_instance.
As the first step, switch it to hlist-like open-coded structure - address of the first mount in the set is stored in ->s_mounts and ->mnt_instance replaced with ->mnt_next_for_sb and ->mnt_pprev_for_sb - the former either NULL or pointing to the next mount in set, the latter - address of either ->s_mounts or ->mnt_next_for_sb in the previous element of the set.
In the next commit we'll steal the LSB of ->mnt_pprev_for_sb as replacement for MNT_WRITE_HOLD.
--- fs/mount.h | 4 +++- fs/namespace.c | 38 +++++++++++++++++++++++++++++--------- fs/super.c | 3 +-- include/linux/fs.h | 4 +++- 4 files changed, 36 insertions(+), 13 deletions(-)
fs/mount.h +3 -1
@@ -64,7 +64,9 @@ struct mount {#endif struct list_head mnt_mounts;/* list of children, anchored here */ struct list_head mnt_child;/* and going through their mnt_child */ -struct list_head mnt_instance;/* mount instance on sb->s_mounts */ +struct mount *mnt_next_for_sb;/* the next two fields are hlist_node, */ +struct mount *__aligned(1) *mnt_pprev_for_sb; +/* except that LSB of pprev will be stolen */ const char *mnt_devname;/* Name of device e.g. /dev/dsk/hda1 */ struct list_head mnt_list;struct list_head mnt_expire;/* link in fs-specific expiry list */
fs/namespace.c +29 -9
@@ -730,6 +730,27 @@ static inline void mnt_unhold_writers(struct mount *mnt) mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; } +static inline void mnt_del_instance (struct mount *m) +{ +struct mount **p = m->mnt_pprev_for_sb; +struct mount *next = m->mnt_next_for_sb; + +if (next) + next->mnt_pprev_for_sb = p; + *p = next; +} + +static inline void mnt_add_instance (struct mount *m,struct super_block *s) +{ +struct mount *first = s->s_mounts; + +if (first) + first->mnt_pprev_for_sb = &m->mnt_next_for_sb; + m->mnt_next_for_sb = first; + m->mnt_pprev_for_sb = &s->s_mounts; + s->s_mounts = m; +} +static int mnt_make_readonly (struct mount *mnt) {int ret;
@@ -743,7 +764,6 @@ static int mnt_make_readonly(struct mount *mnt)int sb_prepare_remount_readonly (struct super_block *sb) { -struct mount *mnt;int err =0 ;/* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */
@@ -751,9 +771,9 @@ int sb_prepare_remount_readonly(struct super_block *sb)return -EBUSY ;lock_mount_hash (); -list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) { -if (!(mnt->mnt.mnt_flags &MNT_READONLY )) { - err =mnt_hold_writers (mnt); +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { +if (!(m->mnt.mnt_flags &MNT_READONLY )) { + err =mnt_hold_writers (m);if (err)break ; }
@@ -763,9 +783,9 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (!err)sb_start_ro_state_change (sb); -list_for_each_entry (mnt, &sb->s_mounts, mnt_instance) { -if (mnt->mnt.mnt_flags &MNT_WRITE_HOLD ) - mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { +if (m->mnt.mnt_flags &MNT_WRITE_HOLD ) + m->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; }unlock_mount_hash ();
@@ -1207,7 +1227,7 @@ static void setup_mnt(struct mount *m, struct dentry *root) m->mnt_parent = m;lock_mount_hash (); -list_add_tail (&m->mnt_instance, &s->s_mounts); +mnt_add_instance (m, s);unlock_mount_hash (); }
@@ -1425,7 +1445,7 @@ static void mntput_no_expire(struct mount *mnt) mnt->mnt.mnt_flags |=MNT_DOOMED ;rcu_read_unlock (); -list_del (&mnt->mnt_instance); +mnt_del_instance (mnt);if (unlikely (!list_empty (&mnt->mnt_expire)))list_del (&mnt->mnt_expire);
fs/super.c +1 -2
@@ -323,7 +323,6 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags,if (!s)return NULL ; -INIT_LIST_HEAD (&s->s_mounts); s->s_user_ns =get_user_ns (user_ns);init_rwsem (&s->s_umount);lockdep_set_class (&s->s_umount, &type->s_umount_key);
@@ -408,7 +407,7 @@ static void __put_super(struct super_block *s)list_del_init (&s->s_list);WARN_ON (s->s_dentry_lru.node);WARN_ON (s->s_inode_lru.node); -WARN_ON (!list_empty (&s->s_mounts)); +WARN_ON (s->s_mounts);call_rcu (&s->rcu, destroy_super_rcu); } }
include/linux/fs.h +3 -1
@@ -1324,6 +1324,8 @@ struct sb_writers {struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS ]; }; +struct mount ; +struct super_block {struct list_head s_list;/* Keep this first */ dev_t s_dev;/* search index; _not_ kdev_t */
@@ -1358,7 +1360,7 @@ struct super_block {__u16 s_encoding_flags;#endif struct hlist_bl_head s_roots;/* alternate root dentries for NFS */ -struct list_head s_mounts;/* list of mounts; _not_ for fs use */ +struct mount *s_mounts;/* list of mounts; _not_ for fs use */ struct block_device *s_bdev;/* can go away once we use an accessor for @s_bdev_file */ struct file *s_bdev_file;struct backing_dev_info *s_bdi;
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 62/63 struct mount: relocate MNT_WRITE_HOLD bit
In reply to Al Viro... from ->mnt_flags to LSB of ->mnt_pprev_for_sb.
This is safe - we always set and clear it within the same mount_lock scope, so we won't interfere with list operations - traversals are always forward, so they don't even look at ->mnt_prev_for_sb and both insertions and removals are in mount_lock scopes of their own, so that bit will be clear in *all* mount instances during those.
--- fs/mount.h | 25 ++++++++++++++++++++++++- fs/namespace.c | 34 +++++++++++++++++----------------- include/linux/mount.h | 3 +-- 3 files changed, 42 insertions(+), 20 deletions(-)
fs/mount.h +24 -1
@@ -66,7 +66,8 @@ struct mount {struct list_head mnt_child;/* and going through their mnt_child */ struct mount *mnt_next_for_sb;/* the next two fields are hlist_node, */ struct mount *__aligned(1) *mnt_pprev_for_sb; -/* except that LSB of pprev will be stolen */ +/* except that LSB of pprev is stolen */ +#define WRITE_HOLD 1/* ... for use by mnt_hold_writers() */ const char *mnt_devname;/* Name of device e.g. /dev/dsk/hda1 */ struct list_head mnt_list;struct list_head mnt_expire;/* link in fs-specific expiry list */
@@ -244,4 +245,26 @@ static inline struct mount *topmost_overmount(struct mount *m)return m; } +static inline bool __test_write_hold (struct mount *__aligned(1) *val) +{ +return (unsigned long )val &WRITE_HOLD ; +} + +static inline bool test_write_hold (const struct mount *m) +{ +return __test_write_hold (m->mnt_pprev_for_sb); +} + +static inline void set_write_hold (struct mount *m) +{ + m->mnt_pprev_for_sb = (void *)((unsigned long )m->mnt_pprev_for_sb + |WRITE_HOLD ); +} + +static inline void clear_write_hold (struct mount *m) +{ + m->mnt_pprev_for_sb = (void *)((unsigned long )m->mnt_pprev_for_sb + & ~WRITE_HOLD ); +} +struct mnt_namespace *mnt_ns_from_dentry (struct dentry *dentry);
fs/namespace.c +17 -17
@@ -509,20 +509,20 @@ int mnt_get_write_access(struct vfsmount *m)mnt_inc_writers (mnt);/* * The store to mnt_inc_writers must be visible before we pass -* MNT_WRITE_HOLD loop below, so that the slowpath can see our -* incremented count after it has set MNT_WRITE_HOLD. +* WRITE_HOLD loop below, so that the slowpath can see our +* incremented count after it has set WRITE_HOLD. */ smp_mb ();might_lock (&mount_lock.lock); -while (READ_ONCE (mnt->mnt.mnt_flags) &MNT_WRITE_HOLD ) { +while (__test_write_hold (READ_ONCE (mnt->mnt_pprev_for_sb))) {if (!IS_ENABLED (CONFIG_PREEMPT_RT )) {cpu_relax (); }else {/* * This prevents priority inversion, if the task -* setting MNT_WRITE_HOLD got preempted on a remote +* setting WRITE_HOLD got preempted on a remote * CPU, and it prevents life lock if the task setting -* MNT_WRITE_HOLD has a lower priority and is bound to +* WRITE_HOLD has a lower priority and is bound to * the same CPU as the task that is spinning here. */ preempt_enable ();
@@ -533,7 +533,7 @@ int mnt_get_write_access(struct vfsmount *m) }/* * The barrier pairs with the barrier sb_start_ro_state_change() making -* sure that if we see MNT_WRITE_HOLD cleared, we will also see +* sure that if we see WRITE_HOLD cleared, we will also see * s_readonly_remount set (or even SB_RDONLY / MNT_READONLY flags) in * mnt_is_readonly() and bail in case we are racing with remount * read-only.
@@ -672,15 +672,15 @@ EXPORT_SYMBOL(mnt_drop_write_file);* @mnt. * * Context: This function expects lock_mount_hash() to be held serializing -* setting MNT_WRITE_HOLD. +* setting WRITE_HOLD. * Return: On success 0 is returned. * On error, -EBUSY is returned. */ static inline int mnt_hold_writers (struct mount *mnt) { - mnt->mnt.mnt_flags |=MNT_WRITE_HOLD ; +set_write_hold (mnt);/* -* After storing MNT_WRITE_HOLD, we'll read the counters. This store +* After storing WRITE_HOLD, we'll read the counters. This store * should be visible before we do. */ smp_mb ();
@@ -696,9 +696,9 @@ static inline int mnt_hold_writers(struct mount *mnt)* sum up each counter, if we read a counter before it is incremented, * but then read another CPU's count which it has been subsequently * decremented from -- we would see more decrements than we should. -* MNT_WRITE_HOLD protects against this scenario, because +* WRITE_HOLD protects against this scenario, because * mnt_want_write first increments count, then smp_mb, then spins on -* MNT_WRITE_HOLD, so it can't be decremented by another CPU while +* WRITE_HOLD, so it can't be decremented by another CPU while * we're counting up here. */ if (mnt_get_writers (mnt) >0 )
@@ -720,14 +720,14 @@ static inline int mnt_hold_writers(struct mount *mnt)*/ static inline void mnt_unhold_writers (struct mount *mnt) { -if (!(mnt->mnt_flags &MNT_WRITE_HOLD )) +if (!test_write_hold (mnt))return ;/* -* MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers +* MNT_READONLY must become visible before ~WRITE_HOLD, so writers * that become unheld will see MNT_READONLY. */ smp_wmb (); - mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; +clear_write_hold (mnt); }static inline void mnt_del_instance (struct mount *m)
@@ -766,7 +766,7 @@ int sb_prepare_remount_readonly(struct super_block *sb) {int err =0 ; -/* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */ +/* Racy optimization. Recheck the counter under WRITE_HOLD */ if (atomic_long_read (&sb->s_remove_count))return -EBUSY ;
@@ -784,8 +784,8 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (!err)sb_start_ro_state_change (sb);for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { -if (m->mnt.mnt_flags &MNT_WRITE_HOLD ) - m->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; +if (test_write_hold (m)) +clear_write_hold (m); }unlock_mount_hash ();
include/linux/mount.h +1 -2
@@ -33,7 +33,6 @@ enum mount_flags {MNT_NOSYMFOLLOW =0x80 ,MNT_SHRINKABLE =0x100 , -MNT_WRITE_HOLD =0x200 , MNT_INTERNAL = 0x4000,
@@ -52,7 +51,7 @@ enum mount_flags { | MNT_READONLY | MNT_NOSYMFOLLOW,MNT_ATIME_MASK =MNT_NOATIME |MNT_NODIRATIME |MNT_RELATIME , -MNT_INTERNAL_FLAGS =MNT_WRITE_HOLD |MNT_INTERNAL |MNT_DOOMED | +MNT_INTERNAL_FLAGS =MNT_INTERNAL |MNT_DOOMED | MNT_SYNC_UMOUNT | MNT_LOCKED };
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 63/65 struct mount: relocate MNT_WRITE_HOLD bit
In reply to Al Viro... from ->mnt_flags to LSB of ->mnt_pprev_for_sb.
This is safe - we always set and clear it within the same mount_lock scope, so we won't interfere with list operations - traversals are always forward, so they don't even look at ->mnt_prev_for_sb and both insertions and removals are in mount_lock scopes of their own, so that bit will be clear in *all* mount instances during those.
--- fs/mount.h | 25 ++++++++++++++++++++++++- fs/namespace.c | 34 +++++++++++++++++----------------- include/linux/mount.h | 3 +-- 3 files changed, 42 insertions(+), 20 deletions(-)
fs/mount.h +24 -1
@@ -66,7 +66,8 @@ struct mount {struct list_head mnt_child;/* and going through their mnt_child */ struct mount *mnt_next_for_sb;/* the next two fields are hlist_node, */ struct mount *__aligned(1) *mnt_pprev_for_sb; -/* except that LSB of pprev will be stolen */ +/* except that LSB of pprev is stolen */ +#define WRITE_HOLD 1/* ... for use by mnt_hold_writers() */ const char *mnt_devname;/* Name of device e.g. /dev/dsk/hda1 */ struct list_head mnt_list;struct list_head mnt_expire;/* link in fs-specific expiry list */
@@ -244,4 +245,26 @@ static inline struct mount *topmost_overmount(struct mount *m)return m; } +static inline bool __test_write_hold (struct mount *__aligned(1) *val) +{ +return (unsigned long )val &WRITE_HOLD ; +} + +static inline bool test_write_hold (const struct mount *m) +{ +return __test_write_hold (m->mnt_pprev_for_sb); +} + +static inline void set_write_hold (struct mount *m) +{ + m->mnt_pprev_for_sb = (void *)((unsigned long )m->mnt_pprev_for_sb + |WRITE_HOLD ); +} + +static inline void clear_write_hold (struct mount *m) +{ + m->mnt_pprev_for_sb = (void *)((unsigned long )m->mnt_pprev_for_sb + & ~WRITE_HOLD ); +} +struct mnt_namespace *mnt_ns_from_dentry (struct dentry *dentry);
fs/namespace.c +17 -17
@@ -509,20 +509,20 @@ int mnt_get_write_access(struct vfsmount *m)mnt_inc_writers (mnt);/* * The store to mnt_inc_writers must be visible before we pass -* MNT_WRITE_HOLD loop below, so that the slowpath can see our -* incremented count after it has set MNT_WRITE_HOLD. +* WRITE_HOLD loop below, so that the slowpath can see our +* incremented count after it has set WRITE_HOLD. */ smp_mb ();might_lock (&mount_lock.lock); -while (READ_ONCE (mnt->mnt.mnt_flags) &MNT_WRITE_HOLD ) { +while (__test_write_hold (READ_ONCE (mnt->mnt_pprev_for_sb))) {if (!IS_ENABLED (CONFIG_PREEMPT_RT )) {cpu_relax (); }else {/* * This prevents priority inversion, if the task -* setting MNT_WRITE_HOLD got preempted on a remote +* setting WRITE_HOLD got preempted on a remote * CPU, and it prevents life lock if the task setting -* MNT_WRITE_HOLD has a lower priority and is bound to +* WRITE_HOLD has a lower priority and is bound to * the same CPU as the task that is spinning here. */ preempt_enable ();
@@ -533,7 +533,7 @@ int mnt_get_write_access(struct vfsmount *m) }/* * The barrier pairs with the barrier sb_start_ro_state_change() making -* sure that if we see MNT_WRITE_HOLD cleared, we will also see +* sure that if we see WRITE_HOLD cleared, we will also see * s_readonly_remount set (or even SB_RDONLY / MNT_READONLY flags) in * mnt_is_readonly() and bail in case we are racing with remount * read-only.
@@ -672,15 +672,15 @@ EXPORT_SYMBOL(mnt_drop_write_file);* @mnt. * * Context: This function expects lock_mount_hash() to be held serializing -* setting MNT_WRITE_HOLD. +* setting WRITE_HOLD. * Return: On success 0 is returned. * On error, -EBUSY is returned. */ static inline int mnt_hold_writers (struct mount *mnt) { - mnt->mnt.mnt_flags |=MNT_WRITE_HOLD ; +set_write_hold (mnt);/* -* After storing MNT_WRITE_HOLD, we'll read the counters. This store +* After storing WRITE_HOLD, we'll read the counters. This store * should be visible before we do. */ smp_mb ();
@@ -696,9 +696,9 @@ static inline int mnt_hold_writers(struct mount *mnt)* sum up each counter, if we read a counter before it is incremented, * but then read another CPU's count which it has been subsequently * decremented from -- we would see more decrements than we should. -* MNT_WRITE_HOLD protects against this scenario, because +* WRITE_HOLD protects against this scenario, because * mnt_want_write first increments count, then smp_mb, then spins on -* MNT_WRITE_HOLD, so it can't be decremented by another CPU while +* WRITE_HOLD, so it can't be decremented by another CPU while * we're counting up here. */ if (mnt_get_writers (mnt) >0 )
@@ -720,14 +720,14 @@ static inline int mnt_hold_writers(struct mount *mnt)*/ static inline void mnt_unhold_writers (struct mount *mnt) { -if (!(mnt->mnt_flags &MNT_WRITE_HOLD )) +if (!test_write_hold (mnt))return ;/* -* MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers +* MNT_READONLY must become visible before ~WRITE_HOLD, so writers * that become unheld will see MNT_READONLY. */ smp_wmb (); - mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; +clear_write_hold (mnt); }static inline void mnt_del_instance (struct mount *m)
@@ -766,7 +766,7 @@ int sb_prepare_remount_readonly(struct super_block *sb) {int err =0 ; -/* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */ +/* Racy optimization. Recheck the counter under WRITE_HOLD */ if (atomic_long_read (&sb->s_remove_count))return -EBUSY ;
@@ -784,8 +784,8 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (!err)sb_start_ro_state_change (sb);for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) { -if (m->mnt.mnt_flags &MNT_WRITE_HOLD ) - m->mnt.mnt_flags &= ~MNT_WRITE_HOLD ; +if (test_write_hold (m)) +clear_write_hold (m); }unlock_mount_hash ();
include/linux/mount.h +1 -2
@@ -33,7 +33,6 @@ enum mount_flags {MNT_NOSYMFOLLOW =0x80 ,MNT_SHRINKABLE =0x100 , -MNT_WRITE_HOLD =0x200 , MNT_INTERNAL = 0x4000,
@@ -52,7 +51,7 @@ enum mount_flags { | MNT_READONLY | MNT_NOSYMFOLLOW,MNT_ATIME_MASK =MNT_NOATIME |MNT_NODIRATIME |MNT_RELATIME , -MNT_INTERNAL_FLAGS =MNT_WRITE_HOLD |MNT_INTERNAL |MNT_DOOMED | +MNT_INTERNAL_FLAGS =MNT_INTERNAL |MNT_DOOMED | MNT_SYNC_UMOUNT | MNT_LOCKED };
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 63/63 WRITE_HOLD machinery: no need for to bump mount_lock seqcount
In reply to Al Viro... neither for insertion into the list of instances, nor for mnt_{un,}hold_writers(), nor for mnt_get_write_access() deciding to be nice to RT during a busy-wait loop - all of that only needs the spinlock side of mount_lock.
IOW, it's mount_locked_reader, not mount_writer.
Clarify the comment re locking rules for mnt_unhold_writers() - it's not just that mount_lock needs to be held when calling that, it must have been held all along since the matching mnt_hold_writers().
--- fs/namespace.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
fs/namespace.c +8 -8
@@ -526,8 +526,8 @@ int mnt_get_write_access(struct vfsmount *m)* the same CPU as the task that is spinning here. */ preempt_enable (); -lock_mount_hash (); -unlock_mount_hash (); +read_seqlock_excl (&mount_lock); +read_sequnlock_excl (&mount_lock);preempt_disable (); } }
@@ -671,7 +671,7 @@ EXPORT_SYMBOL(mnt_drop_write_file);* a call to mnt_unhold_writers() in order to stop preventing write access to * @mnt. * -* Context: This function expects lock_mount_hash() to be held serializing +* Context: This function expects to be in mount_locked_reader scope serializing * setting WRITE_HOLD. * Return: On success 0 is returned. * On error, -EBUSY is returned.
@@ -716,7 +716,8 @@ static inline int mnt_hold_writers(struct mount *mnt)* * This function can only be called after a call to mnt_hold_writers(). * -* Context: This function expects lock_mount_hash() to be held. +* Context: This function expects to be in the same mount_locked_reader scope +* as the matching mnt_hold_writers(). */ static inline void mnt_unhold_writers (struct mount *mnt) {
@@ -770,7 +771,8 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (atomic_long_read (&sb->s_remove_count))return -EBUSY ; -lock_mount_hash (); +guard (mount_locked_reader)(); +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) {if (!(m->mnt.mnt_flags &MNT_READONLY )) { err =mnt_hold_writers (m);
@@ -787,7 +789,6 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (test_write_hold (m))clear_write_hold (m); } -unlock_mount_hash ();return err; }
@@ -1226,9 +1227,8 @@ static void setup_mnt(struct mount *m, struct dentry *root) m->mnt_mountpoint = m->mnt.mnt_root; m->mnt_parent = m; -lock_mount_hash (); +guard (mount_locked_reader)();mnt_add_instance (m, s); -unlock_mount_hash (); }/**
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 64/65 WRITE_HOLD machinery: no need for to bump mount_lock seqcount
In reply to Al Viro... neither for insertion into the list of instances, nor for mnt_{un,}hold_writers(), nor for mnt_get_write_access() deciding to be nice to RT during a busy-wait loop - all of that only needs the spinlock side of mount_lock.
IOW, it's mount_locked_reader, not mount_writer.
Clarify the comment re locking rules for mnt_unhold_writers() - it's not just that mount_lock needs to be held when calling that, it must have been held all along since the matching mnt_hold_writers().
--- fs/namespace.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
fs/namespace.c +8 -8
@@ -526,8 +526,8 @@ int mnt_get_write_access(struct vfsmount *m)* the same CPU as the task that is spinning here. */ preempt_enable (); -lock_mount_hash (); -unlock_mount_hash (); +read_seqlock_excl (&mount_lock); +read_sequnlock_excl (&mount_lock);preempt_disable (); } }
@@ -671,7 +671,7 @@ EXPORT_SYMBOL(mnt_drop_write_file);* a call to mnt_unhold_writers() in order to stop preventing write access to * @mnt. * -* Context: This function expects lock_mount_hash() to be held serializing +* Context: This function expects to be in mount_locked_reader scope serializing * setting WRITE_HOLD. * Return: On success 0 is returned. * On error, -EBUSY is returned.
@@ -716,7 +716,8 @@ static inline int mnt_hold_writers(struct mount *mnt)* * This function can only be called after a call to mnt_hold_writers(). * -* Context: This function expects lock_mount_hash() to be held. +* Context: This function expects to be in the same mount_locked_reader scope +* as the matching mnt_hold_writers(). */ static inline void mnt_unhold_writers (struct mount *mnt) {
@@ -770,7 +771,8 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (atomic_long_read (&sb->s_remove_count))return -EBUSY ; -lock_mount_hash (); +guard (mount_locked_reader)(); +for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) {if (!(m->mnt.mnt_flags &MNT_READONLY )) { err =mnt_hold_writers (m);
@@ -787,7 +789,6 @@ int sb_prepare_remount_readonly(struct super_block *sb)if (test_write_hold (m))clear_write_hold (m); } -unlock_mount_hash ();return err; }
@@ -1226,9 +1227,8 @@ static void setup_mnt(struct mount *m, struct dentry *root) m->mnt_mountpoint = m->mnt.mnt_root; m->mnt_parent = m; -lock_mount_hash (); +guard (mount_locked_reader)();mnt_add_instance (m, s); -unlock_mount_hash (); }/**
Signature · 1 line
2.47.2
Al Viro
maintainerPATCH v3 65/65 constify {__,}mnt_is_readonly()
In reply to Al Viro--- fs/namespace.c | 4 ++-- include/linux/mount.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-)
fs/namespace.c +2 -2
@@ -428,7 +428,7 @@ static struct mount *alloc_vfsmnt(const char *name)* mnt_want/drop_write() will _keep_ the filesystem * r/w. */ -bool __mnt_is_readonly (struct vfsmount *mnt) +bool __mnt_is_readonly (const struct vfsmount *mnt) {return (mnt->mnt_flags &MNT_READONLY ) ||sb_rdonly (mnt->mnt_sb); }
@@ -468,7 +468,7 @@ static unsigned int mnt_get_writers(struct mount *mnt)#endif } -static int mnt_is_readonly (struct vfsmount *mnt) +static int mnt_is_readonly (const struct vfsmount *mnt) {if (READ_ONCE (mnt->mnt_sb->s_readonly_remount))return 1 ;
include/linux/mount.h +1 -1
@@ -76,7 +76,7 @@ extern void mntput(struct vfsmount *mnt);extern struct vfsmount *mntget (struct vfsmount *mnt);extern void mnt_make_shortterm (struct vfsmount *mnt);extern struct vfsmount *mnt_clone_internal (const struct path *path); -extern bool __mnt_is_readonly (struct vfsmount *mnt); +extern bool __mnt_is_readonly (const struct vfsmount *mnt);extern bool mnt_may_suid (struct vfsmount *mnt);extern struct vfsmount *clone_private_mount (const struct path *path);
Signature · 1 line
2.47.2
Al Viro
maintainerQuoted 6 lines · Al Viro
Branch force-pushed into
git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs.git#work.mount (also visible as #v3.mount, #v[12].mount being the previous versions) Individual patches in followups.If nobody objects, this goes into #for-next.
PS: survives LTP, xfstests and mount-related selftests.
FWIW, I've spent the weekend trying to figure out what's going on with generic/475. Turns out that it was not a regression - it goes back at least to 6.12 and it's triggered by PREEMPT vs. PREEMPT_VOLUNTARY in config.
The former gives several kinds of failures, with total frequency about 8%; the latter apparently works - if any similar failures happen, the frequency is at least an order of magnitude lower.
One useful thing I've got out of that is a bunch of helpers for doing bisect for configs - semi-manual decomposing the difference between two configs into a series of small changes, allowing to do bisection on that.
Unfortunately, the change it has converged to (and repeating it alone on the original config reproduces the effect) is not particulary useful - some race gets triggered by a config change that affects timings all over the place ;-/
Quoted 2 lines · Al Viro
If nobody objects, this goes into #for-next.
Looks all sane to me.
What was the issue with generic/475? I have missed that context..
Linus
Al Viro
maintainerQuoted 7 lines · Linus Torvalds
Quoted 2 lines · Al Viro
If nobody objects, this goes into #for-next.
Looks all sane to me.
What was the issue with generic/475? I have missed that context..
At some point testing that branch has caught a failure in generic/475. Unfortunately, it wouldn't trigger on every run, so there was a possibility that it started earlier.
When I went digging, I've found it with trixie kernel (6.12.38 in that kvm, at the time) rebuilt with my local config; the one used by debian didn't trigger that. Bisection by config converged to PREEMPT_VOLUNTARY (no visible failures) changed to PREEMPT (failures happen with odds a bit below 10%).
There are several failure modes; the most common is something like
...
echo '1' 2>&1 > /sys/fs/xfs/dm-0/error/fail_at_unmount
echo '0' 2>&1 > /sys/fs/xfs/dm-0/error/metadata/EIO/max_retries echo '0' 2>&1 > /sys/fs/xfs/dm-0/error/metadata/EIO/retry_timeout_seconds
fsstress: check_cwd stat64() returned -1 with errno: 5 (Input/output error)
fsstress: check_cwd failure
fsstress: check_cwd stat64() returned -1 with errno: 5 (Input/output error)
fsstress: check_cwd failure
fsstress: check_cwd stat64() returned -1 with errno: 5 (Input/output error)
fsstress: check_cwd failure
fsstress: check_cwd stat64() returned -1 with errno: 5 (Input/output error)
fsstress: check_cwd failure
fsstress killed (pid 10824)
fsstress killed (pid 10826)
fsstress killed (pid 10827)
fsstress killed (pid 10828)
fsstress killed (pid 10829)
umount: /home/scratch: target is busy.
unmount failed
umount: /home/scratch: target is busy.
umount: /dev/sdb2: not mounted.
in the end of output (that's mainline v6.12); other variants include e.g. quietly hanging udevadm wait (killable). It's bloody annoying to bisect - 100-iterations run takes about 2.5 hours and while usually a failure happens in the first 40 minutes or so or not at all...
PREEMPT definitely is the main contributor to the failure odds... I'm doing a bisection between v6.12 and v6.10 at the moment, will post when I get something more useful...
Quoted 42 lines · Al Viro
Quoted 7 lines · Linus Torvalds
Quoted 2 lines · Al Viro
If nobody objects, this goes into #for-next.
Looks all sane to me.
What was the issue with generic/475? I have missed that context..
At some point testing that branch has caught a failure in generic/475. Unfortunately, it wouldn't trigger on every run, so there was a possibility that it started earlier.
When I went digging, I've found it with trixie kernel (6.12.38 in that kvm, at the time) rebuilt with my local config; the one used by debian didn't trigger that. Bisection by config converged to
PREEMPT_VOLUNTARY(no visible failures) changed to PREEMPT (failures happen with odds a bit below 10%).There are several failure modes; the most common is something like
...
echo '1' 2>&1 >/sys/fs/xfs/dm-0/error/fail_at_unmount
echo '0' 2>&1 >/sys/fs/xfs/dm-0/error/metadata/EIO/max_retriesecho '0' 2>&1 >/sys/fs/xfs/dm-0/error/metadata/EIO/retry_timeout_seconds
fsstress:check_cwdstat64()returned -1 with errno: 5 (Input/output error)
fsstress:check_cwdfailure
fsstress:check_cwdstat64()returned -1 with errno: 5 (Input/output error)
fsstress:check_cwdfailure
fsstress:check_cwdstat64()returned -1 with errno: 5 (Input/output error)
fsstress:check_cwdfailure
fsstress:check_cwdstat64()returned -1 with errno: 5 (Input/output error)
fsstress:check_cwdfailure
fsstress killed (pid 10824)
fsstress killed (pid 10826)
fsstress killed (pid 10827)
fsstress killed (pid 10828)
fsstress killed (pid 10829)
umount:/home/scratch: target is busy.
unmount failed
umount:/home/scratch: target is busy.
umount:/dev/sdb2: not mounted.
Quoted 2 lines
in the end of output (that's mainline v6.12); other variants include e.g. quietly hanging udevadm wait (killable).
Huh. I've been seeing that "udevadm wait hang" on DM devices issue for a while now when using my check-parallel variant of fstests.
It sometimes reproduces every run, so it can be under 5 minutes to reproduce on a 64-way concurrent test run. It also affects most of the tests that use DM devices (which all call udevadm wait), not just generic/475. Running 'pkill udevadm' is usually enough to get everything unstuck and then the tests continue running.
However, I haven't been able to isolate the problem as running the tests single threaded (ie. normal fstests behaviour) never reproduced it, which is bloody annoying....
Quoted 3 lines
It's bloody annoying to bisect -
100-iterations run takes about 2.5 hours and while usually a failure happens in the first 40 minutes or so or not at all...
That seems to be the case for me, too. If the default XFS config completes (~8 minutes for auto group), then the rest of the configs also complete (~2 hours for a dozen different mkfs/mount configs to run through auto group tests).
Quoted 1 line
PREEMPT definitely is the main contributor to the failure odds...
My test kernels are built with PREEMPT enabled, so it may very likely be a contributing factor:
CONFIG_PREEMPT_BUILD=yCONFIG_ARCH_HAS_PREEMPT_LAZY=y
# CONFIG_PREEMPT_NONE is not set
# CONFIG_PREEMPT_VOLUNTARY is not setCONFIG_PREEMPT=y
# CONFIG_PREEMPT_LAZY is not set
# CONFIG_PREEMPT_RT is not setCONFIG_PREEMPT_COUNT=yCONFIG_PREEMPTION=yCONFIG_PREEMPT_DYNAMIC=y
Quoted 3 lines
I'm doing
a bisection between v6.12 and v6.10 at the moment, will post when I get something more useful...
check-parallel is relatively new so, unfortunately, I don't have any idea when this behaviour might have been introduced.
FWIW, 'udevadm wait' is relatively new behaviour for both udev and fstests. It was introduced into fstests for check-parallel to replace 'udevadm settle'. i.e. wait for the specific device to change to a particular state rather than waiting for the entire udev queue to drain. Check-parallel uses hundreds of block devices and filesystems at the same time resulting in multiple mount/unmount occurring every second. Hence waiting on the udev queue to drain can take a -long- time, but maybe waiting on the device node state chang itself is racy (i.e. might be a udevadm or DM bug) and PREEMPT is opening up that window.
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Al Viro
maintainerQuoted 7 lines · Dave Chinner
Quoted 3 lines
I'm doing
a bisection between v6.12 and v6.10 at the moment, will post when I get something more useful...check-parallel is relatively new so, unfortunately, I don't have any idea when this behaviour might have been introduced.
Quoted 10 lines
FWIW, 'udevadm wait' is relatively new behaviour for both udev and fstests. It was introduced into fstests for check-parallel to replace 'udevadm settle'. i.e. wait for the specific device to change to a particular state rather than waiting for the entire udev queue to drain. Check-parallel uses hundreds of block devices and filesystems at the same time resulting in multiple mount/unmount occurring every second. Hence waiting on the udev queue to drain can take a -long- time, but maybe waiting on the device node state chang itself is racy (i.e. might be a udevadm or DM bug) and PREEMPT is opening up that window.
FWIW, right now it's down to two likely merges, both in 6.12-rc1 window:
sched and vfs_blocksize (the latter - with iomap and xfs branches in it). There's the third merge in that range, but it's ext4, so I'm pretty sure that the next one will be git bisect bad, leaving these two.
Al Viro
maintainerQuoted 20 lines · Al Viro
Quoted 7 lines · Dave Chinner
Quoted 3 lines
I'm doing
a bisection between v6.12 and v6.10 at the moment, will post when I get something more useful...check-parallel is relatively new so, unfortunately, I don't have any idea when this behaviour might have been introduced.
Quoted 10 lines
FWIW, 'udevadm wait' is relatively new behaviour for both udev and fstests. It was introduced into fstests for check-parallel to replace 'udevadm settle'. i.e. wait for the specific device to change to a particular state rather than waiting for the entire udev queue to drain. Check-parallel uses hundreds of block devices and filesystems at the same time resulting in multiple mount/unmount occurring every second. Hence waiting on the udev queue to drain can take a -long- time, but maybe waiting on the device node state chang itself is racy (i.e. might be a udevadm or DM bug) and PREEMPT is opening up that window.
Quoted 5 lines
FWIW, right now it's down to two likely merges, both in 6.12-rc1 window:
sched andvfs_blocksize(the latter - with iomap and xfs branches in it). There's the third merge in that range, but it's ext4, so I'm pretty sure that the next one will be git bisect bad, leaving these two.
Bugger... Either I've got false 'good' at several points, or it's something brought in by commit 2004cef11ea0 "Merge tag 'sched-core-2024-09-19' ofgit://git.kernel.org/pub/scm/linux/kernel/git/tip/tip" - bisection has converged to something within the first 48 commits of the branch in question.
Which is not impossible, but then the underlying race could've been there for years before that, only to be exposed by timing changes ;-/
Anyway, I'll get the bisection to the end, but it looks like the end result won't be particularly useful...
Al Viro
maintainerQuoted 10 lines · Al Viro
Bugger... Either I've got false 'good' at several points, or it's something brought in by commit
2004cef11ea0"Merge tag 'sched-core-2024-09-19' ofgit://git.kernel.org/pub/scm/linux/kernel/git/tip/tip" - bisection has converged to something within the first 48 commits of the branch in question.Which is not impossible, but then the underlying race could've been there for years before that, only to be exposed by timing changes ;-/
Anyway, I'll get the bisection to the end, but it looks like the end result won't be particularly useful...
It's definitely within that branch; breakage reproduce on dae4320b29f0 "sched: Fixup set_next_task() implementations" and does *not* reproduce on 8e2e13ac6122 "sched/fair: Cleanup pick_task_fair() vs throttle"
Trying to bisect it further runs into a bisect hazard left there - commit 54a58a787791 "sched/fair: Implement DELAY_ZERO" has +SCHED_FEAT(DELAY_ZERO, true)
and2e0199df252a "sched/fair: Prepare exit/cleanup paths for delayed_dequeue" -
+ if (sched_feat(DELAY_ZERO) && p->se.vlag > 0)
6 commits before the definition.
I'm not going to try and reorder that branch into something bisectable - I do not know that area anywhere near well enough for that.
In any case, I doubt that it's a scheduler bug; something exposed by the timings change, but that's about it...
Quoted 3 lines · Al Viro
In any case, I doubt that it's a scheduler bug; something exposed by the timings change, but that's about it...
Not great, but not entirely unexpected. It would have been nice to see a smoking gun pointing to an obvious cause, but we've had these kinds of timing-dependent test failures before, and umount tends to be special.
And generic/475 clearly ends up exposing various issues, as shown by
git log --grep=generic/475 fs/
which shows a variety of filesystems having had issues with it.
Linus