^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1) // SPDX-License-Identifier: GPL-2.0-only
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3) * linux/fs/namespace.c
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5) * (C) Copyright Al Viro 2000, 2001
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7) * Based on code from fs/super.c, copyright Linus Torvalds and others.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8) * Heavily rewritten.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 10)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 11) #include <linux/syscalls.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 12) #include <linux/export.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 13) #include <linux/capability.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 14) #include <linux/mnt_namespace.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 15) #include <linux/user_namespace.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 16) #include <linux/namei.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 17) #include <linux/security.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 18) #include <linux/cred.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 19) #include <linux/idr.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 20) #include <linux/init.h> /* init_rootfs */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 21) #include <linux/fs_struct.h> /* get_fs_root et.al. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 22) #include <linux/fsnotify.h> /* fsnotify_vfsmount_delete */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 23) #include <linux/file.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 24) #include <linux/uaccess.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 25) #include <linux/proc_ns.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 26) #include <linux/magic.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 27) #include <linux/memblock.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 28) #include <linux/task_work.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 29) #include <linux/sched/task.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 30) #include <uapi/linux/mount.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 31) #include <linux/fs_context.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 32) #include <linux/shmem_fs.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 33)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 34) #include "pnode.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 35) #include "internal.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 36)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 37) /* Maximum number of mounts in a mount namespace */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 38) unsigned int sysctl_mount_max __read_mostly = 100000;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 39)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 40) static unsigned int m_hash_mask __read_mostly;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 41) static unsigned int m_hash_shift __read_mostly;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 42) static unsigned int mp_hash_mask __read_mostly;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 43) static unsigned int mp_hash_shift __read_mostly;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 44)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 45) static __initdata unsigned long mhash_entries;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 46) static int __init set_mhash_entries(char *str)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 47) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 48) if (!str)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 49) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 50) mhash_entries = simple_strtoul(str, &str, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 51) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 52) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 53) __setup("mhash_entries=", set_mhash_entries);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 54)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 55) static __initdata unsigned long mphash_entries;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 56) static int __init set_mphash_entries(char *str)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 57) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 58) if (!str)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 59) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 60) mphash_entries = simple_strtoul(str, &str, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 61) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 62) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 63) __setup("mphash_entries=", set_mphash_entries);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 64)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 65) static u64 event;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 66) static DEFINE_IDA(mnt_id_ida);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 67) static DEFINE_IDA(mnt_group_ida);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 68)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 69) static struct hlist_head *mount_hashtable __read_mostly;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 70) static struct hlist_head *mountpoint_hashtable __read_mostly;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 71) static struct kmem_cache *mnt_cache __read_mostly;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 72) static DECLARE_RWSEM(namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 73) static HLIST_HEAD(unmounted); /* protected by namespace_sem */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 74) static LIST_HEAD(ex_mountpoints); /* protected by namespace_sem */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 75)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 76) /* /sys/fs */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 77) struct kobject *fs_kobj;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 78) EXPORT_SYMBOL_GPL(fs_kobj);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 79)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 80) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 81) * vfsmount lock may be taken for read to prevent changes to the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 82) * vfsmount hash, ie. during mountpoint lookups or walking back
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 83) * up the tree.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 84) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 85) * It should be taken for write in all cases where the vfsmount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 86) * tree or hash is modified or when a vfsmount structure is modified.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 87) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 88) __cacheline_aligned_in_smp DEFINE_SEQLOCK(mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 89)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 90) static inline struct hlist_head *m_hash(struct vfsmount *mnt, struct dentry *dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 91) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 92) unsigned long tmp = ((unsigned long)mnt / L1_CACHE_BYTES);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 93) tmp += ((unsigned long)dentry / L1_CACHE_BYTES);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 94) tmp = tmp + (tmp >> m_hash_shift);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 95) return &mount_hashtable[tmp & m_hash_mask];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 96) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 97)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 98) static inline struct hlist_head *mp_hash(struct dentry *dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 99) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 100) unsigned long tmp = ((unsigned long)dentry / L1_CACHE_BYTES);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 101) tmp = tmp + (tmp >> mp_hash_shift);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 102) return &mountpoint_hashtable[tmp & mp_hash_mask];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 103) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 104)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 105) static int mnt_alloc_id(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 106) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 107) int res = ida_alloc(&mnt_id_ida, GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 108)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 109) if (res < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 110) return res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 111) mnt->mnt_id = res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 112) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 113) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 114)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 115) static void mnt_free_id(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 116) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 117) ida_free(&mnt_id_ida, mnt->mnt_id);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 118) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 119)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 120) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 121) * Allocate a new peer group ID
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 122) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 123) static int mnt_alloc_group_id(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 124) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 125) int res = ida_alloc_min(&mnt_group_ida, 1, GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 126)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 127) if (res < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 128) return res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 129) mnt->mnt_group_id = res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 130) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 131) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 132)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 133) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 134) * Release a peer group ID
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 135) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 136) void mnt_release_group_id(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 137) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 138) ida_free(&mnt_group_ida, mnt->mnt_group_id);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 139) mnt->mnt_group_id = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 140) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 141)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 142) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 143) * vfsmount lock must be held for read
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 144) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 145) static inline void mnt_add_count(struct mount *mnt, int n)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 146) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 147) #ifdef CONFIG_SMP
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 148) this_cpu_add(mnt->mnt_pcp->mnt_count, n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 149) #else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 150) preempt_disable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 151) mnt->mnt_count += n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 152) preempt_enable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 153) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 154) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 155)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 156) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 157) * vfsmount lock must be held for write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 158) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 159) int mnt_get_count(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 160) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 161) #ifdef CONFIG_SMP
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 162) int count = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 163) int cpu;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 164)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 165) for_each_possible_cpu(cpu) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 166) count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_count;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 167) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 168)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 169) return count;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 170) #else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 171) return mnt->mnt_count;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 172) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 173) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 174)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 175) static struct mount *alloc_vfsmnt(const char *name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 176) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 177) struct mount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 178) if (mnt) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 179) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 180)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 181) err = mnt_alloc_id(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 182) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 183) goto out_free_cache;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 184)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 185) if (name) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 186) mnt->mnt_devname = kstrdup_const(name, GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 187) if (!mnt->mnt_devname)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 188) goto out_free_id;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 189) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 190)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 191) #ifdef CONFIG_SMP
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 192) mnt->mnt_pcp = alloc_percpu(struct mnt_pcp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 193) if (!mnt->mnt_pcp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 194) goto out_free_devname;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 195)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 196) this_cpu_add(mnt->mnt_pcp->mnt_count, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 197) #else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 198) mnt->mnt_count = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 199) mnt->mnt_writers = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 200) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 201)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 202) INIT_HLIST_NODE(&mnt->mnt_hash);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 203) INIT_LIST_HEAD(&mnt->mnt_child);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 204) INIT_LIST_HEAD(&mnt->mnt_mounts);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 205) INIT_LIST_HEAD(&mnt->mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 206) INIT_LIST_HEAD(&mnt->mnt_expire);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 207) INIT_LIST_HEAD(&mnt->mnt_share);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 208) INIT_LIST_HEAD(&mnt->mnt_slave_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 209) INIT_LIST_HEAD(&mnt->mnt_slave);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 210) INIT_HLIST_NODE(&mnt->mnt_mp_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 211) INIT_LIST_HEAD(&mnt->mnt_umounting);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 212) INIT_HLIST_HEAD(&mnt->mnt_stuck_children);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 213) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 214) return mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 215)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 216) #ifdef CONFIG_SMP
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 217) out_free_devname:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 218) kfree_const(mnt->mnt_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 219) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 220) out_free_id:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 221) mnt_free_id(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 222) out_free_cache:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 223) kmem_cache_free(mnt_cache, mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 224) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 225) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 226)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 227) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 228) * Most r/o checks on a fs are for operations that take
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 229) * discrete amounts of time, like a write() or unlink().
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 230) * We must keep track of when those operations start
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 231) * (for permission checks) and when they end, so that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 232) * we can determine when writes are able to occur to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 233) * a filesystem.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 234) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 235) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 236) * __mnt_is_readonly: check whether a mount is read-only
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 237) * @mnt: the mount to check for its write status
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 238) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 239) * This shouldn't be used directly ouside of the VFS.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 240) * It does not guarantee that the filesystem will stay
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 241) * r/w, just that it is right *now*. This can not and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 242) * should not be used in place of IS_RDONLY(inode).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 243) * mnt_want/drop_write() will _keep_ the filesystem
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 244) * r/w.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 245) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 246) bool __mnt_is_readonly(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 247) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 248) return (mnt->mnt_flags & MNT_READONLY) || sb_rdonly(mnt->mnt_sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 249) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 250) EXPORT_SYMBOL_GPL(__mnt_is_readonly);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 251)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 252) static inline void mnt_inc_writers(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 253) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 254) #ifdef CONFIG_SMP
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 255) this_cpu_inc(mnt->mnt_pcp->mnt_writers);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 256) #else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 257) mnt->mnt_writers++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 258) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 259) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 260)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 261) static inline void mnt_dec_writers(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 262) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 263) #ifdef CONFIG_SMP
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 264) this_cpu_dec(mnt->mnt_pcp->mnt_writers);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 265) #else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 266) mnt->mnt_writers--;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 267) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 268) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 269)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 270) static unsigned int mnt_get_writers(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 271) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 272) #ifdef CONFIG_SMP
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 273) unsigned int count = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 274) int cpu;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 275)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 276) for_each_possible_cpu(cpu) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 277) count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_writers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 278) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 279)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 280) return count;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 281) #else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 282) return mnt->mnt_writers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 283) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 284) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 285)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 286) static int mnt_is_readonly(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 287) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 288) if (mnt->mnt_sb->s_readonly_remount)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 289) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 290) /* Order wrt setting s_flags/s_readonly_remount in do_remount() */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 291) smp_rmb();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 292) return __mnt_is_readonly(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 293) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 294)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 295) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 296) * Most r/o & frozen checks on a fs are for operations that take discrete
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 297) * amounts of time, like a write() or unlink(). We must keep track of when
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 298) * those operations start (for permission checks) and when they end, so that we
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 299) * can determine when writes are able to occur to a filesystem.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 300) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 301) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 302) * __mnt_want_write - get write access to a mount without freeze protection
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 303) * @m: the mount on which to take a write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 304) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 305) * This tells the low-level filesystem that a write is about to be performed to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 306) * it, and makes sure that writes are allowed (mnt it read-write) before
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 307) * returning success. This operation does not protect against filesystem being
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 308) * frozen. When the write operation is finished, __mnt_drop_write() must be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 309) * called. This is effectively a refcount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 310) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 311) int __mnt_want_write(struct vfsmount *m)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 312) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 313) struct mount *mnt = real_mount(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 314) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 315)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 316) preempt_disable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 317) mnt_inc_writers(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 318) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 319) * The store to mnt_inc_writers must be visible before we pass
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 320) * MNT_WRITE_HOLD loop below, so that the slowpath can see our
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 321) * incremented count after it has set MNT_WRITE_HOLD.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 322) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 323) smp_mb();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 324) while (READ_ONCE(mnt->mnt.mnt_flags) & MNT_WRITE_HOLD)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 325) cpu_relax();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 326) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 327) * After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 328) * be set to match its requirements. So we must not load that until
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 329) * MNT_WRITE_HOLD is cleared.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 330) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 331) smp_rmb();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 332) if (mnt_is_readonly(m)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 333) mnt_dec_writers(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 334) ret = -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 335) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 336) preempt_enable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 337)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 338) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 339) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 340)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 341) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 342) * mnt_want_write - get write access to a mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 343) * @m: the mount on which to take a write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 344) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 345) * This tells the low-level filesystem that a write is about to be performed to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 346) * it, and makes sure that writes are allowed (mount is read-write, filesystem
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 347) * is not frozen) before returning success. When the write operation is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 348) * finished, mnt_drop_write() must be called. This is effectively a refcount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 349) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 350) int mnt_want_write(struct vfsmount *m)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 351) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 352) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 353)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 354) sb_start_write(m->mnt_sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 355) ret = __mnt_want_write(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 356) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 357) sb_end_write(m->mnt_sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 358) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 359) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 360) EXPORT_SYMBOL_GPL(mnt_want_write);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 361)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 362) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 363) * mnt_clone_write - get write access to a mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 364) * @mnt: the mount on which to take a write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 365) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 366) * This is effectively like mnt_want_write, except
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 367) * it must only be used to take an extra write reference
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 368) * on a mountpoint that we already know has a write reference
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 369) * on it. This allows some optimisation.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 370) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 371) * After finished, mnt_drop_write must be called as usual to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 372) * drop the reference.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 373) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 374) int mnt_clone_write(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 375) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 376) /* superblock may be r/o */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 377) if (__mnt_is_readonly(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 378) return -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 379) preempt_disable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 380) mnt_inc_writers(real_mount(mnt));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 381) preempt_enable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 382) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 383) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 384) EXPORT_SYMBOL_GPL(mnt_clone_write);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 385)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 386) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 387) * __mnt_want_write_file - get write access to a file's mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 388) * @file: the file who's mount on which to take a write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 389) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 390) * This is like __mnt_want_write, but it takes a file and can
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 391) * do some optimisations if the file is open for write already
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 392) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 393) int __mnt_want_write_file(struct file *file)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 394) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 395) if (!(file->f_mode & FMODE_WRITER))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 396) return __mnt_want_write(file->f_path.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 397) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 398) return mnt_clone_write(file->f_path.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 399) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 400)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 401) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 402) * mnt_want_write_file - get write access to a file's mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 403) * @file: the file who's mount on which to take a write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 404) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 405) * This is like mnt_want_write, but it takes a file and can
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 406) * do some optimisations if the file is open for write already
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 407) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 408) int mnt_want_write_file(struct file *file)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 409) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 410) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 411)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 412) sb_start_write(file_inode(file)->i_sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 413) ret = __mnt_want_write_file(file);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 414) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 415) sb_end_write(file_inode(file)->i_sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 416) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 417) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 418) EXPORT_SYMBOL_NS_GPL(mnt_want_write_file, ANDROID_GKI_VFS_EXPORT_ONLY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 419)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 420) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 421) * __mnt_drop_write - give up write access to a mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 422) * @mnt: the mount on which to give up write access
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 423) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 424) * Tells the low-level filesystem that we are done
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 425) * performing writes to it. Must be matched with
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 426) * __mnt_want_write() call above.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 427) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 428) void __mnt_drop_write(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 429) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 430) preempt_disable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 431) mnt_dec_writers(real_mount(mnt));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 432) preempt_enable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 433) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 434)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 435) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 436) * mnt_drop_write - give up write access to a mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 437) * @mnt: the mount on which to give up write access
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 438) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 439) * Tells the low-level filesystem that we are done performing writes to it and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 440) * also allows filesystem to be frozen again. Must be matched with
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 441) * mnt_want_write() call above.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 442) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 443) void mnt_drop_write(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 444) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 445) __mnt_drop_write(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 446) sb_end_write(mnt->mnt_sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 447) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 448) EXPORT_SYMBOL_GPL(mnt_drop_write);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 449)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 450) void __mnt_drop_write_file(struct file *file)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 451) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 452) __mnt_drop_write(file->f_path.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 453) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 454)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 455) void mnt_drop_write_file(struct file *file)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 456) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 457) __mnt_drop_write_file(file);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 458) sb_end_write(file_inode(file)->i_sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 459) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 460) EXPORT_SYMBOL_NS(mnt_drop_write_file, ANDROID_GKI_VFS_EXPORT_ONLY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 461)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 462) static int mnt_make_readonly(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 463) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 464) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 465)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 466) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 467) mnt->mnt.mnt_flags |= MNT_WRITE_HOLD;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 468) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 469) * After storing MNT_WRITE_HOLD, we'll read the counters. This store
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 470) * should be visible before we do.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 471) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 472) smp_mb();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 473)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 474) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 475) * With writers on hold, if this value is zero, then there are
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 476) * definitely no active writers (although held writers may subsequently
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 477) * increment the count, they'll have to wait, and decrement it after
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 478) * seeing MNT_READONLY).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 479) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 480) * It is OK to have counter incremented on one CPU and decremented on
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 481) * another: the sum will add up correctly. The danger would be when we
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 482) * sum up each counter, if we read a counter before it is incremented,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 483) * but then read another CPU's count which it has been subsequently
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 484) * decremented from -- we would see more decrements than we should.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 485) * MNT_WRITE_HOLD protects against this scenario, because
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 486) * mnt_want_write first increments count, then smp_mb, then spins on
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 487) * MNT_WRITE_HOLD, so it can't be decremented by another CPU while
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 488) * we're counting up here.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 489) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 490) if (mnt_get_writers(mnt) > 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 491) ret = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 492) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 493) mnt->mnt.mnt_flags |= MNT_READONLY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 494) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 495) * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 496) * that become unheld will see MNT_READONLY.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 497) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 498) smp_wmb();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 499) mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 500) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 501) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 502) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 503)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 504) static int __mnt_unmake_readonly(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 505) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 506) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 507) mnt->mnt.mnt_flags &= ~MNT_READONLY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 508) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 509) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 510) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 511)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 512) int sb_prepare_remount_readonly(struct super_block *sb)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 513) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 514) struct mount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 515) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 516)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 517) /* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 518) if (atomic_long_read(&sb->s_remove_count))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 519) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 520)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 521) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 522) list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 523) if (!(mnt->mnt.mnt_flags & MNT_READONLY)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 524) mnt->mnt.mnt_flags |= MNT_WRITE_HOLD;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 525) smp_mb();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 526) if (mnt_get_writers(mnt) > 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 527) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 528) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 529) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 530) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 531) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 532) if (!err && atomic_long_read(&sb->s_remove_count))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 533) err = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 534)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 535) if (!err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 536) sb->s_readonly_remount = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 537) smp_wmb();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 538) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 539) list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 540) if (mnt->mnt.mnt_flags & MNT_WRITE_HOLD)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 541) mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 542) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 543) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 544)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 545) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 546) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 547)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 548) static void free_vfsmnt(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 549) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 550) kfree_const(mnt->mnt_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 551) #ifdef CONFIG_SMP
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 552) free_percpu(mnt->mnt_pcp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 553) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 554) kmem_cache_free(mnt_cache, mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 555) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 556)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 557) static void delayed_free_vfsmnt(struct rcu_head *head)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 558) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 559) free_vfsmnt(container_of(head, struct mount, mnt_rcu));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 560) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 561)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 562) /* call under rcu_read_lock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 563) int __legitimize_mnt(struct vfsmount *bastard, unsigned seq)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 564) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 565) struct mount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 566) if (read_seqretry(&mount_lock, seq))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 567) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 568) if (bastard == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 569) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 570) mnt = real_mount(bastard);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 571) mnt_add_count(mnt, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 572) smp_mb(); // see mntput_no_expire()
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 573) if (likely(!read_seqretry(&mount_lock, seq)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 574) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 575) if (bastard->mnt_flags & MNT_SYNC_UMOUNT) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 576) mnt_add_count(mnt, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 577) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 578) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 579) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 580) if (unlikely(bastard->mnt_flags & MNT_DOOMED)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 581) mnt_add_count(mnt, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 582) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 583) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 584) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 585) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 586) /* caller will mntput() */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 587) return -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 588) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 589)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 590) /* call under rcu_read_lock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 591) bool legitimize_mnt(struct vfsmount *bastard, unsigned seq)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 592) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 593) int res = __legitimize_mnt(bastard, seq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 594) if (likely(!res))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 595) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 596) if (unlikely(res < 0)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 597) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 598) mntput(bastard);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 599) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 600) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 601) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 602) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 603)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 604) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 605) * find the first mount at @dentry on vfsmount @mnt.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 606) * call under rcu_read_lock()
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 607) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 608) struct mount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 609) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 610) struct hlist_head *head = m_hash(mnt, dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 611) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 612)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 613) hlist_for_each_entry_rcu(p, head, mnt_hash)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 614) if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 615) return p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 616) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 617) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 618)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 619) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 620) * lookup_mnt - Return the first child mount mounted at path
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 621) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 622) * "First" means first mounted chronologically. If you create the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 623) * following mounts:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 624) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 625) * mount /dev/sda1 /mnt
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 626) * mount /dev/sda2 /mnt
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 627) * mount /dev/sda3 /mnt
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 628) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 629) * Then lookup_mnt() on the base /mnt dentry in the root mount will
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 630) * return successively the root dentry and vfsmount of /dev/sda1, then
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 631) * /dev/sda2, then /dev/sda3, then NULL.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 632) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 633) * lookup_mnt takes a reference to the found vfsmount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 634) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 635) struct vfsmount *lookup_mnt(const struct path *path)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 636) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 637) struct mount *child_mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 638) struct vfsmount *m;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 639) unsigned seq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 640)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 641) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 642) do {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 643) seq = read_seqbegin(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 644) child_mnt = __lookup_mnt(path->mnt, path->dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 645) m = child_mnt ? &child_mnt->mnt : NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 646) } while (!legitimize_mnt(m, seq));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 647) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 648) return m;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 649) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 650)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 651) static inline void lock_ns_list(struct mnt_namespace *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 652) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 653) spin_lock(&ns->ns_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 654) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 655)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 656) static inline void unlock_ns_list(struct mnt_namespace *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 657) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 658) spin_unlock(&ns->ns_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 659) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 660)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 661) static inline bool mnt_is_cursor(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 662) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 663) return mnt->mnt.mnt_flags & MNT_CURSOR;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 664) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 665)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 666) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 667) * __is_local_mountpoint - Test to see if dentry is a mountpoint in the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 668) * current mount namespace.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 669) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 670) * The common case is dentries are not mountpoints at all and that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 671) * test is handled inline. For the slow case when we are actually
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 672) * dealing with a mountpoint of some kind, walk through all of the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 673) * mounts in the current mount namespace and test to see if the dentry
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 674) * is a mountpoint.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 675) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 676) * The mount_hashtable is not usable in the context because we
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 677) * need to identify all mounts that may be in the current mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 678) * namespace not just a mount that happens to have some specified
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 679) * parent mount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 680) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 681) bool __is_local_mountpoint(struct dentry *dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 682) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 683) struct mnt_namespace *ns = current->nsproxy->mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 684) struct mount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 685) bool is_covered = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 686)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 687) down_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 688) lock_ns_list(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 689) list_for_each_entry(mnt, &ns->list, mnt_list) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 690) if (mnt_is_cursor(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 691) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 692) is_covered = (mnt->mnt_mountpoint == dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 693) if (is_covered)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 694) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 695) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 696) unlock_ns_list(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 697) up_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 698)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 699) return is_covered;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 700) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 701)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 702) static struct mountpoint *lookup_mountpoint(struct dentry *dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 703) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 704) struct hlist_head *chain = mp_hash(dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 705) struct mountpoint *mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 706)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 707) hlist_for_each_entry(mp, chain, m_hash) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 708) if (mp->m_dentry == dentry) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 709) mp->m_count++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 710) return mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 711) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 712) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 713) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 714) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 715)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 716) static struct mountpoint *get_mountpoint(struct dentry *dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 717) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 718) struct mountpoint *mp, *new = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 719) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 720)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 721) if (d_mountpoint(dentry)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 722) /* might be worth a WARN_ON() */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 723) if (d_unlinked(dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 724) return ERR_PTR(-ENOENT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 725) mountpoint:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 726) read_seqlock_excl(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 727) mp = lookup_mountpoint(dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 728) read_sequnlock_excl(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 729) if (mp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 730) goto done;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 731) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 732)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 733) if (!new)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 734) new = kmalloc(sizeof(struct mountpoint), GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 735) if (!new)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 736) return ERR_PTR(-ENOMEM);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 737)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 738)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 739) /* Exactly one processes may set d_mounted */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 740) ret = d_set_mounted(dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 741)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 742) /* Someone else set d_mounted? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 743) if (ret == -EBUSY)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 744) goto mountpoint;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 745)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 746) /* The dentry is not available as a mountpoint? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 747) mp = ERR_PTR(ret);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 748) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 749) goto done;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 750)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 751) /* Add the new mountpoint to the hash table */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 752) read_seqlock_excl(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 753) new->m_dentry = dget(dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 754) new->m_count = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 755) hlist_add_head(&new->m_hash, mp_hash(dentry));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 756) INIT_HLIST_HEAD(&new->m_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 757) read_sequnlock_excl(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 758)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 759) mp = new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 760) new = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 761) done:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 762) kfree(new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 763) return mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 764) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 765)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 766) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 767) * vfsmount lock must be held. Additionally, the caller is responsible
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 768) * for serializing calls for given disposal list.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 769) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 770) static void __put_mountpoint(struct mountpoint *mp, struct list_head *list)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 771) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 772) if (!--mp->m_count) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 773) struct dentry *dentry = mp->m_dentry;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 774) BUG_ON(!hlist_empty(&mp->m_list));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 775) spin_lock(&dentry->d_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 776) dentry->d_flags &= ~DCACHE_MOUNTED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 777) spin_unlock(&dentry->d_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 778) dput_to_list(dentry, list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 779) hlist_del(&mp->m_hash);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 780) kfree(mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 781) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 782) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 783)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 784) /* called with namespace_lock and vfsmount lock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 785) static void put_mountpoint(struct mountpoint *mp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 786) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 787) __put_mountpoint(mp, &ex_mountpoints);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 788) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 789)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 790) static inline int check_mnt(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 791) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 792) return mnt->mnt_ns == current->nsproxy->mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 793) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 794)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 795) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 796) * vfsmount lock must be held for write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 797) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 798) static void touch_mnt_namespace(struct mnt_namespace *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 799) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 800) if (ns) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 801) ns->event = ++event;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 802) wake_up_interruptible(&ns->poll);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 803) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 804) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 805)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 806) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 807) * vfsmount lock must be held for write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 808) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 809) static void __touch_mnt_namespace(struct mnt_namespace *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 810) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 811) if (ns && ns->event != event) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 812) ns->event = event;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 813) wake_up_interruptible(&ns->poll);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 814) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 815) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 816)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 817) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 818) * vfsmount lock must be held for write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 819) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 820) static struct mountpoint *unhash_mnt(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 821) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 822) struct mountpoint *mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 823) mnt->mnt_parent = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 824) mnt->mnt_mountpoint = mnt->mnt.mnt_root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 825) list_del_init(&mnt->mnt_child);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 826) hlist_del_init_rcu(&mnt->mnt_hash);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 827) hlist_del_init(&mnt->mnt_mp_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 828) mp = mnt->mnt_mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 829) mnt->mnt_mp = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 830) return mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 831) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 832)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 833) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 834) * vfsmount lock must be held for write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 835) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 836) static void umount_mnt(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 837) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 838) put_mountpoint(unhash_mnt(mnt));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 839) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 840)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 841) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 842) * vfsmount lock must be held for write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 843) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 844) void mnt_set_mountpoint(struct mount *mnt,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 845) struct mountpoint *mp,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 846) struct mount *child_mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 847) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 848) mp->m_count++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 849) mnt_add_count(mnt, 1); /* essentially, that's mntget */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 850) child_mnt->mnt_mountpoint = mp->m_dentry;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 851) child_mnt->mnt_parent = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 852) child_mnt->mnt_mp = mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 853) hlist_add_head(&child_mnt->mnt_mp_list, &mp->m_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 854) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 855)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 856) static void __attach_mnt(struct mount *mnt, struct mount *parent)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 857) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 858) hlist_add_head_rcu(&mnt->mnt_hash,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 859) m_hash(&parent->mnt, mnt->mnt_mountpoint));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 860) list_add_tail(&mnt->mnt_child, &parent->mnt_mounts);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 861) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 862)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 863) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 864) * vfsmount lock must be held for write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 865) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 866) static void attach_mnt(struct mount *mnt,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 867) struct mount *parent,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 868) struct mountpoint *mp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 869) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 870) mnt_set_mountpoint(parent, mp, mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 871) __attach_mnt(mnt, parent);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 872) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 873)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 874) void mnt_change_mountpoint(struct mount *parent, struct mountpoint *mp, struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 875) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 876) struct mountpoint *old_mp = mnt->mnt_mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 877) struct mount *old_parent = mnt->mnt_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 878)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 879) list_del_init(&mnt->mnt_child);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 880) hlist_del_init(&mnt->mnt_mp_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 881) hlist_del_init_rcu(&mnt->mnt_hash);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 882)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 883) attach_mnt(mnt, parent, mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 884)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 885) put_mountpoint(old_mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 886) mnt_add_count(old_parent, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 887) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 888)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 889) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 890) * vfsmount lock must be held for write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 891) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 892) static void commit_tree(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 893) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 894) struct mount *parent = mnt->mnt_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 895) struct mount *m;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 896) LIST_HEAD(head);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 897) struct mnt_namespace *n = parent->mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 898)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 899) BUG_ON(parent == mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 900)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 901) list_add_tail(&head, &mnt->mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 902) list_for_each_entry(m, &head, mnt_list)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 903) m->mnt_ns = n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 904)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 905) list_splice(&head, n->list.prev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 906)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 907) n->mounts += n->pending_mounts;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 908) n->pending_mounts = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 909)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 910) __attach_mnt(mnt, parent);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 911) touch_mnt_namespace(n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 912) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 913)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 914) static struct mount *next_mnt(struct mount *p, struct mount *root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 915) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 916) struct list_head *next = p->mnt_mounts.next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 917) if (next == &p->mnt_mounts) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 918) while (1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 919) if (p == root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 920) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 921) next = p->mnt_child.next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 922) if (next != &p->mnt_parent->mnt_mounts)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 923) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 924) p = p->mnt_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 925) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 926) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 927) return list_entry(next, struct mount, mnt_child);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 928) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 929)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 930) static struct mount *skip_mnt_tree(struct mount *p)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 931) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 932) struct list_head *prev = p->mnt_mounts.prev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 933) while (prev != &p->mnt_mounts) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 934) p = list_entry(prev, struct mount, mnt_child);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 935) prev = p->mnt_mounts.prev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 936) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 937) return p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 938) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 939)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 940) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 941) * vfs_create_mount - Create a mount for a configured superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 942) * @fc: The configuration context with the superblock attached
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 943) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 944) * Create a mount to an already configured superblock. If necessary, the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 945) * caller should invoke vfs_get_tree() before calling this.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 946) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 947) * Note that this does not attach the mount to anything.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 948) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 949) struct vfsmount *vfs_create_mount(struct fs_context *fc)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 950) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 951) struct mount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 952)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 953) if (!fc->root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 954) return ERR_PTR(-EINVAL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 955)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 956) mnt = alloc_vfsmnt(fc->source ?: "none");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 957) if (!mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 958) return ERR_PTR(-ENOMEM);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 959)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 960) if (fc->sb_flags & SB_KERNMOUNT)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 961) mnt->mnt.mnt_flags = MNT_INTERNAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 962)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 963) atomic_inc(&fc->root->d_sb->s_active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 964) mnt->mnt.mnt_sb = fc->root->d_sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 965) mnt->mnt.mnt_root = dget(fc->root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 966) mnt->mnt_mountpoint = mnt->mnt.mnt_root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 967) mnt->mnt_parent = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 968)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 969) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 970) list_add_tail(&mnt->mnt_instance, &mnt->mnt.mnt_sb->s_mounts);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 971) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 972) return &mnt->mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 973) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 974) EXPORT_SYMBOL(vfs_create_mount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 975)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 976) struct vfsmount *fc_mount(struct fs_context *fc)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 977) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 978) int err = vfs_get_tree(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 979) if (!err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 980) up_write(&fc->root->d_sb->s_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 981) return vfs_create_mount(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 982) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 983) return ERR_PTR(err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 984) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 985) EXPORT_SYMBOL(fc_mount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 986)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 987) struct vfsmount *vfs_kern_mount(struct file_system_type *type,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 988) int flags, const char *name,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 989) void *data)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 990) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 991) struct fs_context *fc;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 992) struct vfsmount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 993) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 994)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 995) if (!type)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 996) return ERR_PTR(-EINVAL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 997)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 998) fc = fs_context_for_mount(type, flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 999) if (IS_ERR(fc))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1000) return ERR_CAST(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1001)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1002) if (name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1003) ret = vfs_parse_fs_string(fc, "source",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1004) name, strlen(name));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1005) if (!ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1006) ret = parse_monolithic_mount_data(fc, data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1007) if (!ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1008) mnt = fc_mount(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1009) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1010) mnt = ERR_PTR(ret);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1011)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1012) put_fs_context(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1013) return mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1014) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1015) EXPORT_SYMBOL_GPL(vfs_kern_mount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1016)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1017) struct vfsmount *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1018) vfs_submount(const struct dentry *mountpoint, struct file_system_type *type,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1019) const char *name, void *data)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1020) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1021) /* Until it is worked out how to pass the user namespace
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1022) * through from the parent mount to the submount don't support
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1023) * unprivileged mounts with submounts.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1024) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1025) if (mountpoint->d_sb->s_user_ns != &init_user_ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1026) return ERR_PTR(-EPERM);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1027)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1028) return vfs_kern_mount(type, SB_SUBMOUNT, name, data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1029) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1030) EXPORT_SYMBOL_GPL(vfs_submount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1031)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1032) static struct mount *clone_mnt(struct mount *old, struct dentry *root,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1033) int flag)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1034) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1035) struct super_block *sb = old->mnt.mnt_sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1036) struct mount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1037) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1038)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1039) mnt = alloc_vfsmnt(old->mnt_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1040) if (!mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1041) return ERR_PTR(-ENOMEM);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1042)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1043) if (flag & (CL_SLAVE | CL_PRIVATE | CL_SHARED_TO_SLAVE))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1044) mnt->mnt_group_id = 0; /* not a peer of original */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1045) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1046) mnt->mnt_group_id = old->mnt_group_id;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1047)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1048) if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1049) err = mnt_alloc_group_id(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1050) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1051) goto out_free;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1052) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1053)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1054) mnt->mnt.mnt_flags = old->mnt.mnt_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1055) mnt->mnt.mnt_flags &= ~(MNT_WRITE_HOLD|MNT_MARKED|MNT_INTERNAL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1056)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1057) atomic_inc(&sb->s_active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1058) mnt->mnt.mnt_sb = sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1059) mnt->mnt.mnt_root = dget(root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1060) mnt->mnt_mountpoint = mnt->mnt.mnt_root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1061) mnt->mnt_parent = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1062) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1063) list_add_tail(&mnt->mnt_instance, &sb->s_mounts);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1064) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1065)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1066) if ((flag & CL_SLAVE) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1067) ((flag & CL_SHARED_TO_SLAVE) && IS_MNT_SHARED(old))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1068) list_add(&mnt->mnt_slave, &old->mnt_slave_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1069) mnt->mnt_master = old;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1070) CLEAR_MNT_SHARED(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1071) } else if (!(flag & CL_PRIVATE)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1072) if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(old))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1073) list_add(&mnt->mnt_share, &old->mnt_share);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1074) if (IS_MNT_SLAVE(old))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1075) list_add(&mnt->mnt_slave, &old->mnt_slave);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1076) mnt->mnt_master = old->mnt_master;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1077) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1078) CLEAR_MNT_SHARED(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1079) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1080) if (flag & CL_MAKE_SHARED)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1081) set_mnt_shared(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1082)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1083) /* stick the duplicate mount on the same expiry list
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1084) * as the original if that was on one */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1085) if (flag & CL_EXPIRE) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1086) if (!list_empty(&old->mnt_expire))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1087) list_add(&mnt->mnt_expire, &old->mnt_expire);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1088) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1089)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1090) return mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1091)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1092) out_free:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1093) mnt_free_id(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1094) free_vfsmnt(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1095) return ERR_PTR(err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1096) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1097)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1098) static void cleanup_mnt(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1099) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1100) struct hlist_node *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1101) struct mount *m;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1102) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1103) * The warning here probably indicates that somebody messed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1104) * up a mnt_want/drop_write() pair. If this happens, the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1105) * filesystem was probably unable to make r/w->r/o transitions.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1106) * The locking used to deal with mnt_count decrement provides barriers,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1107) * so mnt_get_writers() below is safe.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1108) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1109) WARN_ON(mnt_get_writers(mnt));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1110) if (unlikely(mnt->mnt_pins.first))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1111) mnt_pin_kill(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1112) hlist_for_each_entry_safe(m, p, &mnt->mnt_stuck_children, mnt_umount) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1113) hlist_del(&m->mnt_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1114) mntput(&m->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1115) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1116) fsnotify_vfsmount_delete(&mnt->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1117) dput(mnt->mnt.mnt_root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1118) deactivate_super(mnt->mnt.mnt_sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1119) mnt_free_id(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1120) call_rcu(&mnt->mnt_rcu, delayed_free_vfsmnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1121) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1122)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1123) static void __cleanup_mnt(struct rcu_head *head)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1124) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1125) cleanup_mnt(container_of(head, struct mount, mnt_rcu));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1126) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1127)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1128) static LLIST_HEAD(delayed_mntput_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1129) static void delayed_mntput(struct work_struct *unused)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1130) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1131) struct llist_node *node = llist_del_all(&delayed_mntput_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1132) struct mount *m, *t;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1133)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1134) llist_for_each_entry_safe(m, t, node, mnt_llist)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1135) cleanup_mnt(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1136) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1137) static DECLARE_DELAYED_WORK(delayed_mntput_work, delayed_mntput);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1138)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1139) static void mntput_no_expire(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1140) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1141) LIST_HEAD(list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1142) int count;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1143)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1144) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1145) if (likely(READ_ONCE(mnt->mnt_ns))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1146) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1147) * Since we don't do lock_mount_hash() here,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1148) * ->mnt_ns can change under us. However, if it's
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1149) * non-NULL, then there's a reference that won't
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1150) * be dropped until after an RCU delay done after
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1151) * turning ->mnt_ns NULL. So if we observe it
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1152) * non-NULL under rcu_read_lock(), the reference
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1153) * we are dropping is not the final one.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1154) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1155) mnt_add_count(mnt, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1156) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1157) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1158) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1159) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1160) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1161) * make sure that if __legitimize_mnt() has not seen us grab
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1162) * mount_lock, we'll see their refcount increment here.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1163) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1164) smp_mb();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1165) mnt_add_count(mnt, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1166) count = mnt_get_count(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1167) if (count != 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1168) WARN_ON(count < 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1169) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1170) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1171) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1172) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1173) if (unlikely(mnt->mnt.mnt_flags & MNT_DOOMED)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1174) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1175) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1176) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1177) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1178) mnt->mnt.mnt_flags |= MNT_DOOMED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1179) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1180)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1181) list_del(&mnt->mnt_instance);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1182)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1183) if (unlikely(!list_empty(&mnt->mnt_mounts))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1184) struct mount *p, *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1185) list_for_each_entry_safe(p, tmp, &mnt->mnt_mounts, mnt_child) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1186) __put_mountpoint(unhash_mnt(p), &list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1187) hlist_add_head(&p->mnt_umount, &mnt->mnt_stuck_children);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1188) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1189) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1190) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1191) shrink_dentry_list(&list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1192)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1193) if (likely(!(mnt->mnt.mnt_flags & MNT_INTERNAL))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1194) struct task_struct *task = current;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1195) if (likely(!(task->flags & PF_KTHREAD))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1196) init_task_work(&mnt->mnt_rcu, __cleanup_mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1197) if (!task_work_add(task, &mnt->mnt_rcu, TWA_RESUME))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1198) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1199) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1200) if (llist_add(&mnt->mnt_llist, &delayed_mntput_list))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1201) schedule_delayed_work(&delayed_mntput_work, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1202) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1203) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1204) cleanup_mnt(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1205) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1206)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1207) void mntput(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1208) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1209) if (mnt) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1210) struct mount *m = real_mount(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1211) /* avoid cacheline pingpong, hope gcc doesn't get "smart" */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1212) if (unlikely(m->mnt_expiry_mark))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1213) m->mnt_expiry_mark = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1214) mntput_no_expire(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1215) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1216) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1217) EXPORT_SYMBOL(mntput);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1218)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1219) struct vfsmount *mntget(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1220) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1221) if (mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1222) mnt_add_count(real_mount(mnt), 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1223) return mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1224) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1225) EXPORT_SYMBOL(mntget);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1226)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1227) /* path_is_mountpoint() - Check if path is a mount in the current
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1228) * namespace.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1229) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1230) * d_mountpoint() can only be used reliably to establish if a dentry is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1231) * not mounted in any namespace and that common case is handled inline.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1232) * d_mountpoint() isn't aware of the possibility there may be multiple
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1233) * mounts using a given dentry in a different namespace. This function
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1234) * checks if the passed in path is a mountpoint rather than the dentry
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1235) * alone.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1236) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1237) bool path_is_mountpoint(const struct path *path)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1238) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1239) unsigned seq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1240) bool res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1241)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1242) if (!d_mountpoint(path->dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1243) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1244)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1245) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1246) do {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1247) seq = read_seqbegin(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1248) res = __path_is_mountpoint(path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1249) } while (read_seqretry(&mount_lock, seq));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1250) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1251)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1252) return res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1253) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1254) EXPORT_SYMBOL(path_is_mountpoint);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1255)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1256) struct vfsmount *mnt_clone_internal(const struct path *path)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1257) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1258) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1259) p = clone_mnt(real_mount(path->mnt), path->dentry, CL_PRIVATE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1260) if (IS_ERR(p))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1261) return ERR_CAST(p);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1262) p->mnt.mnt_flags |= MNT_INTERNAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1263) return &p->mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1264) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1265)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1266) #ifdef CONFIG_PROC_FS
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1267) static struct mount *mnt_list_next(struct mnt_namespace *ns,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1268) struct list_head *p)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1269) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1270) struct mount *mnt, *ret = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1271)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1272) lock_ns_list(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1273) list_for_each_continue(p, &ns->list) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1274) mnt = list_entry(p, typeof(*mnt), mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1275) if (!mnt_is_cursor(mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1276) ret = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1277) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1278) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1279) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1280) unlock_ns_list(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1281)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1282) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1283) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1284)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1285) /* iterator; we want it to have access to namespace_sem, thus here... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1286) static void *m_start(struct seq_file *m, loff_t *pos)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1287) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1288) struct proc_mounts *p = m->private;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1289) struct list_head *prev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1290)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1291) down_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1292) if (!*pos) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1293) prev = &p->ns->list;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1294) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1295) prev = &p->cursor.mnt_list;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1296)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1297) /* Read after we'd reached the end? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1298) if (list_empty(prev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1299) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1300) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1301)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1302) return mnt_list_next(p->ns, prev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1303) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1304)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1305) static void *m_next(struct seq_file *m, void *v, loff_t *pos)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1306) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1307) struct proc_mounts *p = m->private;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1308) struct mount *mnt = v;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1309)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1310) ++*pos;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1311) return mnt_list_next(p->ns, &mnt->mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1312) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1313)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1314) static void m_stop(struct seq_file *m, void *v)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1315) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1316) struct proc_mounts *p = m->private;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1317) struct mount *mnt = v;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1318)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1319) lock_ns_list(p->ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1320) if (mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1321) list_move_tail(&p->cursor.mnt_list, &mnt->mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1322) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1323) list_del_init(&p->cursor.mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1324) unlock_ns_list(p->ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1325) up_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1326) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1327)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1328) static int m_show(struct seq_file *m, void *v)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1329) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1330) struct proc_mounts *p = m->private;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1331) struct mount *r = v;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1332) return p->show(m, &r->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1333) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1334)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1335) const struct seq_operations mounts_op = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1336) .start = m_start,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1337) .next = m_next,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1338) .stop = m_stop,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1339) .show = m_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1340) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1341)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1342) void mnt_cursor_del(struct mnt_namespace *ns, struct mount *cursor)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1343) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1344) down_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1345) lock_ns_list(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1346) list_del(&cursor->mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1347) unlock_ns_list(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1348) up_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1349) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1350) #endif /* CONFIG_PROC_FS */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1351)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1352) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1353) * may_umount_tree - check if a mount tree is busy
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1354) * @mnt: root of mount tree
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1355) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1356) * This is called to check if a tree of mounts has any
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1357) * open files, pwds, chroots or sub mounts that are
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1358) * busy.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1359) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1360) int may_umount_tree(struct vfsmount *m)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1361) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1362) struct mount *mnt = real_mount(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1363) int actual_refs = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1364) int minimum_refs = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1365) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1366) BUG_ON(!m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1367)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1368) /* write lock needed for mnt_get_count */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1369) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1370) for (p = mnt; p; p = next_mnt(p, mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1371) actual_refs += mnt_get_count(p);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1372) minimum_refs += 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1373) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1374) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1375)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1376) if (actual_refs > minimum_refs)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1377) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1378)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1379) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1380) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1381)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1382) EXPORT_SYMBOL(may_umount_tree);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1383)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1384) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1385) * may_umount - check if a mount point is busy
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1386) * @mnt: root of mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1387) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1388) * This is called to check if a mount point has any
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1389) * open files, pwds, chroots or sub mounts. If the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1390) * mount has sub mounts this will return busy
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1391) * regardless of whether the sub mounts are busy.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1392) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1393) * Doesn't take quota and stuff into account. IOW, in some cases it will
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1394) * give false negatives. The main reason why it's here is that we need
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1395) * a non-destructive way to look for easily umountable filesystems.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1396) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1397) int may_umount(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1398) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1399) int ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1400) down_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1401) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1402) if (propagate_mount_busy(real_mount(mnt), 2))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1403) ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1404) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1405) up_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1406) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1407) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1408)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1409) EXPORT_SYMBOL(may_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1410)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1411) static void namespace_unlock(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1412) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1413) struct hlist_head head;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1414) struct hlist_node *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1415) struct mount *m;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1416) LIST_HEAD(list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1417)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1418) hlist_move_list(&unmounted, &head);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1419) list_splice_init(&ex_mountpoints, &list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1420)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1421) up_write(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1422)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1423) shrink_dentry_list(&list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1424)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1425) if (likely(hlist_empty(&head)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1426) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1427)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1428) synchronize_rcu_expedited();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1429)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1430) hlist_for_each_entry_safe(m, p, &head, mnt_umount) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1431) hlist_del(&m->mnt_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1432) mntput(&m->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1433) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1434) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1435)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1436) static inline void namespace_lock(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1437) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1438) down_write(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1439) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1440)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1441) enum umount_tree_flags {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1442) UMOUNT_SYNC = 1,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1443) UMOUNT_PROPAGATE = 2,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1444) UMOUNT_CONNECTED = 4,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1445) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1446)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1447) static bool disconnect_mount(struct mount *mnt, enum umount_tree_flags how)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1448) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1449) /* Leaving mounts connected is only valid for lazy umounts */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1450) if (how & UMOUNT_SYNC)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1451) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1452)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1453) /* A mount without a parent has nothing to be connected to */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1454) if (!mnt_has_parent(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1455) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1456)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1457) /* Because the reference counting rules change when mounts are
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1458) * unmounted and connected, umounted mounts may not be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1459) * connected to mounted mounts.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1460) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1461) if (!(mnt->mnt_parent->mnt.mnt_flags & MNT_UMOUNT))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1462) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1463)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1464) /* Has it been requested that the mount remain connected? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1465) if (how & UMOUNT_CONNECTED)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1466) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1467)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1468) /* Is the mount locked such that it needs to remain connected? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1469) if (IS_MNT_LOCKED(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1470) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1471)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1472) /* By default disconnect the mount */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1473) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1474) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1475)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1476) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1477) * mount_lock must be held
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1478) * namespace_sem must be held for write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1479) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1480) static void umount_tree(struct mount *mnt, enum umount_tree_flags how)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1481) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1482) LIST_HEAD(tmp_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1483) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1484)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1485) if (how & UMOUNT_PROPAGATE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1486) propagate_mount_unlock(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1487)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1488) /* Gather the mounts to umount */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1489) for (p = mnt; p; p = next_mnt(p, mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1490) p->mnt.mnt_flags |= MNT_UMOUNT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1491) list_move(&p->mnt_list, &tmp_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1492) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1493)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1494) /* Hide the mounts from mnt_mounts */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1495) list_for_each_entry(p, &tmp_list, mnt_list) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1496) list_del_init(&p->mnt_child);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1497) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1498)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1499) /* Add propogated mounts to the tmp_list */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1500) if (how & UMOUNT_PROPAGATE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1501) propagate_umount(&tmp_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1502)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1503) while (!list_empty(&tmp_list)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1504) struct mnt_namespace *ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1505) bool disconnect;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1506) p = list_first_entry(&tmp_list, struct mount, mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1507) list_del_init(&p->mnt_expire);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1508) list_del_init(&p->mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1509) ns = p->mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1510) if (ns) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1511) ns->mounts--;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1512) __touch_mnt_namespace(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1513) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1514) p->mnt_ns = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1515) if (how & UMOUNT_SYNC)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1516) p->mnt.mnt_flags |= MNT_SYNC_UMOUNT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1517)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1518) disconnect = disconnect_mount(p, how);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1519) if (mnt_has_parent(p)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1520) mnt_add_count(p->mnt_parent, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1521) if (!disconnect) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1522) /* Don't forget about p */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1523) list_add_tail(&p->mnt_child, &p->mnt_parent->mnt_mounts);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1524) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1525) umount_mnt(p);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1526) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1527) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1528) change_mnt_propagation(p, MS_PRIVATE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1529) if (disconnect)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1530) hlist_add_head(&p->mnt_umount, &unmounted);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1531) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1532) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1533)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1534) static void shrink_submounts(struct mount *mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1535)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1536) static int do_umount_root(struct super_block *sb)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1537) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1538) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1539)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1540) down_write(&sb->s_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1541) if (!sb_rdonly(sb)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1542) struct fs_context *fc;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1543)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1544) fc = fs_context_for_reconfigure(sb->s_root, SB_RDONLY,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1545) SB_RDONLY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1546) if (IS_ERR(fc)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1547) ret = PTR_ERR(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1548) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1549) ret = parse_monolithic_mount_data(fc, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1550) if (!ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1551) ret = reconfigure_super(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1552) put_fs_context(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1553) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1554) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1555) up_write(&sb->s_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1556) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1557) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1558)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1559) static int do_umount(struct mount *mnt, int flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1560) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1561) struct super_block *sb = mnt->mnt.mnt_sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1562) int retval;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1563)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1564) retval = security_sb_umount(&mnt->mnt, flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1565) if (retval)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1566) return retval;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1567)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1568) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1569) * Allow userspace to request a mountpoint be expired rather than
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1570) * unmounting unconditionally. Unmount only happens if:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1571) * (1) the mark is already set (the mark is cleared by mntput())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1572) * (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount]
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1573) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1574) if (flags & MNT_EXPIRE) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1575) if (&mnt->mnt == current->fs->root.mnt ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1576) flags & (MNT_FORCE | MNT_DETACH))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1577) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1578)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1579) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1580) * probably don't strictly need the lock here if we examined
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1581) * all race cases, but it's a slowpath.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1582) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1583) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1584) if (mnt_get_count(mnt) != 2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1585) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1586) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1587) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1588) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1589)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1590) if (!xchg(&mnt->mnt_expiry_mark, 1))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1591) return -EAGAIN;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1592) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1593)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1594) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1595) * If we may have to abort operations to get out of this
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1596) * mount, and they will themselves hold resources we must
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1597) * allow the fs to do things. In the Unix tradition of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1598) * 'Gee thats tricky lets do it in userspace' the umount_begin
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1599) * might fail to complete on the first run through as other tasks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1600) * must return, and the like. Thats for the mount program to worry
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1601) * about for the moment.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1602) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1603)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1604) if (flags & MNT_FORCE && sb->s_op->umount_begin) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1605) sb->s_op->umount_begin(sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1606) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1607)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1608) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1609) * No sense to grab the lock for this test, but test itself looks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1610) * somewhat bogus. Suggestions for better replacement?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1611) * Ho-hum... In principle, we might treat that as umount + switch
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1612) * to rootfs. GC would eventually take care of the old vfsmount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1613) * Actually it makes sense, especially if rootfs would contain a
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1614) * /reboot - static binary that would close all descriptors and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1615) * call reboot(9). Then init(8) could umount root and exec /reboot.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1616) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1617) if (&mnt->mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1618) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1619) * Special case for "unmounting" root ...
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1620) * we just try to remount it readonly.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1621) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1622) if (!ns_capable(sb->s_user_ns, CAP_SYS_ADMIN))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1623) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1624) return do_umount_root(sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1625) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1626)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1627) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1628) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1629)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1630) /* Recheck MNT_LOCKED with the locks held */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1631) retval = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1632) if (mnt->mnt.mnt_flags & MNT_LOCKED)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1633) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1634)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1635) event++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1636) if (flags & MNT_DETACH) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1637) if (!list_empty(&mnt->mnt_list))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1638) umount_tree(mnt, UMOUNT_PROPAGATE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1639) retval = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1640) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1641) shrink_submounts(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1642) retval = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1643) if (!propagate_mount_busy(mnt, 2)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1644) if (!list_empty(&mnt->mnt_list))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1645) umount_tree(mnt, UMOUNT_PROPAGATE|UMOUNT_SYNC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1646) retval = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1647) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1648) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1649) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1650) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1651) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1652) return retval;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1653) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1654)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1655) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1656) * __detach_mounts - lazily unmount all mounts on the specified dentry
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1657) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1658) * During unlink, rmdir, and d_drop it is possible to loose the path
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1659) * to an existing mountpoint, and wind up leaking the mount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1660) * detach_mounts allows lazily unmounting those mounts instead of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1661) * leaking them.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1662) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1663) * The caller may hold dentry->d_inode->i_mutex.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1664) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1665) void __detach_mounts(struct dentry *dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1666) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1667) struct mountpoint *mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1668) struct mount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1669)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1670) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1671) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1672) mp = lookup_mountpoint(dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1673) if (!mp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1674) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1675)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1676) event++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1677) while (!hlist_empty(&mp->m_list)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1678) mnt = hlist_entry(mp->m_list.first, struct mount, mnt_mp_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1679) if (mnt->mnt.mnt_flags & MNT_UMOUNT) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1680) umount_mnt(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1681) hlist_add_head(&mnt->mnt_umount, &unmounted);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1682) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1683) else umount_tree(mnt, UMOUNT_CONNECTED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1684) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1685) put_mountpoint(mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1686) out_unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1687) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1688) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1689) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1690)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1691) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1692) * Is the caller allowed to modify his namespace?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1693) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1694) static inline bool may_mount(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1695) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1696) return ns_capable(current->nsproxy->mnt_ns->user_ns, CAP_SYS_ADMIN);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1697) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1698)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1699) #ifdef CONFIG_MANDATORY_FILE_LOCKING
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1700) static bool may_mandlock(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1701) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1702) pr_warn_once("======================================================\n"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1703) "WARNING: the mand mount option is being deprecated and\n"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1704) " will be removed in v5.15!\n"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1705) "======================================================\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1706) return capable(CAP_SYS_ADMIN);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1707) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1708) #else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1709) static inline bool may_mandlock(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1710) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1711) pr_warn("VFS: \"mand\" mount option not supported");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1712) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1713) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1714) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1715)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1716) static int can_umount(const struct path *path, int flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1717) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1718) struct mount *mnt = real_mount(path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1719)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1720) if (!may_mount())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1721) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1722) if (path->dentry != path->mnt->mnt_root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1723) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1724) if (!check_mnt(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1725) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1726) if (mnt->mnt.mnt_flags & MNT_LOCKED) /* Check optimistically */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1727) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1728) if (flags & MNT_FORCE && !capable(CAP_SYS_ADMIN))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1729) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1730) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1731) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1732)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1733) // caller is responsible for flags being sane
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1734) int path_umount(struct path *path, int flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1735) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1736) struct mount *mnt = real_mount(path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1737) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1738)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1739) ret = can_umount(path, flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1740) if (!ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1741) ret = do_umount(mnt, flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1742)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1743) /* we mustn't call path_put() as that would clear mnt_expiry_mark */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1744) dput(path->dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1745) mntput_no_expire(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1746) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1747) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1748)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1749) static int ksys_umount(char __user *name, int flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1750) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1751) int lookup_flags = LOOKUP_MOUNTPOINT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1752) struct path path;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1753) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1754)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1755) // basic validity checks done first
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1756) if (flags & ~(MNT_FORCE | MNT_DETACH | MNT_EXPIRE | UMOUNT_NOFOLLOW))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1757) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1758)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1759) if (!(flags & UMOUNT_NOFOLLOW))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1760) lookup_flags |= LOOKUP_FOLLOW;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1761) ret = user_path_at(AT_FDCWD, name, lookup_flags, &path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1762) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1763) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1764) return path_umount(&path, flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1765) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1766)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1767) SYSCALL_DEFINE2(umount, char __user *, name, int, flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1768) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1769) return ksys_umount(name, flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1770) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1771)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1772) #ifdef __ARCH_WANT_SYS_OLDUMOUNT
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1773)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1774) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1775) * The 2.0 compatible umount. No flags.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1776) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1777) SYSCALL_DEFINE1(oldumount, char __user *, name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1778) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1779) return ksys_umount(name, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1780) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1781)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1782) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1783)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1784) static bool is_mnt_ns_file(struct dentry *dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1785) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1786) /* Is this a proxy for a mount namespace? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1787) return dentry->d_op == &ns_dentry_operations &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1788) dentry->d_fsdata == &mntns_operations;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1789) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1790)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1791) static struct mnt_namespace *to_mnt_ns(struct ns_common *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1792) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1793) return container_of(ns, struct mnt_namespace, ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1794) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1795)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1796) struct ns_common *from_mnt_ns(struct mnt_namespace *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1797) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1798) return &mnt->ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1799) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1800)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1801) static bool mnt_ns_loop(struct dentry *dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1802) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1803) /* Could bind mounting the mount namespace inode cause a
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1804) * mount namespace loop?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1805) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1806) struct mnt_namespace *mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1807) if (!is_mnt_ns_file(dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1808) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1809)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1810) mnt_ns = to_mnt_ns(get_proc_ns(dentry->d_inode));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1811) return current->nsproxy->mnt_ns->seq >= mnt_ns->seq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1812) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1813)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1814) struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1815) int flag)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1816) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1817) struct mount *res, *p, *q, *r, *parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1818)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1819) if (!(flag & CL_COPY_UNBINDABLE) && IS_MNT_UNBINDABLE(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1820) return ERR_PTR(-EINVAL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1821)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1822) if (!(flag & CL_COPY_MNT_NS_FILE) && is_mnt_ns_file(dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1823) return ERR_PTR(-EINVAL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1824)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1825) res = q = clone_mnt(mnt, dentry, flag);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1826) if (IS_ERR(q))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1827) return q;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1828)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1829) q->mnt_mountpoint = mnt->mnt_mountpoint;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1830)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1831) p = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1832) list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1833) struct mount *s;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1834) if (!is_subdir(r->mnt_mountpoint, dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1835) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1836)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1837) for (s = r; s; s = next_mnt(s, r)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1838) if (!(flag & CL_COPY_UNBINDABLE) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1839) IS_MNT_UNBINDABLE(s)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1840) if (s->mnt.mnt_flags & MNT_LOCKED) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1841) /* Both unbindable and locked. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1842) q = ERR_PTR(-EPERM);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1843) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1844) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1845) s = skip_mnt_tree(s);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1846) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1847) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1848) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1849) if (!(flag & CL_COPY_MNT_NS_FILE) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1850) is_mnt_ns_file(s->mnt.mnt_root)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1851) s = skip_mnt_tree(s);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1852) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1853) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1854) while (p != s->mnt_parent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1855) p = p->mnt_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1856) q = q->mnt_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1857) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1858) p = s;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1859) parent = q;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1860) q = clone_mnt(p, p->mnt.mnt_root, flag);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1861) if (IS_ERR(q))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1862) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1863) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1864) list_add_tail(&q->mnt_list, &res->mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1865) attach_mnt(q, parent, p->mnt_mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1866) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1867) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1868) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1869) return res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1870) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1871) if (res) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1872) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1873) umount_tree(res, UMOUNT_SYNC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1874) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1875) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1876) return q;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1877) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1878)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1879) /* Caller should check returned pointer for errors */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1880)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1881) struct vfsmount *collect_mounts(const struct path *path)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1882) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1883) struct mount *tree;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1884) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1885) if (!check_mnt(real_mount(path->mnt)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1886) tree = ERR_PTR(-EINVAL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1887) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1888) tree = copy_tree(real_mount(path->mnt), path->dentry,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1889) CL_COPY_ALL | CL_PRIVATE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1890) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1891) if (IS_ERR(tree))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1892) return ERR_CAST(tree);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1893) return &tree->mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1894) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1895)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1896) static void free_mnt_ns(struct mnt_namespace *);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1897) static struct mnt_namespace *alloc_mnt_ns(struct user_namespace *, bool);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1898)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1899) void dissolve_on_fput(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1900) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1901) struct mnt_namespace *ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1902) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1903) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1904) ns = real_mount(mnt)->mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1905) if (ns) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1906) if (is_anon_ns(ns))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1907) umount_tree(real_mount(mnt), UMOUNT_CONNECTED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1908) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1909) ns = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1910) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1911) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1912) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1913) if (ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1914) free_mnt_ns(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1915) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1916)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1917) void drop_collected_mounts(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1918) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1919) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1920) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1921) umount_tree(real_mount(mnt), 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1922) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1923) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1924) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1925)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1926) static bool has_locked_children(struct mount *mnt, struct dentry *dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1927) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1928) struct mount *child;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1929)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1930) list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1931) if (!is_subdir(child->mnt_mountpoint, dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1932) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1933)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1934) if (child->mnt.mnt_flags & MNT_LOCKED)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1935) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1936) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1937) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1938) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1939)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1940) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1941) * clone_private_mount - create a private clone of a path
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1942) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1943) * This creates a new vfsmount, which will be the clone of @path. The new will
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1944) * not be attached anywhere in the namespace and will be private (i.e. changes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1945) * to the originating mount won't be propagated into this).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1946) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1947) * Release with mntput().
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1948) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1949) struct vfsmount *clone_private_mount(const struct path *path)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1950) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1951) struct mount *old_mnt = real_mount(path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1952) struct mount *new_mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1953)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1954) down_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1955) if (IS_MNT_UNBINDABLE(old_mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1956) goto invalid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1957)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1958) if (!check_mnt(old_mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1959) goto invalid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1960)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1961) if (has_locked_children(old_mnt, path->dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1962) goto invalid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1963)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1964) new_mnt = clone_mnt(old_mnt, path->dentry, CL_PRIVATE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1965) up_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1966)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1967) if (IS_ERR(new_mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1968) return ERR_CAST(new_mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1969)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1970) /* Longterm mount to be removed by kern_unmount*() */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1971) new_mnt->mnt_ns = MNT_NS_INTERNAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1972)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1973) return &new_mnt->mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1974)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1975) invalid:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1976) up_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1977) return ERR_PTR(-EINVAL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1978) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1979) EXPORT_SYMBOL_GPL(clone_private_mount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1980)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1981) int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1982) struct vfsmount *root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1983) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1984) struct mount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1985) int res = f(root, arg);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1986) if (res)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1987) return res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1988) list_for_each_entry(mnt, &real_mount(root)->mnt_list, mnt_list) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1989) res = f(&mnt->mnt, arg);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1990) if (res)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1991) return res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1992) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1993) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1994) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1995)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1996) static void lock_mnt_tree(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1997) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1998) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1999)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2000) for (p = mnt; p; p = next_mnt(p, mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2001) int flags = p->mnt.mnt_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2002) /* Don't allow unprivileged users to change mount flags */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2003) flags |= MNT_LOCK_ATIME;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2004)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2005) if (flags & MNT_READONLY)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2006) flags |= MNT_LOCK_READONLY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2007)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2008) if (flags & MNT_NODEV)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2009) flags |= MNT_LOCK_NODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2010)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2011) if (flags & MNT_NOSUID)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2012) flags |= MNT_LOCK_NOSUID;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2013)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2014) if (flags & MNT_NOEXEC)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2015) flags |= MNT_LOCK_NOEXEC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2016) /* Don't allow unprivileged users to reveal what is under a mount */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2017) if (list_empty(&p->mnt_expire))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2018) flags |= MNT_LOCKED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2019) p->mnt.mnt_flags = flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2020) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2021) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2022)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2023) static void cleanup_group_ids(struct mount *mnt, struct mount *end)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2024) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2025) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2026)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2027) for (p = mnt; p != end; p = next_mnt(p, mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2028) if (p->mnt_group_id && !IS_MNT_SHARED(p))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2029) mnt_release_group_id(p);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2030) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2031) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2032)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2033) static int invent_group_ids(struct mount *mnt, bool recurse)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2034) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2035) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2036)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2037) for (p = mnt; p; p = recurse ? next_mnt(p, mnt) : NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2038) if (!p->mnt_group_id && !IS_MNT_SHARED(p)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2039) int err = mnt_alloc_group_id(p);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2040) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2041) cleanup_group_ids(mnt, p);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2042) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2043) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2044) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2045) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2046)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2047) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2048) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2049)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2050) int count_mounts(struct mnt_namespace *ns, struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2051) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2052) unsigned int max = READ_ONCE(sysctl_mount_max);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2053) unsigned int mounts = 0, old, pending, sum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2054) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2055)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2056) for (p = mnt; p; p = next_mnt(p, mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2057) mounts++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2058)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2059) old = ns->mounts;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2060) pending = ns->pending_mounts;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2061) sum = old + pending;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2062) if ((old > sum) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2063) (pending > sum) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2064) (max < sum) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2065) (mounts > (max - sum)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2066) return -ENOSPC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2067)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2068) ns->pending_mounts = pending + mounts;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2069) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2070) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2071)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2072) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2073) * @source_mnt : mount tree to be attached
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2074) * @nd : place the mount tree @source_mnt is attached
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2075) * @parent_nd : if non-null, detach the source_mnt from its parent and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2076) * store the parent mount and mountpoint dentry.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2077) * (done when source_mnt is moved)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2078) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2079) * NOTE: in the table below explains the semantics when a source mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2080) * of a given type is attached to a destination mount of a given type.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2081) * ---------------------------------------------------------------------------
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2082) * | BIND MOUNT OPERATION |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2083) * |**************************************************************************
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2084) * | source-->| shared | private | slave | unbindable |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2085) * | dest | | | | |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2086) * | | | | | | |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2087) * | v | | | | |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2088) * |**************************************************************************
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2089) * | shared | shared (++) | shared (+) | shared(+++)| invalid |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2090) * | | | | | |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2091) * |non-shared| shared (+) | private | slave (*) | invalid |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2092) * ***************************************************************************
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2093) * A bind operation clones the source mount and mounts the clone on the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2094) * destination mount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2095) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2096) * (++) the cloned mount is propagated to all the mounts in the propagation
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2097) * tree of the destination mount and the cloned mount is added to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2098) * the peer group of the source mount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2099) * (+) the cloned mount is created under the destination mount and is marked
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2100) * as shared. The cloned mount is added to the peer group of the source
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2101) * mount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2102) * (+++) the mount is propagated to all the mounts in the propagation tree
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2103) * of the destination mount and the cloned mount is made slave
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2104) * of the same master as that of the source mount. The cloned mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2105) * is marked as 'shared and slave'.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2106) * (*) the cloned mount is made a slave of the same master as that of the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2107) * source mount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2108) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2109) * ---------------------------------------------------------------------------
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2110) * | MOVE MOUNT OPERATION |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2111) * |**************************************************************************
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2112) * | source-->| shared | private | slave | unbindable |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2113) * | dest | | | | |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2114) * | | | | | | |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2115) * | v | | | | |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2116) * |**************************************************************************
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2117) * | shared | shared (+) | shared (+) | shared(+++) | invalid |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2118) * | | | | | |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2119) * |non-shared| shared (+*) | private | slave (*) | unbindable |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2120) * ***************************************************************************
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2121) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2122) * (+) the mount is moved to the destination. And is then propagated to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2123) * all the mounts in the propagation tree of the destination mount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2124) * (+*) the mount is moved to the destination.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2125) * (+++) the mount is moved to the destination and is then propagated to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2126) * all the mounts belonging to the destination mount's propagation tree.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2127) * the mount is marked as 'shared and slave'.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2128) * (*) the mount continues to be a slave at the new location.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2129) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2130) * if the source mount is a tree, the operations explained above is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2131) * applied to each mount in the tree.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2132) * Must be called without spinlocks held, since this function can sleep
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2133) * in allocations.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2134) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2135) static int attach_recursive_mnt(struct mount *source_mnt,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2136) struct mount *dest_mnt,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2137) struct mountpoint *dest_mp,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2138) bool moving)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2139) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2140) struct user_namespace *user_ns = current->nsproxy->mnt_ns->user_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2141) HLIST_HEAD(tree_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2142) struct mnt_namespace *ns = dest_mnt->mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2143) struct mountpoint *smp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2144) struct mount *child, *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2145) struct hlist_node *n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2146) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2147)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2148) /* Preallocate a mountpoint in case the new mounts need
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2149) * to be tucked under other mounts.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2150) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2151) smp = get_mountpoint(source_mnt->mnt.mnt_root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2152) if (IS_ERR(smp))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2153) return PTR_ERR(smp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2154)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2155) /* Is there space to add these mounts to the mount namespace? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2156) if (!moving) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2157) err = count_mounts(ns, source_mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2158) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2159) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2160) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2161)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2162) if (IS_MNT_SHARED(dest_mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2163) err = invent_group_ids(source_mnt, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2164) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2165) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2166) err = propagate_mnt(dest_mnt, dest_mp, source_mnt, &tree_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2167) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2168) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2169) goto out_cleanup_ids;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2170) for (p = source_mnt; p; p = next_mnt(p, source_mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2171) set_mnt_shared(p);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2172) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2173) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2174) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2175) if (moving) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2176) unhash_mnt(source_mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2177) attach_mnt(source_mnt, dest_mnt, dest_mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2178) touch_mnt_namespace(source_mnt->mnt_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2179) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2180) if (source_mnt->mnt_ns) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2181) /* move from anon - the caller will destroy */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2182) list_del_init(&source_mnt->mnt_ns->list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2183) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2184) mnt_set_mountpoint(dest_mnt, dest_mp, source_mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2185) commit_tree(source_mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2186) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2187)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2188) hlist_for_each_entry_safe(child, n, &tree_list, mnt_hash) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2189) struct mount *q;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2190) hlist_del_init(&child->mnt_hash);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2191) q = __lookup_mnt(&child->mnt_parent->mnt,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2192) child->mnt_mountpoint);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2193) if (q)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2194) mnt_change_mountpoint(child, smp, q);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2195) /* Notice when we are propagating across user namespaces */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2196) if (child->mnt_parent->mnt_ns->user_ns != user_ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2197) lock_mnt_tree(child);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2198) child->mnt.mnt_flags &= ~MNT_LOCKED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2199) commit_tree(child);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2200) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2201) put_mountpoint(smp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2202) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2203)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2204) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2205)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2206) out_cleanup_ids:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2207) while (!hlist_empty(&tree_list)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2208) child = hlist_entry(tree_list.first, struct mount, mnt_hash);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2209) child->mnt_parent->mnt_ns->pending_mounts = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2210) umount_tree(child, UMOUNT_SYNC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2211) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2212) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2213) cleanup_group_ids(source_mnt, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2214) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2215) ns->pending_mounts = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2216)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2217) read_seqlock_excl(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2218) put_mountpoint(smp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2219) read_sequnlock_excl(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2220)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2221) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2222) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2223)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2224) static struct mountpoint *lock_mount(struct path *path)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2225) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2226) struct vfsmount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2227) struct dentry *dentry = path->dentry;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2228) retry:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2229) inode_lock(dentry->d_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2230) if (unlikely(cant_mount(dentry))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2231) inode_unlock(dentry->d_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2232) return ERR_PTR(-ENOENT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2233) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2234) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2235) mnt = lookup_mnt(path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2236) if (likely(!mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2237) struct mountpoint *mp = get_mountpoint(dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2238) if (IS_ERR(mp)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2239) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2240) inode_unlock(dentry->d_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2241) return mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2242) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2243) return mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2244) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2245) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2246) inode_unlock(path->dentry->d_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2247) path_put(path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2248) path->mnt = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2249) dentry = path->dentry = dget(mnt->mnt_root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2250) goto retry;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2251) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2252)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2253) static void unlock_mount(struct mountpoint *where)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2254) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2255) struct dentry *dentry = where->m_dentry;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2256)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2257) read_seqlock_excl(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2258) put_mountpoint(where);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2259) read_sequnlock_excl(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2260)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2261) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2262) inode_unlock(dentry->d_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2263) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2264)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2265) static int graft_tree(struct mount *mnt, struct mount *p, struct mountpoint *mp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2266) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2267) if (mnt->mnt.mnt_sb->s_flags & SB_NOUSER)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2268) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2269)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2270) if (d_is_dir(mp->m_dentry) !=
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2271) d_is_dir(mnt->mnt.mnt_root))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2272) return -ENOTDIR;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2273)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2274) return attach_recursive_mnt(mnt, p, mp, false);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2275) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2276)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2277) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2278) * Sanity check the flags to change_mnt_propagation.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2279) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2280)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2281) static int flags_to_propagation_type(int ms_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2282) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2283) int type = ms_flags & ~(MS_REC | MS_SILENT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2284)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2285) /* Fail if any non-propagation flags are set */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2286) if (type & ~(MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2287) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2288) /* Only one propagation flag should be set */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2289) if (!is_power_of_2(type))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2290) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2291) return type;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2292) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2293)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2294) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2295) * recursively change the type of the mountpoint.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2296) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2297) static int do_change_type(struct path *path, int ms_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2298) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2299) struct mount *m;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2300) struct mount *mnt = real_mount(path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2301) int recurse = ms_flags & MS_REC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2302) int type;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2303) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2304)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2305) if (path->dentry != path->mnt->mnt_root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2306) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2307)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2308) type = flags_to_propagation_type(ms_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2309) if (!type)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2310) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2311)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2312) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2313) if (type == MS_SHARED) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2314) err = invent_group_ids(mnt, recurse);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2315) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2316) goto out_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2317) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2318)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2319) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2320) for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2321) change_mnt_propagation(m, type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2322) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2323)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2324) out_unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2325) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2326) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2327) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2328)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2329) static struct mount *__do_loopback(struct path *old_path, int recurse)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2330) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2331) struct mount *mnt = ERR_PTR(-EINVAL), *old = real_mount(old_path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2332)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2333) if (IS_MNT_UNBINDABLE(old))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2334) return mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2335)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2336) if (!check_mnt(old) && old_path->dentry->d_op != &ns_dentry_operations)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2337) return mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2338)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2339) if (!recurse && has_locked_children(old, old_path->dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2340) return mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2341)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2342) if (recurse)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2343) mnt = copy_tree(old, old_path->dentry, CL_COPY_MNT_NS_FILE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2344) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2345) mnt = clone_mnt(old, old_path->dentry, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2346)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2347) if (!IS_ERR(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2348) mnt->mnt.mnt_flags &= ~MNT_LOCKED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2349)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2350) return mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2351) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2352)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2353) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2354) * do loopback mount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2355) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2356) static int do_loopback(struct path *path, const char *old_name,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2357) int recurse)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2358) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2359) struct path old_path;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2360) struct mount *mnt = NULL, *parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2361) struct mountpoint *mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2362) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2363) if (!old_name || !*old_name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2364) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2365) err = kern_path(old_name, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &old_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2366) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2367) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2368)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2369) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2370) if (mnt_ns_loop(old_path.dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2371) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2372)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2373) mp = lock_mount(path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2374) if (IS_ERR(mp)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2375) err = PTR_ERR(mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2376) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2377) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2378)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2379) parent = real_mount(path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2380) if (!check_mnt(parent))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2381) goto out2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2382)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2383) mnt = __do_loopback(&old_path, recurse);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2384) if (IS_ERR(mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2385) err = PTR_ERR(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2386) goto out2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2387) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2388)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2389) err = graft_tree(mnt, parent, mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2390) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2391) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2392) umount_tree(mnt, UMOUNT_SYNC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2393) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2394) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2395) out2:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2396) unlock_mount(mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2397) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2398) path_put(&old_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2399) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2400) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2401)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2402) static struct file *open_detached_copy(struct path *path, bool recursive)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2403) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2404) struct user_namespace *user_ns = current->nsproxy->mnt_ns->user_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2405) struct mnt_namespace *ns = alloc_mnt_ns(user_ns, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2406) struct mount *mnt, *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2407) struct file *file;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2408)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2409) if (IS_ERR(ns))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2410) return ERR_CAST(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2411)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2412) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2413) mnt = __do_loopback(path, recursive);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2414) if (IS_ERR(mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2415) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2416) free_mnt_ns(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2417) return ERR_CAST(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2418) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2419)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2420) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2421) for (p = mnt; p; p = next_mnt(p, mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2422) p->mnt_ns = ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2423) ns->mounts++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2424) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2425) ns->root = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2426) list_add_tail(&ns->list, &mnt->mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2427) mntget(&mnt->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2428) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2429) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2430)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2431) mntput(path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2432) path->mnt = &mnt->mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2433) file = dentry_open(path, O_PATH, current_cred());
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2434) if (IS_ERR(file))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2435) dissolve_on_fput(path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2436) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2437) file->f_mode |= FMODE_NEED_UNMOUNT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2438) return file;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2439) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2440)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2441) SYSCALL_DEFINE3(open_tree, int, dfd, const char __user *, filename, unsigned, flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2442) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2443) struct file *file;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2444) struct path path;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2445) int lookup_flags = LOOKUP_AUTOMOUNT | LOOKUP_FOLLOW;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2446) bool detached = flags & OPEN_TREE_CLONE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2447) int error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2448) int fd;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2449)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2450) BUILD_BUG_ON(OPEN_TREE_CLOEXEC != O_CLOEXEC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2451)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2452) if (flags & ~(AT_EMPTY_PATH | AT_NO_AUTOMOUNT | AT_RECURSIVE |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2453) AT_SYMLINK_NOFOLLOW | OPEN_TREE_CLONE |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2454) OPEN_TREE_CLOEXEC))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2455) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2456)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2457) if ((flags & (AT_RECURSIVE | OPEN_TREE_CLONE)) == AT_RECURSIVE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2458) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2459)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2460) if (flags & AT_NO_AUTOMOUNT)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2461) lookup_flags &= ~LOOKUP_AUTOMOUNT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2462) if (flags & AT_SYMLINK_NOFOLLOW)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2463) lookup_flags &= ~LOOKUP_FOLLOW;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2464) if (flags & AT_EMPTY_PATH)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2465) lookup_flags |= LOOKUP_EMPTY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2466)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2467) if (detached && !may_mount())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2468) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2469)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2470) fd = get_unused_fd_flags(flags & O_CLOEXEC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2471) if (fd < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2472) return fd;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2473)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2474) error = user_path_at(dfd, filename, lookup_flags, &path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2475) if (unlikely(error)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2476) file = ERR_PTR(error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2477) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2478) if (detached)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2479) file = open_detached_copy(&path, flags & AT_RECURSIVE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2480) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2481) file = dentry_open(&path, O_PATH, current_cred());
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2482) path_put(&path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2483) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2484) if (IS_ERR(file)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2485) put_unused_fd(fd);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2486) return PTR_ERR(file);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2487) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2488) fd_install(fd, file);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2489) return fd;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2490) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2491)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2492) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2493) * Don't allow locked mount flags to be cleared.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2494) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2495) * No locks need to be held here while testing the various MNT_LOCK
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2496) * flags because those flags can never be cleared once they are set.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2497) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2498) static bool can_change_locked_flags(struct mount *mnt, unsigned int mnt_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2499) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2500) unsigned int fl = mnt->mnt.mnt_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2501)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2502) if ((fl & MNT_LOCK_READONLY) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2503) !(mnt_flags & MNT_READONLY))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2504) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2505)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2506) if ((fl & MNT_LOCK_NODEV) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2507) !(mnt_flags & MNT_NODEV))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2508) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2509)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2510) if ((fl & MNT_LOCK_NOSUID) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2511) !(mnt_flags & MNT_NOSUID))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2512) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2513)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2514) if ((fl & MNT_LOCK_NOEXEC) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2515) !(mnt_flags & MNT_NOEXEC))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2516) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2517)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2518) if ((fl & MNT_LOCK_ATIME) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2519) ((fl & MNT_ATIME_MASK) != (mnt_flags & MNT_ATIME_MASK)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2520) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2521)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2522) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2523) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2524)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2525) static int change_mount_ro_state(struct mount *mnt, unsigned int mnt_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2526) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2527) bool readonly_request = (mnt_flags & MNT_READONLY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2528)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2529) if (readonly_request == __mnt_is_readonly(&mnt->mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2530) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2531)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2532) if (readonly_request)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2533) return mnt_make_readonly(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2534)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2535) return __mnt_unmake_readonly(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2536) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2537)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2538) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2539) * Update the user-settable attributes on a mount. The caller must hold
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2540) * sb->s_umount for writing.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2541) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2542) static void set_mount_attributes(struct mount *mnt, unsigned int mnt_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2543) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2544) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2545) mnt_flags |= mnt->mnt.mnt_flags & ~MNT_USER_SETTABLE_MASK;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2546) mnt->mnt.mnt_flags = mnt_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2547) touch_mnt_namespace(mnt->mnt_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2548) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2549) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2550)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2551) static void mnt_warn_timestamp_expiry(struct path *mountpoint, struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2552) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2553) struct super_block *sb = mnt->mnt_sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2554)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2555) if (!__mnt_is_readonly(mnt) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2556) (ktime_get_real_seconds() + TIME_UPTIME_SEC_MAX > sb->s_time_max)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2557) char *buf = (char *)__get_free_page(GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2558) char *mntpath = buf ? d_path(mountpoint, buf, PAGE_SIZE) : ERR_PTR(-ENOMEM);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2559) struct tm tm;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2560)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2561) time64_to_tm(sb->s_time_max, 0, &tm);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2562)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2563) pr_warn("%s filesystem being %s at %s supports timestamps until %04ld (0x%llx)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2564) sb->s_type->name,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2565) is_mounted(mnt) ? "remounted" : "mounted",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2566) mntpath,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2567) tm.tm_year+1900, (unsigned long long)sb->s_time_max);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2568)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2569) free_page((unsigned long)buf);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2570) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2571) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2572)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2573) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2574) * Handle reconfiguration of the mountpoint only without alteration of the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2575) * superblock it refers to. This is triggered by specifying MS_REMOUNT|MS_BIND
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2576) * to mount(2).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2577) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2578) static int do_reconfigure_mnt(struct path *path, unsigned int mnt_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2579) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2580) struct super_block *sb = path->mnt->mnt_sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2581) struct mount *mnt = real_mount(path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2582) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2583)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2584) if (!check_mnt(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2585) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2586)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2587) if (path->dentry != mnt->mnt.mnt_root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2588) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2589)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2590) if (!can_change_locked_flags(mnt, mnt_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2591) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2592)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2593) down_write(&sb->s_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2594) ret = change_mount_ro_state(mnt, mnt_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2595) if (ret == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2596) set_mount_attributes(mnt, mnt_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2597) up_write(&sb->s_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2598)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2599) mnt_warn_timestamp_expiry(path, &mnt->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2600)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2601) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2602) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2603)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2604) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2605) * change filesystem flags. dir should be a physical root of filesystem.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2606) * If you've mounted a non-root directory somewhere and want to do remount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2607) * on it - tough luck.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2608) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2609) static int do_remount(struct path *path, int ms_flags, int sb_flags,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2610) int mnt_flags, void *data)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2611) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2612) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2613) struct super_block *sb = path->mnt->mnt_sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2614) struct mount *mnt = real_mount(path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2615) struct fs_context *fc;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2616)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2617) if (!check_mnt(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2618) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2619)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2620) if (path->dentry != path->mnt->mnt_root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2621) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2622)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2623) if (!can_change_locked_flags(mnt, mnt_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2624) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2625)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2626) fc = fs_context_for_reconfigure(path->dentry, sb_flags, MS_RMT_MASK);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2627) if (IS_ERR(fc))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2628) return PTR_ERR(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2629)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2630) fc->oldapi = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2631) err = parse_monolithic_mount_data(fc, data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2632) if (!err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2633) down_write(&sb->s_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2634) err = -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2635) if (ns_capable(sb->s_user_ns, CAP_SYS_ADMIN)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2636) err = reconfigure_super(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2637) if (!err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2638) set_mount_attributes(mnt, mnt_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2639) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2640) up_write(&sb->s_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2641) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2642)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2643) mnt_warn_timestamp_expiry(path, &mnt->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2644)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2645) put_fs_context(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2646) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2647) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2648)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2649) static inline int tree_contains_unbindable(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2650) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2651) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2652) for (p = mnt; p; p = next_mnt(p, mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2653) if (IS_MNT_UNBINDABLE(p))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2654) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2655) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2656) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2657) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2658)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2659) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2660) * Check that there aren't references to earlier/same mount namespaces in the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2661) * specified subtree. Such references can act as pins for mount namespaces
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2662) * that aren't checked by the mount-cycle checking code, thereby allowing
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2663) * cycles to be made.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2664) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2665) static bool check_for_nsfs_mounts(struct mount *subtree)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2666) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2667) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2668) bool ret = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2669)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2670) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2671) for (p = subtree; p; p = next_mnt(p, subtree))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2672) if (mnt_ns_loop(p->mnt.mnt_root))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2673) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2674)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2675) ret = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2676) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2677) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2678) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2679) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2680)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2681) static int do_move_mount(struct path *old_path, struct path *new_path)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2682) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2683) struct mnt_namespace *ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2684) struct mount *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2685) struct mount *old;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2686) struct mount *parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2687) struct mountpoint *mp, *old_mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2688) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2689) bool attached;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2690)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2691) mp = lock_mount(new_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2692) if (IS_ERR(mp))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2693) return PTR_ERR(mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2694)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2695) old = real_mount(old_path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2696) p = real_mount(new_path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2697) parent = old->mnt_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2698) attached = mnt_has_parent(old);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2699) old_mp = old->mnt_mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2700) ns = old->mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2701)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2702) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2703) /* The mountpoint must be in our namespace. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2704) if (!check_mnt(p))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2705) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2706)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2707) /* The thing moved must be mounted... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2708) if (!is_mounted(&old->mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2709) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2710)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2711) /* ... and either ours or the root of anon namespace */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2712) if (!(attached ? check_mnt(old) : is_anon_ns(ns)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2713) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2714)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2715) if (old->mnt.mnt_flags & MNT_LOCKED)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2716) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2717)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2718) if (old_path->dentry != old_path->mnt->mnt_root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2719) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2720)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2721) if (d_is_dir(new_path->dentry) !=
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2722) d_is_dir(old_path->dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2723) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2724) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2725) * Don't move a mount residing in a shared parent.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2726) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2727) if (attached && IS_MNT_SHARED(parent))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2728) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2729) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2730) * Don't move a mount tree containing unbindable mounts to a destination
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2731) * mount which is shared.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2732) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2733) if (IS_MNT_SHARED(p) && tree_contains_unbindable(old))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2734) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2735) err = -ELOOP;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2736) if (!check_for_nsfs_mounts(old))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2737) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2738) for (; mnt_has_parent(p); p = p->mnt_parent)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2739) if (p == old)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2740) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2741)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2742) err = attach_recursive_mnt(old, real_mount(new_path->mnt), mp,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2743) attached);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2744) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2745) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2746)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2747) /* if the mount is moved, it should no longer be expire
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2748) * automatically */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2749) list_del_init(&old->mnt_expire);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2750) if (attached)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2751) put_mountpoint(old_mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2752) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2753) unlock_mount(mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2754) if (!err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2755) if (attached)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2756) mntput_no_expire(parent);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2757) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2758) free_mnt_ns(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2759) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2760) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2761) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2762)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2763) static int do_move_mount_old(struct path *path, const char *old_name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2764) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2765) struct path old_path;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2766) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2767)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2768) if (!old_name || !*old_name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2769) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2770)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2771) err = kern_path(old_name, LOOKUP_FOLLOW, &old_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2772) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2773) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2774)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2775) err = do_move_mount(&old_path, path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2776) path_put(&old_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2777) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2778) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2779)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2780) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2781) * add a mount into a namespace's mount tree
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2782) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2783) static int do_add_mount(struct mount *newmnt, struct mountpoint *mp,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2784) struct path *path, int mnt_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2785) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2786) struct mount *parent = real_mount(path->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2787)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2788) mnt_flags &= ~MNT_INTERNAL_FLAGS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2789)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2790) if (unlikely(!check_mnt(parent))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2791) /* that's acceptable only for automounts done in private ns */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2792) if (!(mnt_flags & MNT_SHRINKABLE))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2793) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2794) /* ... and for those we'd better have mountpoint still alive */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2795) if (!parent->mnt_ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2796) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2797) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2798)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2799) /* Refuse the same filesystem on the same mount point */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2800) if (path->mnt->mnt_sb == newmnt->mnt.mnt_sb &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2801) path->mnt->mnt_root == path->dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2802) return -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2803)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2804) if (d_is_symlink(newmnt->mnt.mnt_root))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2805) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2806)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2807) newmnt->mnt.mnt_flags = mnt_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2808) return graft_tree(newmnt, parent, mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2809) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2810)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2811) static bool mount_too_revealing(const struct super_block *sb, int *new_mnt_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2812)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2813) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2814) * Create a new mount using a superblock configuration and request it
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2815) * be added to the namespace tree.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2816) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2817) static int do_new_mount_fc(struct fs_context *fc, struct path *mountpoint,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2818) unsigned int mnt_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2819) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2820) struct vfsmount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2821) struct mountpoint *mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2822) struct super_block *sb = fc->root->d_sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2823) int error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2824)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2825) error = security_sb_kern_mount(sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2826) if (!error && mount_too_revealing(sb, &mnt_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2827) error = -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2828)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2829) if (unlikely(error)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2830) fc_drop_locked(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2831) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2832) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2833)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2834) up_write(&sb->s_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2835)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2836) mnt = vfs_create_mount(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2837) if (IS_ERR(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2838) return PTR_ERR(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2839)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2840) mnt_warn_timestamp_expiry(mountpoint, mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2841)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2842) mp = lock_mount(mountpoint);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2843) if (IS_ERR(mp)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2844) mntput(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2845) return PTR_ERR(mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2846) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2847) error = do_add_mount(real_mount(mnt), mp, mountpoint, mnt_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2848) unlock_mount(mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2849) if (error < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2850) mntput(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2851) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2852) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2853)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2854) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2855) * create a new mount for userspace and request it to be added into the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2856) * namespace's tree
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2857) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2858) static int do_new_mount(struct path *path, const char *fstype, int sb_flags,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2859) int mnt_flags, const char *name, void *data)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2860) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2861) struct file_system_type *type;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2862) struct fs_context *fc;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2863) const char *subtype = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2864) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2865)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2866) if (!fstype)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2867) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2868)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2869) type = get_fs_type(fstype);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2870) if (!type)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2871) return -ENODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2872)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2873) if (type->fs_flags & FS_HAS_SUBTYPE) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2874) subtype = strchr(fstype, '.');
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2875) if (subtype) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2876) subtype++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2877) if (!*subtype) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2878) put_filesystem(type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2879) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2880) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2881) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2882) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2883)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2884) fc = fs_context_for_mount(type, sb_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2885) put_filesystem(type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2886) if (IS_ERR(fc))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2887) return PTR_ERR(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2888)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2889) if (subtype)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2890) err = vfs_parse_fs_string(fc, "subtype",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2891) subtype, strlen(subtype));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2892) if (!err && name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2893) err = vfs_parse_fs_string(fc, "source", name, strlen(name));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2894) if (!err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2895) err = parse_monolithic_mount_data(fc, data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2896) if (!err && !mount_capable(fc))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2897) err = -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2898) if (!err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2899) err = vfs_get_tree(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2900) if (!err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2901) err = do_new_mount_fc(fc, path, mnt_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2902)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2903) put_fs_context(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2904) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2905) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2906)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2907) int finish_automount(struct vfsmount *m, struct path *path)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2908) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2909) struct dentry *dentry = path->dentry;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2910) struct mountpoint *mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2911) struct mount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2912) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2913)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2914) if (!m)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2915) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2916) if (IS_ERR(m))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2917) return PTR_ERR(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2918)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2919) mnt = real_mount(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2920) /* The new mount record should have at least 2 refs to prevent it being
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2921) * expired before we get a chance to add it
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2922) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2923) BUG_ON(mnt_get_count(mnt) < 2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2924)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2925) if (m->mnt_sb == path->mnt->mnt_sb &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2926) m->mnt_root == dentry) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2927) err = -ELOOP;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2928) goto discard;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2929) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2930)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2931) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2932) * we don't want to use lock_mount() - in this case finding something
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2933) * that overmounts our mountpoint to be means "quitely drop what we've
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2934) * got", not "try to mount it on top".
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2935) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2936) inode_lock(dentry->d_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2937) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2938) if (unlikely(cant_mount(dentry))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2939) err = -ENOENT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2940) goto discard_locked;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2941) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2942) rcu_read_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2943) if (unlikely(__lookup_mnt(path->mnt, dentry))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2944) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2945) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2946) goto discard_locked;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2947) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2948) rcu_read_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2949) mp = get_mountpoint(dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2950) if (IS_ERR(mp)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2951) err = PTR_ERR(mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2952) goto discard_locked;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2953) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2954)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2955) err = do_add_mount(mnt, mp, path, path->mnt->mnt_flags | MNT_SHRINKABLE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2956) unlock_mount(mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2957) if (unlikely(err))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2958) goto discard;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2959) mntput(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2960) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2961)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2962) discard_locked:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2963) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2964) inode_unlock(dentry->d_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2965) discard:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2966) /* remove m from any expiration list it may be on */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2967) if (!list_empty(&mnt->mnt_expire)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2968) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2969) list_del_init(&mnt->mnt_expire);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2970) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2971) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2972) mntput(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2973) mntput(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2974) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2975) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2976)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2977) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2978) * mnt_set_expiry - Put a mount on an expiration list
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2979) * @mnt: The mount to list.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2980) * @expiry_list: The list to add the mount to.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2981) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2982) void mnt_set_expiry(struct vfsmount *mnt, struct list_head *expiry_list)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2983) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2984) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2985)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2986) list_add_tail(&real_mount(mnt)->mnt_expire, expiry_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2987)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2988) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2989) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2990) EXPORT_SYMBOL(mnt_set_expiry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2991)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2992) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2993) * process a list of expirable mountpoints with the intent of discarding any
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2994) * mountpoints that aren't in use and haven't been touched since last we came
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2995) * here
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2996) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2997) void mark_mounts_for_expiry(struct list_head *mounts)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2998) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2999) struct mount *mnt, *next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3000) LIST_HEAD(graveyard);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3001)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3002) if (list_empty(mounts))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3003) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3004)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3005) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3006) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3007)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3008) /* extract from the expiration list every vfsmount that matches the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3009) * following criteria:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3010) * - only referenced by its parent vfsmount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3011) * - still marked for expiry (marked on the last call here; marks are
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3012) * cleared by mntput())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3013) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3014) list_for_each_entry_safe(mnt, next, mounts, mnt_expire) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3015) if (!xchg(&mnt->mnt_expiry_mark, 1) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3016) propagate_mount_busy(mnt, 1))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3017) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3018) list_move(&mnt->mnt_expire, &graveyard);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3019) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3020) while (!list_empty(&graveyard)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3021) mnt = list_first_entry(&graveyard, struct mount, mnt_expire);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3022) touch_mnt_namespace(mnt->mnt_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3023) umount_tree(mnt, UMOUNT_PROPAGATE|UMOUNT_SYNC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3024) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3025) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3026) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3027) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3028)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3029) EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3030)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3031) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3032) * Ripoff of 'select_parent()'
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3033) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3034) * search the list of submounts for a given mountpoint, and move any
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3035) * shrinkable submounts to the 'graveyard' list.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3036) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3037) static int select_submounts(struct mount *parent, struct list_head *graveyard)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3038) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3039) struct mount *this_parent = parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3040) struct list_head *next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3041) int found = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3042)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3043) repeat:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3044) next = this_parent->mnt_mounts.next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3045) resume:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3046) while (next != &this_parent->mnt_mounts) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3047) struct list_head *tmp = next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3048) struct mount *mnt = list_entry(tmp, struct mount, mnt_child);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3049)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3050) next = tmp->next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3051) if (!(mnt->mnt.mnt_flags & MNT_SHRINKABLE))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3052) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3053) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3054) * Descend a level if the d_mounts list is non-empty.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3055) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3056) if (!list_empty(&mnt->mnt_mounts)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3057) this_parent = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3058) goto repeat;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3059) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3060)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3061) if (!propagate_mount_busy(mnt, 1)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3062) list_move_tail(&mnt->mnt_expire, graveyard);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3063) found++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3064) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3065) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3066) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3067) * All done at this level ... ascend and resume the search
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3068) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3069) if (this_parent != parent) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3070) next = this_parent->mnt_child.next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3071) this_parent = this_parent->mnt_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3072) goto resume;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3073) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3074) return found;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3075) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3076)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3077) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3078) * process a list of expirable mountpoints with the intent of discarding any
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3079) * submounts of a specific parent mountpoint
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3080) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3081) * mount_lock must be held for write
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3082) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3083) static void shrink_submounts(struct mount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3084) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3085) LIST_HEAD(graveyard);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3086) struct mount *m;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3087)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3088) /* extract submounts of 'mountpoint' from the expiration list */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3089) while (select_submounts(mnt, &graveyard)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3090) while (!list_empty(&graveyard)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3091) m = list_first_entry(&graveyard, struct mount,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3092) mnt_expire);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3093) touch_mnt_namespace(m->mnt_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3094) umount_tree(m, UMOUNT_PROPAGATE|UMOUNT_SYNC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3095) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3096) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3097) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3098)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3099) static void *copy_mount_options(const void __user * data)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3100) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3101) char *copy;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3102) unsigned left, offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3103)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3104) if (!data)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3105) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3106)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3107) copy = kmalloc(PAGE_SIZE, GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3108) if (!copy)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3109) return ERR_PTR(-ENOMEM);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3110)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3111) left = copy_from_user(copy, data, PAGE_SIZE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3112)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3113) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3114) * Not all architectures have an exact copy_from_user(). Resort to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3115) * byte at a time.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3116) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3117) offset = PAGE_SIZE - left;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3118) while (left) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3119) char c;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3120) if (get_user(c, (const char __user *)data + offset))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3121) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3122) copy[offset] = c;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3123) left--;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3124) offset++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3125) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3126)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3127) if (left == PAGE_SIZE) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3128) kfree(copy);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3129) return ERR_PTR(-EFAULT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3130) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3131)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3132) return copy;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3133) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3134)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3135) static char *copy_mount_string(const void __user *data)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3136) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3137) return data ? strndup_user(data, PATH_MAX) : NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3138) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3139)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3140) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3141) * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3142) * be given to the mount() call (ie: read-only, no-dev, no-suid etc).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3143) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3144) * data is a (void *) that can point to any structure up to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3145) * PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3146) * information (or be NULL).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3147) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3148) * Pre-0.97 versions of mount() didn't have a flags word.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3149) * When the flags word was introduced its top half was required
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3150) * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3151) * Therefore, if this magic number is present, it carries no information
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3152) * and must be discarded.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3153) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3154) int path_mount(const char *dev_name, struct path *path,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3155) const char *type_page, unsigned long flags, void *data_page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3156) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3157) unsigned int mnt_flags = 0, sb_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3158) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3159)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3160) /* Discard magic */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3161) if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3162) flags &= ~MS_MGC_MSK;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3163)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3164) /* Basic sanity checks */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3165) if (data_page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3166) ((char *)data_page)[PAGE_SIZE - 1] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3167)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3168) if (flags & MS_NOUSER)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3169) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3170)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3171) ret = security_sb_mount(dev_name, path, type_page, flags, data_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3172) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3173) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3174) if (!may_mount())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3175) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3176) if ((flags & SB_MANDLOCK) && !may_mandlock())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3177) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3178)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3179) /* Default to relatime unless overriden */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3180) if (!(flags & MS_NOATIME))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3181) mnt_flags |= MNT_RELATIME;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3182)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3183) /* Separate the per-mountpoint flags */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3184) if (flags & MS_NOSUID)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3185) mnt_flags |= MNT_NOSUID;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3186) if (flags & MS_NODEV)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3187) mnt_flags |= MNT_NODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3188) if (flags & MS_NOEXEC)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3189) mnt_flags |= MNT_NOEXEC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3190) if (flags & MS_NOATIME)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3191) mnt_flags |= MNT_NOATIME;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3192) if (flags & MS_NODIRATIME)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3193) mnt_flags |= MNT_NODIRATIME;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3194) if (flags & MS_STRICTATIME)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3195) mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3196) if (flags & MS_RDONLY)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3197) mnt_flags |= MNT_READONLY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3198) if (flags & MS_NOSYMFOLLOW)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3199) mnt_flags |= MNT_NOSYMFOLLOW;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3200)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3201) /* The default atime for remount is preservation */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3202) if ((flags & MS_REMOUNT) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3203) ((flags & (MS_NOATIME | MS_NODIRATIME | MS_RELATIME |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3204) MS_STRICTATIME)) == 0)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3205) mnt_flags &= ~MNT_ATIME_MASK;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3206) mnt_flags |= path->mnt->mnt_flags & MNT_ATIME_MASK;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3207) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3208)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3209) sb_flags = flags & (SB_RDONLY |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3210) SB_SYNCHRONOUS |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3211) SB_MANDLOCK |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3212) SB_DIRSYNC |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3213) SB_SILENT |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3214) SB_POSIXACL |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3215) SB_LAZYTIME |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3216) SB_I_VERSION);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3217)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3218) if ((flags & (MS_REMOUNT | MS_BIND)) == (MS_REMOUNT | MS_BIND))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3219) return do_reconfigure_mnt(path, mnt_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3220) if (flags & MS_REMOUNT)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3221) return do_remount(path, flags, sb_flags, mnt_flags, data_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3222) if (flags & MS_BIND)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3223) return do_loopback(path, dev_name, flags & MS_REC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3224) if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3225) return do_change_type(path, flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3226) if (flags & MS_MOVE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3227) return do_move_mount_old(path, dev_name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3228)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3229) return do_new_mount(path, type_page, sb_flags, mnt_flags, dev_name,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3230) data_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3231) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3232)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3233) long do_mount(const char *dev_name, const char __user *dir_name,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3234) const char *type_page, unsigned long flags, void *data_page)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3235) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3236) struct path path;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3237) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3238)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3239) ret = user_path_at(AT_FDCWD, dir_name, LOOKUP_FOLLOW, &path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3240) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3241) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3242) ret = path_mount(dev_name, &path, type_page, flags, data_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3243) path_put(&path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3244) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3245) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3246)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3247) static struct ucounts *inc_mnt_namespaces(struct user_namespace *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3248) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3249) return inc_ucount(ns, current_euid(), UCOUNT_MNT_NAMESPACES);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3250) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3251)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3252) static void dec_mnt_namespaces(struct ucounts *ucounts)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3253) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3254) dec_ucount(ucounts, UCOUNT_MNT_NAMESPACES);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3255) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3256)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3257) static void free_mnt_ns(struct mnt_namespace *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3258) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3259) if (!is_anon_ns(ns))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3260) ns_free_inum(&ns->ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3261) dec_mnt_namespaces(ns->ucounts);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3262) put_user_ns(ns->user_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3263) kfree(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3264) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3265)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3266) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3267) * Assign a sequence number so we can detect when we attempt to bind
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3268) * mount a reference to an older mount namespace into the current
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3269) * mount namespace, preventing reference counting loops. A 64bit
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3270) * number incrementing at 10Ghz will take 12,427 years to wrap which
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3271) * is effectively never, so we can ignore the possibility.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3272) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3273) static atomic64_t mnt_ns_seq = ATOMIC64_INIT(1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3274)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3275) static struct mnt_namespace *alloc_mnt_ns(struct user_namespace *user_ns, bool anon)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3276) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3277) struct mnt_namespace *new_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3278) struct ucounts *ucounts;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3279) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3280)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3281) ucounts = inc_mnt_namespaces(user_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3282) if (!ucounts)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3283) return ERR_PTR(-ENOSPC);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3284)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3285) new_ns = kzalloc(sizeof(struct mnt_namespace), GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3286) if (!new_ns) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3287) dec_mnt_namespaces(ucounts);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3288) return ERR_PTR(-ENOMEM);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3289) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3290) if (!anon) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3291) ret = ns_alloc_inum(&new_ns->ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3292) if (ret) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3293) kfree(new_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3294) dec_mnt_namespaces(ucounts);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3295) return ERR_PTR(ret);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3296) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3297) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3298) new_ns->ns.ops = &mntns_operations;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3299) if (!anon)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3300) new_ns->seq = atomic64_add_return(1, &mnt_ns_seq);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3301) atomic_set(&new_ns->count, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3302) INIT_LIST_HEAD(&new_ns->list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3303) init_waitqueue_head(&new_ns->poll);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3304) spin_lock_init(&new_ns->ns_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3305) new_ns->user_ns = get_user_ns(user_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3306) new_ns->ucounts = ucounts;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3307) return new_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3308) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3309)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3310) __latent_entropy
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3311) struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3312) struct user_namespace *user_ns, struct fs_struct *new_fs)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3313) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3314) struct mnt_namespace *new_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3315) struct vfsmount *rootmnt = NULL, *pwdmnt = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3316) struct mount *p, *q;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3317) struct mount *old;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3318) struct mount *new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3319) int copy_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3320)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3321) BUG_ON(!ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3322)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3323) if (likely(!(flags & CLONE_NEWNS))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3324) get_mnt_ns(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3325) return ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3326) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3327)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3328) old = ns->root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3329)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3330) new_ns = alloc_mnt_ns(user_ns, false);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3331) if (IS_ERR(new_ns))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3332) return new_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3333)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3334) namespace_lock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3335) /* First pass: copy the tree topology */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3336) copy_flags = CL_COPY_UNBINDABLE | CL_EXPIRE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3337) if (user_ns != ns->user_ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3338) copy_flags |= CL_SHARED_TO_SLAVE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3339) new = copy_tree(old, old->mnt.mnt_root, copy_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3340) if (IS_ERR(new)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3341) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3342) free_mnt_ns(new_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3343) return ERR_CAST(new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3344) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3345) if (user_ns != ns->user_ns) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3346) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3347) lock_mnt_tree(new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3348) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3349) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3350) new_ns->root = new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3351) list_add_tail(&new_ns->list, &new->mnt_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3352)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3353) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3354) * Second pass: switch the tsk->fs->* elements and mark new vfsmounts
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3355) * as belonging to new namespace. We have already acquired a private
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3356) * fs_struct, so tsk->fs->lock is not needed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3357) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3358) p = old;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3359) q = new;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3360) while (p) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3361) q->mnt_ns = new_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3362) new_ns->mounts++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3363) if (new_fs) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3364) if (&p->mnt == new_fs->root.mnt) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3365) new_fs->root.mnt = mntget(&q->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3366) rootmnt = &p->mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3367) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3368) if (&p->mnt == new_fs->pwd.mnt) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3369) new_fs->pwd.mnt = mntget(&q->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3370) pwdmnt = &p->mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3371) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3372) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3373) p = next_mnt(p, old);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3374) q = next_mnt(q, new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3375) if (!q)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3376) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3377) while (p->mnt.mnt_root != q->mnt.mnt_root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3378) p = next_mnt(p, old);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3379) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3380) namespace_unlock();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3381)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3382) if (rootmnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3383) mntput(rootmnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3384) if (pwdmnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3385) mntput(pwdmnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3386)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3387) return new_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3388) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3389)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3390) struct dentry *mount_subtree(struct vfsmount *m, const char *name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3391) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3392) struct mount *mnt = real_mount(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3393) struct mnt_namespace *ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3394) struct super_block *s;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3395) struct path path;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3396) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3397)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3398) ns = alloc_mnt_ns(&init_user_ns, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3399) if (IS_ERR(ns)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3400) mntput(m);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3401) return ERR_CAST(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3402) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3403) mnt->mnt_ns = ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3404) ns->root = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3405) ns->mounts++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3406) list_add(&mnt->mnt_list, &ns->list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3407)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3408) err = vfs_path_lookup(m->mnt_root, m,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3409) name, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3410)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3411) put_mnt_ns(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3412)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3413) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3414) return ERR_PTR(err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3415)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3416) /* trade a vfsmount reference for active sb one */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3417) s = path.mnt->mnt_sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3418) atomic_inc(&s->s_active);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3419) mntput(path.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3420) /* lock the sucker */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3421) down_write(&s->s_umount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3422) /* ... and return the root of (sub)tree on it */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3423) return path.dentry;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3424) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3425) EXPORT_SYMBOL(mount_subtree);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3426)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3427) SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3428) char __user *, type, unsigned long, flags, void __user *, data)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3429) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3430) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3431) char *kernel_type;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3432) char *kernel_dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3433) void *options;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3434)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3435) kernel_type = copy_mount_string(type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3436) ret = PTR_ERR(kernel_type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3437) if (IS_ERR(kernel_type))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3438) goto out_type;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3439)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3440) kernel_dev = copy_mount_string(dev_name);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3441) ret = PTR_ERR(kernel_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3442) if (IS_ERR(kernel_dev))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3443) goto out_dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3444)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3445) options = copy_mount_options(data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3446) ret = PTR_ERR(options);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3447) if (IS_ERR(options))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3448) goto out_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3449)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3450) ret = do_mount(kernel_dev, dir_name, kernel_type, flags, options);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3451)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3452) kfree(options);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3453) out_data:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3454) kfree(kernel_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3455) out_dev:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3456) kfree(kernel_type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3457) out_type:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3458) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3459) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3460)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3461) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3462) * Create a kernel mount representation for a new, prepared superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3463) * (specified by fs_fd) and attach to an open_tree-like file descriptor.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3464) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3465) SYSCALL_DEFINE3(fsmount, int, fs_fd, unsigned int, flags,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3466) unsigned int, attr_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3467) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3468) struct mnt_namespace *ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3469) struct fs_context *fc;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3470) struct file *file;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3471) struct path newmount;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3472) struct mount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3473) struct fd f;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3474) unsigned int mnt_flags = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3475) long ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3476)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3477) if (!may_mount())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3478) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3479)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3480) if ((flags & ~(FSMOUNT_CLOEXEC)) != 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3481) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3482)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3483) if (attr_flags & ~(MOUNT_ATTR_RDONLY |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3484) MOUNT_ATTR_NOSUID |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3485) MOUNT_ATTR_NODEV |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3486) MOUNT_ATTR_NOEXEC |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3487) MOUNT_ATTR__ATIME |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3488) MOUNT_ATTR_NODIRATIME))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3489) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3490)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3491) if (attr_flags & MOUNT_ATTR_RDONLY)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3492) mnt_flags |= MNT_READONLY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3493) if (attr_flags & MOUNT_ATTR_NOSUID)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3494) mnt_flags |= MNT_NOSUID;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3495) if (attr_flags & MOUNT_ATTR_NODEV)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3496) mnt_flags |= MNT_NODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3497) if (attr_flags & MOUNT_ATTR_NOEXEC)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3498) mnt_flags |= MNT_NOEXEC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3499) if (attr_flags & MOUNT_ATTR_NODIRATIME)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3500) mnt_flags |= MNT_NODIRATIME;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3501)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3502) switch (attr_flags & MOUNT_ATTR__ATIME) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3503) case MOUNT_ATTR_STRICTATIME:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3504) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3505) case MOUNT_ATTR_NOATIME:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3506) mnt_flags |= MNT_NOATIME;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3507) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3508) case MOUNT_ATTR_RELATIME:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3509) mnt_flags |= MNT_RELATIME;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3510) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3511) default:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3512) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3513) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3514)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3515) f = fdget(fs_fd);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3516) if (!f.file)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3517) return -EBADF;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3518)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3519) ret = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3520) if (f.file->f_op != &fscontext_fops)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3521) goto err_fsfd;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3522)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3523) fc = f.file->private_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3524)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3525) ret = mutex_lock_interruptible(&fc->uapi_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3526) if (ret < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3527) goto err_fsfd;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3528)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3529) /* There must be a valid superblock or we can't mount it */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3530) ret = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3531) if (!fc->root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3532) goto err_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3533)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3534) ret = -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3535) if (mount_too_revealing(fc->root->d_sb, &mnt_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3536) pr_warn("VFS: Mount too revealing\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3537) goto err_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3538) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3539)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3540) ret = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3541) if (fc->phase != FS_CONTEXT_AWAITING_MOUNT)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3542) goto err_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3543)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3544) ret = -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3545) if ((fc->sb_flags & SB_MANDLOCK) && !may_mandlock())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3546) goto err_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3547)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3548) newmount.mnt = vfs_create_mount(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3549) if (IS_ERR(newmount.mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3550) ret = PTR_ERR(newmount.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3551) goto err_unlock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3552) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3553) newmount.dentry = dget(fc->root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3554) newmount.mnt->mnt_flags = mnt_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3555)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3556) /* We've done the mount bit - now move the file context into more or
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3557) * less the same state as if we'd done an fspick(). We don't want to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3558) * do any memory allocation or anything like that at this point as we
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3559) * don't want to have to handle any errors incurred.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3560) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3561) vfs_clean_context(fc);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3562)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3563) ns = alloc_mnt_ns(current->nsproxy->mnt_ns->user_ns, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3564) if (IS_ERR(ns)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3565) ret = PTR_ERR(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3566) goto err_path;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3567) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3568) mnt = real_mount(newmount.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3569) mnt->mnt_ns = ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3570) ns->root = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3571) ns->mounts = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3572) list_add(&mnt->mnt_list, &ns->list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3573) mntget(newmount.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3574)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3575) /* Attach to an apparent O_PATH fd with a note that we need to unmount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3576) * it, not just simply put it.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3577) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3578) file = dentry_open(&newmount, O_PATH, fc->cred);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3579) if (IS_ERR(file)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3580) dissolve_on_fput(newmount.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3581) ret = PTR_ERR(file);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3582) goto err_path;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3583) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3584) file->f_mode |= FMODE_NEED_UNMOUNT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3585)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3586) ret = get_unused_fd_flags((flags & FSMOUNT_CLOEXEC) ? O_CLOEXEC : 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3587) if (ret >= 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3588) fd_install(ret, file);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3589) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3590) fput(file);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3591)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3592) err_path:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3593) path_put(&newmount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3594) err_unlock:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3595) mutex_unlock(&fc->uapi_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3596) err_fsfd:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3597) fdput(f);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3598) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3599) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3600)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3601) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3602) * Move a mount from one place to another. In combination with
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3603) * fsopen()/fsmount() this is used to install a new mount and in combination
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3604) * with open_tree(OPEN_TREE_CLONE [| AT_RECURSIVE]) it can be used to copy
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3605) * a mount subtree.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3606) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3607) * Note the flags value is a combination of MOVE_MOUNT_* flags.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3608) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3609) SYSCALL_DEFINE5(move_mount,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3610) int, from_dfd, const char __user *, from_pathname,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3611) int, to_dfd, const char __user *, to_pathname,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3612) unsigned int, flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3613) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3614) struct path from_path, to_path;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3615) unsigned int lflags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3616) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3617)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3618) if (!may_mount())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3619) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3620)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3621) if (flags & ~MOVE_MOUNT__MASK)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3622) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3623)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3624) /* If someone gives a pathname, they aren't permitted to move
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3625) * from an fd that requires unmount as we can't get at the flag
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3626) * to clear it afterwards.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3627) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3628) lflags = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3629) if (flags & MOVE_MOUNT_F_SYMLINKS) lflags |= LOOKUP_FOLLOW;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3630) if (flags & MOVE_MOUNT_F_AUTOMOUNTS) lflags |= LOOKUP_AUTOMOUNT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3631) if (flags & MOVE_MOUNT_F_EMPTY_PATH) lflags |= LOOKUP_EMPTY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3632)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3633) ret = user_path_at(from_dfd, from_pathname, lflags, &from_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3634) if (ret < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3635) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3636)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3637) lflags = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3638) if (flags & MOVE_MOUNT_T_SYMLINKS) lflags |= LOOKUP_FOLLOW;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3639) if (flags & MOVE_MOUNT_T_AUTOMOUNTS) lflags |= LOOKUP_AUTOMOUNT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3640) if (flags & MOVE_MOUNT_T_EMPTY_PATH) lflags |= LOOKUP_EMPTY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3641)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3642) ret = user_path_at(to_dfd, to_pathname, lflags, &to_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3643) if (ret < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3644) goto out_from;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3645)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3646) ret = security_move_mount(&from_path, &to_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3647) if (ret < 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3648) goto out_to;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3649)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3650) ret = do_move_mount(&from_path, &to_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3651)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3652) out_to:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3653) path_put(&to_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3654) out_from:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3655) path_put(&from_path);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3656) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3657) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3658)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3659) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3660) * Return true if path is reachable from root
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3661) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3662) * namespace_sem or mount_lock is held
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3663) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3664) bool is_path_reachable(struct mount *mnt, struct dentry *dentry,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3665) const struct path *root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3666) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3667) while (&mnt->mnt != root->mnt && mnt_has_parent(mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3668) dentry = mnt->mnt_mountpoint;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3669) mnt = mnt->mnt_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3670) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3671) return &mnt->mnt == root->mnt && is_subdir(dentry, root->dentry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3672) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3673)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3674) bool path_is_under(const struct path *path1, const struct path *path2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3675) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3676) bool res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3677) read_seqlock_excl(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3678) res = is_path_reachable(real_mount(path1->mnt), path1->dentry, path2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3679) read_sequnlock_excl(&mount_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3680) return res;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3681) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3682) EXPORT_SYMBOL(path_is_under);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3683)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3684) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3685) * pivot_root Semantics:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3686) * Moves the root file system of the current process to the directory put_old,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3687) * makes new_root as the new root file system of the current process, and sets
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3688) * root/cwd of all processes which had them on the current root to new_root.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3689) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3690) * Restrictions:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3691) * The new_root and put_old must be directories, and must not be on the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3692) * same file system as the current process root. The put_old must be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3693) * underneath new_root, i.e. adding a non-zero number of /.. to the string
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3694) * pointed to by put_old must yield the same directory as new_root. No other
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3695) * file system may be mounted on put_old. After all, new_root is a mountpoint.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3696) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3697) * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3698) * See Documentation/filesystems/ramfs-rootfs-initramfs.rst for alternatives
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3699) * in this situation.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3700) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3701) * Notes:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3702) * - we don't move root/cwd if they are not at the root (reason: if something
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3703) * cared enough to change them, it's probably wrong to force them elsewhere)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3704) * - it's okay to pick a root that isn't the root of a file system, e.g.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3705) * /nfs/my_root where /nfs is the mount point. It must be a mountpoint,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3706) * though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3707) * first.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3708) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3709) SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3710) const char __user *, put_old)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3711) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3712) struct path new, old, root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3713) struct mount *new_mnt, *root_mnt, *old_mnt, *root_parent, *ex_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3714) struct mountpoint *old_mp, *root_mp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3715) int error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3716)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3717) if (!may_mount())
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3718) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3719)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3720) error = user_path_at(AT_FDCWD, new_root,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3721) LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3722) if (error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3723) goto out0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3724)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3725) error = user_path_at(AT_FDCWD, put_old,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3726) LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &old);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3727) if (error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3728) goto out1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3729)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3730) error = security_sb_pivotroot(&old, &new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3731) if (error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3732) goto out2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3733)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3734) get_fs_root(current->fs, &root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3735) old_mp = lock_mount(&old);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3736) error = PTR_ERR(old_mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3737) if (IS_ERR(old_mp))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3738) goto out3;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3739)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3740) error = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3741) new_mnt = real_mount(new.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3742) root_mnt = real_mount(root.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3743) old_mnt = real_mount(old.mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3744) ex_parent = new_mnt->mnt_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3745) root_parent = root_mnt->mnt_parent;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3746) if (IS_MNT_SHARED(old_mnt) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3747) IS_MNT_SHARED(ex_parent) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3748) IS_MNT_SHARED(root_parent))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3749) goto out4;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3750) if (!check_mnt(root_mnt) || !check_mnt(new_mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3751) goto out4;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3752) if (new_mnt->mnt.mnt_flags & MNT_LOCKED)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3753) goto out4;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3754) error = -ENOENT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3755) if (d_unlinked(new.dentry))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3756) goto out4;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3757) error = -EBUSY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3758) if (new_mnt == root_mnt || old_mnt == root_mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3759) goto out4; /* loop, on the same file system */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3760) error = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3761) if (root.mnt->mnt_root != root.dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3762) goto out4; /* not a mountpoint */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3763) if (!mnt_has_parent(root_mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3764) goto out4; /* not attached */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3765) if (new.mnt->mnt_root != new.dentry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3766) goto out4; /* not a mountpoint */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3767) if (!mnt_has_parent(new_mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3768) goto out4; /* not attached */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3769) /* make sure we can reach put_old from new_root */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3770) if (!is_path_reachable(old_mnt, old.dentry, &new))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3771) goto out4;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3772) /* make certain new is below the root */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3773) if (!is_path_reachable(new_mnt, new.dentry, &root))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3774) goto out4;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3775) lock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3776) umount_mnt(new_mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3777) root_mp = unhash_mnt(root_mnt); /* we'll need its mountpoint */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3778) if (root_mnt->mnt.mnt_flags & MNT_LOCKED) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3779) new_mnt->mnt.mnt_flags |= MNT_LOCKED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3780) root_mnt->mnt.mnt_flags &= ~MNT_LOCKED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3781) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3782) /* mount old root on put_old */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3783) attach_mnt(root_mnt, old_mnt, old_mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3784) /* mount new_root on / */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3785) attach_mnt(new_mnt, root_parent, root_mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3786) mnt_add_count(root_parent, -1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3787) touch_mnt_namespace(current->nsproxy->mnt_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3788) /* A moved mount should not expire automatically */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3789) list_del_init(&new_mnt->mnt_expire);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3790) put_mountpoint(root_mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3791) unlock_mount_hash();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3792) chroot_fs_refs(&root, &new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3793) error = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3794) out4:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3795) unlock_mount(old_mp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3796) if (!error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3797) mntput_no_expire(ex_parent);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3798) out3:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3799) path_put(&root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3800) out2:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3801) path_put(&old);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3802) out1:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3803) path_put(&new);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3804) out0:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3805) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3806) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3807)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3808) static void __init init_mount_tree(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3809) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3810) struct vfsmount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3811) struct mount *m;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3812) struct mnt_namespace *ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3813) struct path root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3814)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3815) mnt = vfs_kern_mount(&rootfs_fs_type, 0, "rootfs", NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3816) if (IS_ERR(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3817) panic("Can't create rootfs");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3818)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3819) ns = alloc_mnt_ns(&init_user_ns, false);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3820) if (IS_ERR(ns))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3821) panic("Can't allocate initial namespace");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3822) m = real_mount(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3823) m->mnt_ns = ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3824) ns->root = m;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3825) ns->mounts = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3826) list_add(&m->mnt_list, &ns->list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3827) init_task.nsproxy->mnt_ns = ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3828) get_mnt_ns(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3829)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3830) root.mnt = mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3831) root.dentry = mnt->mnt_root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3832) mnt->mnt_flags |= MNT_LOCKED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3833)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3834) set_fs_pwd(current->fs, &root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3835) set_fs_root(current->fs, &root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3836) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3837)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3838) void __init mnt_init(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3839) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3840) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3841)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3842) mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct mount),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3843) 0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3844)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3845) mount_hashtable = alloc_large_system_hash("Mount-cache",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3846) sizeof(struct hlist_head),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3847) mhash_entries, 19,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3848) HASH_ZERO,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3849) &m_hash_shift, &m_hash_mask, 0, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3850) mountpoint_hashtable = alloc_large_system_hash("Mountpoint-cache",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3851) sizeof(struct hlist_head),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3852) mphash_entries, 19,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3853) HASH_ZERO,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3854) &mp_hash_shift, &mp_hash_mask, 0, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3855)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3856) if (!mount_hashtable || !mountpoint_hashtable)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3857) panic("Failed to allocate mount hash table\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3858)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3859) kernfs_init();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3860)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3861) err = sysfs_init();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3862) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3863) printk(KERN_WARNING "%s: sysfs_init error: %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3864) __func__, err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3865) fs_kobj = kobject_create_and_add("fs", NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3866) if (!fs_kobj)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3867) printk(KERN_WARNING "%s: kobj create error\n", __func__);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3868) shmem_init();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3869) init_rootfs();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3870) init_mount_tree();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3871) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3872)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3873) void put_mnt_ns(struct mnt_namespace *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3874) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3875) if (!atomic_dec_and_test(&ns->count))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3876) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3877) drop_collected_mounts(&ns->root->mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3878) free_mnt_ns(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3879) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3880)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3881) struct vfsmount *kern_mount(struct file_system_type *type)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3882) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3883) struct vfsmount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3884) mnt = vfs_kern_mount(type, SB_KERNMOUNT, type->name, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3885) if (!IS_ERR(mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3886) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3887) * it is a longterm mount, don't release mnt until
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3888) * we unmount before file sys is unregistered
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3889) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3890) real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3891) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3892) return mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3893) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3894) EXPORT_SYMBOL_GPL(kern_mount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3895)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3896) void kern_unmount(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3897) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3898) /* release long term mount so mount point can be released */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3899) if (!IS_ERR_OR_NULL(mnt)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3900) real_mount(mnt)->mnt_ns = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3901) synchronize_rcu(); /* yecchhh... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3902) mntput(mnt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3903) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3904) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3905) EXPORT_SYMBOL(kern_unmount);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3906)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3907) void kern_unmount_array(struct vfsmount *mnt[], unsigned int num)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3908) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3909) unsigned int i;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3910)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3911) for (i = 0; i < num; i++)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3912) if (mnt[i])
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3913) real_mount(mnt[i])->mnt_ns = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3914) synchronize_rcu_expedited();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3915) for (i = 0; i < num; i++)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3916) mntput(mnt[i]);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3917) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3918) EXPORT_SYMBOL(kern_unmount_array);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3919)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3920) bool our_mnt(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3921) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3922) return check_mnt(real_mount(mnt));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3923) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3924)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3925) bool current_chrooted(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3926) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3927) /* Does the current process have a non-standard root */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3928) struct path ns_root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3929) struct path fs_root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3930) bool chrooted;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3931)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3932) /* Find the namespace root */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3933) ns_root.mnt = ¤t->nsproxy->mnt_ns->root->mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3934) ns_root.dentry = ns_root.mnt->mnt_root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3935) path_get(&ns_root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3936) while (d_mountpoint(ns_root.dentry) && follow_down_one(&ns_root))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3937) ;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3938)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3939) get_fs_root(current->fs, &fs_root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3940)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3941) chrooted = !path_equal(&fs_root, &ns_root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3942)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3943) path_put(&fs_root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3944) path_put(&ns_root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3945)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3946) return chrooted;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3947) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3948)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3949) static bool mnt_already_visible(struct mnt_namespace *ns,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3950) const struct super_block *sb,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3951) int *new_mnt_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3952) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3953) int new_flags = *new_mnt_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3954) struct mount *mnt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3955) bool visible = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3956)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3957) down_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3958) lock_ns_list(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3959) list_for_each_entry(mnt, &ns->list, mnt_list) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3960) struct mount *child;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3961) int mnt_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3962)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3963) if (mnt_is_cursor(mnt))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3964) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3965)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3966) if (mnt->mnt.mnt_sb->s_type != sb->s_type)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3967) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3968)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3969) /* This mount is not fully visible if it's root directory
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3970) * is not the root directory of the filesystem.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3971) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3972) if (mnt->mnt.mnt_root != mnt->mnt.mnt_sb->s_root)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3973) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3974)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3975) /* A local view of the mount flags */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3976) mnt_flags = mnt->mnt.mnt_flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3977)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3978) /* Don't miss readonly hidden in the superblock flags */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3979) if (sb_rdonly(mnt->mnt.mnt_sb))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3980) mnt_flags |= MNT_LOCK_READONLY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3981)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3982) /* Verify the mount flags are equal to or more permissive
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3983) * than the proposed new mount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3984) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3985) if ((mnt_flags & MNT_LOCK_READONLY) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3986) !(new_flags & MNT_READONLY))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3987) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3988) if ((mnt_flags & MNT_LOCK_ATIME) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3989) ((mnt_flags & MNT_ATIME_MASK) != (new_flags & MNT_ATIME_MASK)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3990) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3991)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3992) /* This mount is not fully visible if there are any
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3993) * locked child mounts that cover anything except for
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3994) * empty directories.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3995) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3996) list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3997) struct inode *inode = child->mnt_mountpoint->d_inode;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3998) /* Only worry about locked mounts */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3999) if (!(child->mnt.mnt_flags & MNT_LOCKED))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4000) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4001) /* Is the directory permanetly empty? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4002) if (!is_empty_dir_inode(inode))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4003) goto next;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4004) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4005) /* Preserve the locked attributes */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4006) *new_mnt_flags |= mnt_flags & (MNT_LOCK_READONLY | \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4007) MNT_LOCK_ATIME);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4008) visible = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4009) goto found;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4010) next: ;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4011) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4012) found:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4013) unlock_ns_list(ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4014) up_read(&namespace_sem);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4015) return visible;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4016) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4017)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4018) static bool mount_too_revealing(const struct super_block *sb, int *new_mnt_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4019) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4020) const unsigned long required_iflags = SB_I_NOEXEC | SB_I_NODEV;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4021) struct mnt_namespace *ns = current->nsproxy->mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4022) unsigned long s_iflags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4023)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4024) if (ns->user_ns == &init_user_ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4025) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4026)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4027) /* Can this filesystem be too revealing? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4028) s_iflags = sb->s_iflags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4029) if (!(s_iflags & SB_I_USERNS_VISIBLE))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4030) return false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4031)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4032) if ((s_iflags & required_iflags) != required_iflags) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4033) WARN_ONCE(1, "Expected s_iflags to contain 0x%lx\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4034) required_iflags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4035) return true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4036) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4037)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4038) return !mnt_already_visible(ns, sb, new_mnt_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4039) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4040)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4041) bool mnt_may_suid(struct vfsmount *mnt)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4042) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4043) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4044) * Foreign mounts (accessed via fchdir or through /proc
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4045) * symlinks) are always treated as if they are nosuid. This
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4046) * prevents namespaces from trusting potentially unsafe
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4047) * suid/sgid bits, file caps, or security labels that originate
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4048) * in other namespaces.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4049) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4050) return !(mnt->mnt_flags & MNT_NOSUID) && check_mnt(real_mount(mnt)) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4051) current_in_userns(mnt->mnt_sb->s_user_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4052) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4053)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4054) static struct ns_common *mntns_get(struct task_struct *task)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4055) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4056) struct ns_common *ns = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4057) struct nsproxy *nsproxy;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4058)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4059) task_lock(task);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4060) nsproxy = task->nsproxy;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4061) if (nsproxy) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4062) ns = &nsproxy->mnt_ns->ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4063) get_mnt_ns(to_mnt_ns(ns));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4064) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4065) task_unlock(task);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4066)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4067) return ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4068) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4069)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4070) static void mntns_put(struct ns_common *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4071) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4072) put_mnt_ns(to_mnt_ns(ns));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4073) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4074)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4075) static int mntns_install(struct nsset *nsset, struct ns_common *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4076) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4077) struct nsproxy *nsproxy = nsset->nsproxy;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4078) struct fs_struct *fs = nsset->fs;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4079) struct mnt_namespace *mnt_ns = to_mnt_ns(ns), *old_mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4080) struct user_namespace *user_ns = nsset->cred->user_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4081) struct path root;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4082) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4083)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4084) if (!ns_capable(mnt_ns->user_ns, CAP_SYS_ADMIN) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4085) !ns_capable(user_ns, CAP_SYS_CHROOT) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4086) !ns_capable(user_ns, CAP_SYS_ADMIN))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4087) return -EPERM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4088)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4089) if (is_anon_ns(mnt_ns))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4090) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4091)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4092) if (fs->users != 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4093) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4094)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4095) get_mnt_ns(mnt_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4096) old_mnt_ns = nsproxy->mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4097) nsproxy->mnt_ns = mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4098)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4099) /* Find the root */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4100) err = vfs_path_lookup(mnt_ns->root->mnt.mnt_root, &mnt_ns->root->mnt,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4101) "/", LOOKUP_DOWN, &root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4102) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4103) /* revert to old namespace */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4104) nsproxy->mnt_ns = old_mnt_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4105) put_mnt_ns(mnt_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4106) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4107) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4108)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4109) put_mnt_ns(old_mnt_ns);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4110)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4111) /* Update the pwd and root */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4112) set_fs_pwd(fs, &root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4113) set_fs_root(fs, &root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4114)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4115) path_put(&root);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4116) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4117) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4118)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4119) static struct user_namespace *mntns_owner(struct ns_common *ns)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4120) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4121) return to_mnt_ns(ns)->user_ns;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4122) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4123)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4124) const struct proc_ns_operations mntns_operations = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4125) .name = "mnt",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4126) .type = CLONE_NEWNS,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4127) .get = mntns_get,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4128) .put = mntns_put,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4129) .install = mntns_install,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4130) .owner = mntns_owner,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4131) };
Orange Pi5 kernel
Deprecated Linux kernel 5.10.110 for OrangePi 5/5B/5+ boards
3 Commits
0 Branches
0 Tags