do_umount(): simplify the "is it still mounted" checks

Calls of do_umount() are always preceded by can_umount(), where we'd
done a racy check for mount belonging to our namespace; if it wasn't,
can_unmount() would've failed with -EINVAL and we wouldn't have
reached do_umount() at all.

That check needs to be redone once we have acquired namespace_sem
and in do_umount() we do that.  However, that's done in a very odd
way; we check that mount is still in rbtree of _some_ namespace or
its mnt_list is not empty.  It is equivalent to check_mnt(mnt) -
we know that earlier mnt was mounted in our namespace; if it has
stayed there, it's going to remain in rbtree of our namespace.
OTOH, if it ever had been removed from out namespace, it would be
removed from rbtree and it never would've re-added to a namespace
afterwards.  As for ->mnt_list, for something that had been mounted
in a namespace we'll never observe non-empty ->mnt_list while holding
namespace_sem - it does temporarily become non-empty during
umount_tree(), but that doesn't outlast the call of umount_tree(),
let alone dropping namespace_sem.

Things get much easier to follow if we replace that with (equivalent)
check_mnt(mnt) there.  What's more, currently we treat a failure of
that test as "quietly do nothing"; we might as well pretend that we'd
lost the race and fail on that the same way can_umount() would have.

Reviewed-by: Christian Brauner <brauner@kernel.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/namespace.c b/fs/namespace.c
index 12cf69da4320950eb5df2a12950469d52e20c9e7..57b0974a5d1e82c279b6cff5b7b9e9954304d488 100644 (file)
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -1983,8 +1983,11 @@ static int do_umount(struct mount *mnt, int flags)
        namespace_lock();
        lock_mount_hash();
 
-       /* Recheck MNT_LOCKED with the locks held */
+       /* Repeat the earlier racy checks, now that we are holding the locks */
        retval = -EINVAL;
+       if (!check_mnt(mnt))
+               goto out;
+
        if (mnt->mnt.mnt_flags & MNT_LOCKED)
                goto out;
 
@@ -1993,16 +1996,14 @@ static int do_umount(struct mount *mnt, int flags)
 
        event++;
        if (flags & MNT_DETACH) {
-               if (mnt_ns_attached(mnt) || !list_empty(&mnt->mnt_list))
-                       umount_tree(mnt, UMOUNT_PROPAGATE);
+               umount_tree(mnt, UMOUNT_PROPAGATE);
                retval = 0;
        } else {
                smp_mb(); // paired with __legitimize_mnt()
                shrink_submounts(mnt);
                retval = -EBUSY;
                if (!propagate_mount_busy(mnt, 2)) {
-                       if (mnt_ns_attached(mnt) || !list_empty(&mnt->mnt_list))
-                               umount_tree(mnt, UMOUNT_PROPAGATE|UMOUNT_SYNC);
+                       umount_tree(mnt, UMOUNT_PROPAGATE|UMOUNT_SYNC);
                        retval = 0;
                }
        }