Lines Matching defs:mount
31 #include <uapi/linux/mount.h>
41 /* Maximum number of mounts in a mount namespace */
76 /* Don't allow confusion with old 32bit mount ID */
131 /* keep alive for {list,stat}mount() */
148 /* remove from global mount namespace list */
156 * Lookup a mount namespace by id and take a passive reference count. Taking a
157 * passive reference means the mount namespace can be emptied if e.g., the last
160 * already shut down before acquiring @namespace_sem, {list,stat}mount() will
161 * see that the mount rbtree of the namespace is empty.
165 * possible. So if we didn't find a mount namespace and the sequence
213 static int mnt_alloc_id(struct mount *mnt)
225 static void mnt_free_id(struct mount *mnt)
233 static int mnt_alloc_group_id(struct mount *mnt)
246 void mnt_release_group_id(struct mount *mnt)
255 static inline void mnt_add_count(struct mount *mnt, int n)
269 int mnt_get_count(struct mount *mnt)
285 static struct mount *alloc_vfsmnt(const char *name)
287 struct mount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
350 * __mnt_is_readonly: check whether a mount is read-only
351 * @mnt: the mount to check for its write status
366 static inline void mnt_inc_writers(struct mount *mnt)
375 static inline void mnt_dec_writers(struct mount *mnt)
384 static unsigned int mnt_get_writers(struct mount *mnt)
407 * not see any superblock / mount flag changes done by remount.
410 * see the values of superblock / mount flags updated by remount.
423 * mnt_get_write_access - get write access to a mount without freeze protection
424 * @m: the mount on which to take a write
434 struct mount *mnt = real_mount(m);
482 * mnt_want_write - get write access to a mount
483 * @m: the mount on which to take a write
486 * it, and makes sure that writes are allowed (mount is read-write, filesystem
503 * mnt_get_write_access_file - get write access to a file's mount
504 * @file: the file who's mount on which to take a write
526 * mnt_want_write_file - get write access to a file's mount
527 * @file: the file who's mount on which to take a write
547 * mnt_put_write_access - give up write access to a mount
548 * @mnt: the mount on which to give up write access
563 * mnt_drop_write - give up write access to a mount
564 * @mnt: the mount on which to give up write access
591 * mnt_hold_writers - prevent write access to the given mount
608 static inline int mnt_hold_writers(struct mount *mnt)
640 * mnt_unhold_writers - stop preventing write access to the given mount
651 static inline void mnt_unhold_writers(struct mount *mnt)
663 static inline void mnt_del_instance(struct mount *m)
665 struct mount **p = m->mnt_pprev_for_sb;
666 struct mount *next = m->mnt_next_for_sb;
673 static inline void mnt_add_instance(struct mount *m, struct super_block *s)
675 struct mount *first = s->s_mounts;
684 static int mnt_make_readonly(struct mount *mnt)
705 for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) {
717 for (struct mount *m = sb->s_mounts; m; m = m->mnt_next_for_sb) {
725 static void free_vfsmnt(struct mount *mnt)
737 free_vfsmnt(container_of(head, struct mount, mnt_rcu));
743 struct mount *mnt;
779 * __lookup_mnt - mount hash lookup
780 * @mnt: parent mount
783 * If @mnt has a child mount @c mounted on @dentry find and return it.
790 struct mount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)
793 struct mount *p;
802 * lookup_mnt - Return the child mount mounted at given location
805 * Acquires and returns a new reference to mount at given location
810 struct mount *child_mnt;
826 * current mount namespace.
831 * mounts in the current mount namespace and test to see if the dentry
835 * need to identify all mounts that may be in the current mount
836 * namespace not just a mount that happens to have some specified
837 * parent mount.
842 struct mount *mnt, *n;
856 struct mount *parent;
947 static inline int check_mnt(const struct mount *mnt)
952 static inline bool check_anonymous_mnt(struct mount *mnt)
988 static void __umount_mnt(struct mount *mnt, struct list_head *shrink_list)
991 struct mount *parent = mnt->mnt_parent;
1007 static void umount_mnt(struct mount *mnt)
1015 void mnt_set_mountpoint(struct mount *mnt,
1017 struct mount *child_mnt)
1025 static void make_visible(struct mount *mnt)
1027 struct mount *parent = mnt->mnt_parent;
1036 * attach_mnt - mount a mount, attach to @mount_hashtable and parent's
1039 * @mnt: the new mount
1043 * to @parent's child mount list and to @mount_hashtable.
1051 static void attach_mnt(struct mount *mnt, struct mount *parent,
1058 void mnt_change_mountpoint(struct mount *parent, struct mountpoint *mp, struct mount *mnt)
1071 static inline struct mount *node_to_mount(struct rb_node *node)
1073 return node ? rb_entry(node, struct mount, mnt_node) : NULL;
1076 static void mnt_add_to_ns(struct mnt_namespace *ns, struct mount *mnt)
1109 static struct mount *next_mnt(struct mount *p, struct mount *root)
1122 return list_entry(next, struct mount, mnt_child);
1125 static struct mount *skip_mnt_tree(struct mount *p)
1129 p = list_entry(prev, struct mount, mnt_child);
1138 static void commit_tree(struct mount *mnt)
1143 for (struct mount *m = mnt; m; m = next_mnt(m, mnt))
1153 static void setup_mnt(struct mount *m, struct dentry *root)
1168 * vfs_create_mount - Create a mount for a configured superblock
1171 * Create a mount to an already configured superblock. If necessary, the
1174 * Note that this does not attach the mount to anything.
1178 struct mount *mnt;
1245 static struct mount *clone_mnt(struct mount *old, struct dentry *root,
1248 struct mount *mnt;
1297 static void cleanup_mnt(struct mount *mnt)
1300 struct mount *m;
1324 cleanup_mnt(container_of(head, struct mount, mnt_rcu));
1331 struct mount *m, *t;
1338 static void noinline mntput_no_expire_slowpath(struct mount *mnt)
1371 struct mount *p, *tmp;
1394 static void mntput_no_expire(struct mount *mnt)
1417 struct mount *m = real_mount(mnt);
1435 * Make a mount point inaccessible to new lookups.
1437 * for an RCU grace period before destroying the mount point.
1446 * path_is_mountpoint() - Check if path is a mount in the current namespace.
1477 struct mount *p;
1486 * Returns the mount which either has the specified mnt_id, or has the next
1489 static struct mount *mnt_find_id_at(struct mnt_namespace *ns, u64 mnt_id)
1492 struct mount *ret = NULL;
1495 struct mount *m = node_to_mount(node);
1510 * Returns the mount which either has the specified mnt_id, or has the next
1513 static struct mount *mnt_find_id_at_reverse(struct mnt_namespace *ns, u64 mnt_id)
1516 struct mount *ret = NULL;
1519 struct mount *m = node_to_mount(node);
1539 struct mount *mnt;
1551 struct mount *mnt = v;
1555 struct mount *next = node_to_mount(node);
1561 * No more mounts. Set pos past current mount's ID so that if
1576 struct mount *r = v;
1590 * may_umount_tree - check if a mount tree is busy
1591 * @m: root of mount tree
1599 struct mount *mnt = real_mount(m);
1604 for (struct mount *p = mnt; p; p = next_mnt(p, mnt)) {
1618 * may_umount - check if a mount point is busy
1619 * @mnt: root of mount
1621 * This is called to check if a mount point has any
1623 * mount has sub mounts this will return busy
1645 static void mnt_notify(struct mount *p)
1662 struct mount *m, *tmp;
1693 struct mount *m;
1743 static bool disconnect_mount(struct mount *mnt, enum umount_tree_flags how)
1749 /* A mount without a parent has nothing to be connected to */
1760 /* Has it been requested that the mount remain connected? */
1764 /* Is the mount locked such that it needs to remain connected? */
1768 /* By default disconnect the mount */
1776 static void umount_tree(struct mount *mnt, enum umount_tree_flags how)
1779 struct mount *p;
1806 p = list_first_entry(&tmp_list, struct mount, mnt_list);
1837 * This will preclude queuing the mount if this is a cleanup
1845 static void shrink_submounts(struct mount *mnt);
1870 static int do_umount(struct mount *mnt, int flags)
1907 * mount, and they will themselves hold resources we must
1911 * must return, and the like. Thats for the mount program to worry
1975 * to an existing mountpoint, and wind up leaking the mount.
1984 struct mount *mnt;
1994 mnt = hlist_entry(mp.node.next, struct mount, mnt_mp_list);
2015 "WARNING: The mand mount option has been deprecated and\n"
2017 " option from the mount to silence this warning.\n"
2023 struct mount *mnt = real_mount(path->mnt);
2042 struct mount *mnt = real_mount(path->mnt);
2094 /* Is this a proxy for a mount namespace? */
2123 * delay so accessing the mount namespace is not just
2131 * the mount namespace and it might already be on its
2151 /* Could bind mounting the mount namespace inode cause a
2152 * mount namespace loop?
2162 struct mount *copy_tree(struct mount *src_root, struct dentry *dentry,
2165 struct mount *res, *src_parent, *src_root_child, *src_mnt,
2216 /* stick the duplicate mount on the same expiry
2256 struct mount *root = real_mount(path->mnt);
2257 struct mount *child;
2271 for (struct mount *m = child; m; m = next_mnt(m, child)) {
2299 struct mount *m = real_mount(mnt);
2303 * we need to dissolve the mount tree and free that namespace.
2328 static bool __has_locked_children(struct mount *mnt, struct dentry *dentry)
2330 struct mount *child;
2342 bool has_locked_children(struct mount *mnt, struct dentry *dentry)
2349 * Check that there aren't references to earlier/same mount namespaces in the
2350 * specified subtree. Such references can act as pins for mount namespaces
2351 * that aren't checked by the mount-cycle checking code, thereby allowing
2356 static bool check_for_nsfs_mounts(struct mount *subtree)
2358 for (struct mount *p = subtree; p; p = next_mnt(p, subtree))
2368 * This creates a new vfsmount, which will be the clone of @path. The new mount
2370 * changes to the originating mount won't be propagated into this).
2378 struct mount *old_mnt = real_mount(path->mnt);
2379 struct mount *new_mnt;
2387 * Make sure the source mount is acceptable.
2388 * Anything mounted in our mount namespace is allowed.
2389 * Otherwise, it must be the root of an anonymous mount
2411 /* Longterm mount to be removed by kern_unmount*() */
2417 static void lock_mnt_tree(struct mount *mnt)
2419 struct mount *p;
2423 /* Don't allow unprivileged users to change mount flags */
2437 /* Don't allow unprivileged users to reveal what is under a mount */
2444 static void cleanup_group_ids(struct mount *mnt, struct mount *end)
2446 struct mount *p;
2454 static int invent_group_ids(struct mount *mnt, bool recurse)
2456 struct mount *p;
2471 int count_mounts(struct mnt_namespace *ns, struct mount *mnt)
2475 struct mount *p;
2500 * attach_recursive_mnt - attach a source mount tree
2501 * @source_mnt: mount tree to be attached
2504 * NOTE: in the table below explains the semantics when a source mount
2505 * of a given type is attached to a destination mount of a given type.
2518 * A bind operation clones the source mount and mounts the clone on the
2519 * destination mount.
2521 * (++) the cloned mount is propagated to all the mounts in the propagation
2522 * tree of the destination mount and the cloned mount is added to
2523 * the peer group of the source mount.
2524 * (+) the cloned mount is created under the destination mount and is marked
2525 * as shared. The cloned mount is added to the peer group of the source
2526 * mount.
2527 * (+++) the mount is propagated to all the mounts in the propagation tree
2528 * of the destination mount and the cloned mount is made slave
2529 * of the same master as that of the source mount. The cloned mount
2531 * (*) the cloned mount is made a slave of the same master as that of the
2532 * source mount.
2547 * (+) the mount is moved to the destination. And is then propagated to
2548 * all the mounts in the propagation tree of the destination mount.
2549 * (+*) the mount is moved to the destination.
2550 * (+++) the mount is moved to the destination and is then propagated to
2551 * all the mounts belonging to the destination mount's propagation tree.
2552 * the mount is marked as 'shared and slave'.
2553 * (*) the mount continues to be a slave at the new location.
2555 * if the source mount is a tree, the operations explained above is
2556 * applied to each mount in the tree.
2564 static int attach_recursive_mnt(struct mount *source_mnt,
2568 struct mount *dest_mnt = dest->parent;
2574 struct mount *child, *p;
2575 struct mount *top;
2592 /* Is there space to add these mounts to the mount namespace? */
2617 /* if the mount is moved, it should no longer be expired
2640 struct mount *q;
2649 struct mount *r = topmost_overmount(child);
2660 * consented to this by not severing the mount
2677 child = hlist_entry(tree_list.first, struct mount, mnt_hash);
2693 static inline struct mount *where_to_mount(const struct path *path,
2697 struct mount *m;
2718 * @beneath: whether the intention is to mount beneath @path
2720 * To mount something at given location, we need
2724 * struct mount we are mounting on
2735 * Request to mount on overmounted location is treated as "mount on
2736 * top of whatever's overmounting it"; request to mount beneath
2737 * a location - "mount immediately beneath the topmost mount at that
2742 * case we also require the location to be at the root of a mount
2758 struct mount *m, *n;
2836 static int graft_tree(struct mount *mnt, const struct pinned_mountpoint *mp)
2848 static int may_change_propagation(const struct mount *m)
2883 struct mount *m;
2884 struct mount *mnt = real_mount(path->mnt);
2914 /* may_copy_tree() - check if a mount tree can be copied
2915 * @path: path to the mount tree to be copied
2917 * This helper checks if the caller may copy the mount tree starting
2918 * from @path->mnt. The caller may copy the mount tree under the
2921 * (1) The caller is located in the mount namespace of the mount tree.
2922 * This also implies that the mount does not belong to an anonymous
2923 * mount namespace.
2924 * (2) The caller tries to copy an nfs mount referring to a mount
2925 * namespace, i.e., the caller is trying to copy a mount namespace
2927 * (3) The caller tries to copy a pidfs mount referring to a pidfd.
2928 * (4) The caller is trying to copy a mount tree that belongs to an
2929 * anonymous mount namespace.
2931 * For that to be safe, this helper enforces that the origin mount
2932 * namespace the anonymous mount namespace was created from is the
2933 * same as the caller's mount namespace by comparing the sequence
2937 * mount api enforce that the caller must be located in the same
2938 * mount namespace as the mount tree it interacts with. Using the
2940 * anonymous mount namespaces. However, one could envision extending
2941 * the api to directly operate across mount namespace if needed.
2943 * The ownership of a non-anonymous mount namespace such as the
2945 * => We know that the caller's mount namespace is stable.
2947 * If the origin sequence number of the anonymous mount namespace is
2948 * the same as the sequence number of the caller's mount namespace.
2952 * caller's mount namespace ensures that the caller has the
2953 * ability to copy the mount tree.
2955 * Returns true if the mount tree can be copied, false otherwise.
2959 struct mount *mnt = real_mount(path->mnt);
2978 static struct mount *__do_loopback(const struct path *old_path,
2981 struct mount *old = real_mount(old_path->mnt);
2999 * do loopback mount.
3005 struct mount *mnt = NULL;
3041 struct mount *mnt, *p;
3050 * Record the sequence number of the source mount namespace.
3051 * This needs to hold namespace_sem to ensure that the mount
3105 struct mount *new_ns_root, *old_ns_root;
3107 struct mount *mnt;
3135 * If the real rootfs had a locked mount on top of it somewhere
3136 * in the stack, lock the new mount tree as well so it can't be
3147 * We don't emulate unshare()ing a mount namespace. We stick to
3165 * now mount the detached tree on top of the copy
3220 * If we create a new mount namespace with the cloned mount tree we
3222 * The new mount namespace will be owned by it.
3251 * Don't allow locked mount flags to be cleared.
3256 static bool can_change_locked_flags(struct mount *mnt, unsigned int mnt_flags)
3283 static int change_mount_ro_state(struct mount *mnt, unsigned int mnt_flags)
3297 static void set_mount_attributes(struct mount *mnt, unsigned int mnt_flags)
3336 * to mount(2).
3341 struct mount *mnt = real_mount(path->mnt);
3380 struct mount *mnt = real_mount(path->mnt);
3398 * from the legacy mount system call.
3423 static inline int tree_contains_unbindable(struct mount *mnt)
3425 struct mount *p;
3435 struct mount *from = real_mount(from_path->mnt);
3436 struct mount *to = real_mount(to_path->mnt);
3448 /* To and From paths should be mount roots */
3458 /* From mount root should be wider than To mount root */
3462 /* From mount should not have locked children in place of To's root */
3491 * Check if path is overmounted, i.e., if there's a mount on top of
3519 static bool mount_is_ancestor(const struct mount *p1, const struct mount *p2)
3527 * can_move_mount_beneath - check that we can mount beneath the top mount
3528 * @mnt_from: mount we are trying to move
3529 * @mnt_to: mount under which to mount
3532 * - Make sure that the caller can unmount the topmost mount ensuring
3536 * - Prevent mounting beneath a mount if the propagation relationship
3537 * between the source mount, parent mount, and top mount would lead to
3538 * nonsensical mount trees.
3543 static int can_move_mount_beneath(const struct mount *mnt_from,
3544 const struct mount *mnt_to,
3547 struct mount *parent_mnt_to = mnt_to->mnt_parent;
3549 /* Avoid creating shadow mounts during mount propagation. */
3557 * If the parent mount propagates to the child mount this would
3560 * defeats the whole purpose of mounting beneath another mount.
3584 /* may_use_mount() - check if a mount tree can be used
3587 * This helper checks if the caller may use the mount tree starting
3588 * from @path->mnt. The caller may use the mount tree under the
3591 * (1) The caller is located in the mount namespace of the mount tree.
3592 * This also implies that the mount does not belong to an anonymous
3593 * mount namespace.
3594 * (2) The caller is trying to use a mount tree that belongs to an
3595 * anonymous mount namespace.
3597 * For that to be safe, this helper enforces that the origin mount
3598 * namespace the anonymous mount namespace was created from is the
3599 * same as the caller's mount namespace by comparing the sequence
3602 * The ownership of a non-anonymous mount namespace such as the
3604 * => We know that the caller's mount namespace is stable.
3606 * If the origin sequence number of the anonymous mount namespace is
3607 * the same as the sequence number of the caller's mount namespace.
3611 * caller's mount namespace ensures that the caller has the
3612 * ability to use the mount tree.
3614 * Returns true if the mount tree can be used, false otherwise.
3616 static inline bool may_use_mount(struct mount *mnt)
3636 struct mount *old = real_mount(old_path->mnt);
3683 struct mount *over = real_mount(new_path->mnt);
3693 * Don't move a mount tree containing unbindable mounts to a destination
3694 * mount which is shared.
3722 * add a mount into a namespace's mount tree
3724 static int do_add_mount(struct mount *newmnt, const struct pinned_mountpoint *mp,
3727 struct mount *parent = mp->parent;
3743 /* Refuse the same filesystem on the same mount point */
3758 * Create a new mount using a superblock configuration and request it
3791 * create a new mount for userspace and request it to be added into the
3827 * Indicate to the filesystem that the mount request is coming
3828 * from the legacy mount system call.
3883 struct mount *mnt;
3899 * got", not "try to mount it on top".
3912 * mnt_set_expiry - Put a mount on an expiration list
3913 * @mnt: The mount to list.
3914 * @expiry_list: The list to add the mount to.
3930 struct mount *mnt, *next;
3955 mnt = list_first_entry(&graveyard, struct mount, mnt_expire);
3969 static int select_submounts(struct mount *parent, struct list_head *graveyard)
3971 struct mount *this_parent = parent;
3980 struct mount *mnt = list_entry(tmp, struct mount, mnt_child);
4015 static void shrink_submounts(struct mount *mnt)
4018 struct mount *m;
4023 m = list_first_entry(&graveyard, struct mount,
4074 * be given to the mount() call (ie: read-only, no-dev, no-suid etc).
4080 * Pre-0.97 versions of mount() didn't have a flags word.
4238 struct mount *p, *q;
4239 struct mount *old;
4240 struct mount *new;
4281 * Empty mount namespace: only the root mount exists.
4282 * Reset root and pwd to the cloned mount's root dentry.
4333 struct mount *mnt = real_mount(m);
4367 SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
4432 * Create a kernel mount representation for a new, prepared superblock
4442 struct mount *mnt;
4488 /* There must be a valid superblock or we can't mount it */
4518 /* We've done the mount bit - now move the file context into more or
4570 * Move a mount from one place to another. In combination with
4571 * fsopen()/fsmount() this is used to install a new mount and in combination
4573 * a mount subtree.
4654 bool is_path_reachable(struct mount *mnt, struct dentry *dentry,
4674 struct mount *new_mnt, *root_mnt, *old_mnt, *root_parent, *ex_parent;
4727 /* mount new_root on / */
4730 /* mount old root on put_old */
4733 /* A moved mount should not expire automatically */
4763 * /nfs/my_root where /nfs is the mount point. It must be a mountpoint,
4764 * though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
4787 static unsigned int recalc_flags(struct mount_kattr *kattr, struct mount *mnt)
4799 static int can_idmap_mount(const struct mount_kattr *kattr, struct mount *mnt)
4808 * Creating an idmapped mount with the filesystem wide idmapping
4815 * We only allow an mount to change it's idmapping if it has
4842 * @kattr: the new mount attributes
4843 * @mnt: the mount to which @kattr will be applied
4845 * Check whether thew new mount attributes in @kattr allow concurrent writers.
4850 const struct mount *mnt)
4857 static int mount_setattr_prepare(struct mount_kattr *kattr, struct mount *mnt)
4859 struct mount *m;
4886 for (struct mount *p = mnt; p != m; p = next_mnt(p, mnt))
4892 static void do_idmap_mount(const struct mount_kattr *kattr, struct mount *mnt)
4906 static void mount_setattr_commit(struct mount_kattr *kattr, struct mount *mnt)
4908 struct mount *m;
4930 struct mount *mnt = real_mount(path->mnt);
4967 * First, we get the mount tree in a shape where we can change mount
5030 * mount. We use the initial idmapping as an indicator of a mount
5230 struct mount *mnt = mnt_find_id_at(ns, id);
5282 static u64 mnt_to_propagation_flags(struct mount *m)
5317 struct mount *m = real_mount(s->mnt);
5332 struct mount *m = real_mount(s->mnt);
5390 struct mount *r = real_mount(s->mnt);
5532 * non-idmapped mount and an idmapped mount where none of the
5552 * non-idmapped mount and an idmapped mount where none of the
5662 static struct mount *listmnt_next(struct mount *curr, bool reverse)
5676 struct mount *first, *child;
5687 * We have to find the first mount in our ns and use that, however it
5739 * We can't set mount point and mnt_ns_id since we don't have a
5740 * ns for the mount. This can happen if the mount is unmounted
5760 struct mount *m;
5777 * Note that mount properties in mnt->mnt_flags, mnt->mnt_idmap
5779 * namespace semaphore and mount properties may change with only
5780 * the mount lock held.
5782 * We could sample the mount lock sequence counter to detect
5917 /* The first valid unique mount id is MNT_UNIQUE_ID_OFFSET + 1. */
5925 * If the user requested a specific mount namespace id, look that up and return
5926 * that, or if not simply grab a passive reference on our mount namespace and
6034 struct mount *r, *first;
6102 /* The first valid unique mount id is MNT_UNIQUE_ID_OFFSET + 1. */
6135 * If the mount namespace really has more than 1 million mounts the
6136 * caller must iterate over the mount namespace (and reconsider their
6158 * We only need to guard against mount topology changes as
6159 * listmount() doesn't care about any mount properties.
6183 struct mount *mnt_root;
6189 * (1) nullfs with mount id 1
6190 * (2) mutable rootfs with mount id 2
6215 panic("VFS: Failed to mount rootfs on nullfs");
6223 * the only task that's running, there's no other mount
6224 * namespace in existence and the initial mount namespace is
6227 for (struct mount *p = mnt_root; p; p = next_mnt(p, mnt_root)) {
6248 mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct mount),
6263 panic("Failed to allocate mount hash table\n");
6295 * it is a longterm mount, don't release mnt until
6306 /* release long term mount so mount point can be released */
6336 struct mount *root;
6354 struct mount *mnt;
6363 struct mount *child;
6376 /* A local view of the mount flags */
6383 /* Verify the mount flags are equal to or more permissive
6384 * than the proposed new mount.
6393 /* This mount is not fully visible if there are any
6436 * Restricted variants don't need an already visible mount because they
6539 .procname = "mount-max",