4 * (C) Copyright Al Viro 2000, 2001
5 * Released under GPL v2.
7 * Based on code from fs/super.c, copyright Linus Torvalds and others.
11 #include <linux/syscalls.h>
12 #include <linux/export.h>
13 #include <linux/capability.h>
14 #include <linux/mnt_namespace.h>
15 #include <linux/user_namespace.h>
16 #include <linux/namei.h>
17 #include <linux/security.h>
18 #include <linux/idr.h>
19 #include <linux/init.h> /* init_rootfs */
20 #include <linux/fs_struct.h> /* get_fs_root et.al. */
21 #include <linux/fsnotify.h> /* fsnotify_vfsmount_delete */
22 #include <linux/uaccess.h>
23 #include <linux/proc_ns.h>
24 #include <linux/magic.h>
25 #include <linux/bootmem.h>
26 #include <linux/task_work.h>
27 #include <linux/slub_def.h>
28 #include <linux/fslog.h>
32 /* Maximum number of mounts in a mount namespace */
33 unsigned int sysctl_mount_max __read_mostly
= 100000;
35 static unsigned int sys_umount_trace_status
;
37 static unsigned int m_hash_mask __read_mostly
;
38 static unsigned int m_hash_shift __read_mostly
;
39 static unsigned int mp_hash_mask __read_mostly
;
40 static unsigned int mp_hash_shift __read_mostly
;
42 static __initdata
unsigned long mhash_entries
;
43 static int __init
set_mhash_entries(char *str
)
47 mhash_entries
= simple_strtoul(str
, &str
, 0);
50 __setup("mhash_entries=", set_mhash_entries
);
52 static __initdata
unsigned long mphash_entries
;
53 static int __init
set_mphash_entries(char *str
)
57 mphash_entries
= simple_strtoul(str
, &str
, 0);
60 __setup("mphash_entries=", set_mphash_entries
);
63 static DEFINE_IDA(mnt_id_ida
);
64 static DEFINE_IDA(mnt_group_ida
);
65 static DEFINE_SPINLOCK(mnt_id_lock
);
66 #ifdef CONFIG_RKP_NS_PROT
67 static DEFINE_SPINLOCK(mnt_vfsmnt_lock
);
69 static int mnt_id_start
= 0;
70 static int mnt_group_start
= 1;
72 static struct hlist_head
*mount_hashtable __read_mostly
;
73 static struct hlist_head
*mountpoint_hashtable __read_mostly
;
74 static struct kmem_cache
*mnt_cache __read_mostly
;
75 #ifdef CONFIG_RKP_NS_PROT
76 static struct kmem_cache
*vfsmnt_cache __read_mostly
;
77 RKP_RO_AREA
struct super_block
*sys_sb
;
78 RKP_RO_AREA
struct super_block
*rootfs_sb
;
81 static DECLARE_RWSEM(namespace_sem
);
84 struct kobject
*fs_kobj
;
85 EXPORT_SYMBOL_GPL(fs_kobj
);
88 * vfsmount lock may be taken for read to prevent changes to the
89 * vfsmount hash, ie. during mountpoint lookups or walking back
92 * It should be taken for write in all cases where the vfsmount
93 * tree or hash is modified or when a vfsmount structure is modified.
95 __cacheline_aligned_in_smp
DEFINE_SEQLOCK(mount_lock
);
97 static inline struct hlist_head
*m_hash(struct vfsmount
*mnt
, struct dentry
*dentry
)
99 unsigned long tmp
= ((unsigned long)mnt
/ L1_CACHE_BYTES
);
100 tmp
+= ((unsigned long)dentry
/ L1_CACHE_BYTES
);
101 tmp
= tmp
+ (tmp
>> m_hash_shift
);
102 return &mount_hashtable
[tmp
& m_hash_mask
];
105 static inline int sys_umount_trace_start(struct mount
*mnt
, int flags
)
107 #ifdef CONFIG_RKP_NS_PROT
108 struct super_block
*sb
= mnt
->mnt
->mnt_sb
;
109 int mnt_flags
= mnt
->mnt
->mnt_flags
;
111 struct super_block
*sb
= mnt
->mnt
.mnt_sb
;
112 int mnt_flags
= mnt
->mnt
.mnt_flags
;
114 if ((sb
->s_magic
== SDFAT_SUPER_MAGIC
) ||
115 (sb
->s_magic
== MSDOS_SUPER_MAGIC
)) {
116 struct block_device
*bdev
= sb
->s_bdev
;
117 dev_t bd_dev
= bdev
? bdev
->bd_dev
: 0;
119 ST_LOG("[SYSCALL](%s[%d:%d]): "
120 "enter umount(mf:0x%x, f:0x%x, %s)\n",
121 sb
->s_id
, MAJOR(bd_dev
), MINOR(bd_dev
), mnt_flags
,
122 flags
, mnt
->mnt_mountpoint
->d_name
.name
);
128 #define UMOUNT_END_ADD_TASK (0x00)
129 #define UMOUNT_END_REMAIN_NS (0x01)
130 #define UMOUNT_END_REMAIN_MNT_COUNT (0x02)
131 #define UMOUNT_END_ADD_DELAYED_WORK (0x03)
133 static inline void sys_umount_trace_set_status(unsigned int status
)
135 sys_umount_trace_status
= status
;
138 static inline void sys_umount_trace_end(struct mount
*mnt
, unsigned int stlog
)
140 #ifdef CONFIG_RKP_NS_PROT
141 struct super_block
*sb
= mnt
->mnt
->mnt_sb
;
143 struct super_block
*sb
= mnt
->mnt
.mnt_sb
;
146 struct block_device
*bdev
= sb
->s_bdev
;
147 dev_t bd_dev
= bdev
? bdev
->bd_dev
: 0;
149 ST_LOG("[SYSCALL](%s[%d:%d]): exit umount(%d)\n",
150 sb
->s_id
, MAJOR(bd_dev
), MINOR(bd_dev
),
151 sys_umount_trace_status
);
155 #ifdef CONFIG_RKP_NS_PROT
157 unsigned int cmp_ns_integrity(void)
159 struct mount
*root
= NULL
;
160 struct nsproxy
*nsp
= NULL
;
167 nsp
= current
->nsproxy
;
168 if(!ns_prot
|| !nsp
||
172 root
= current
->nsproxy
->mnt_ns
->root
;
173 if(root
!= root
->mnt
->bp_mount
){
174 printk("\n RKP44_3 Name Space Mismatch %p != %p\n nsp = %p mnt_ns %p\n",root
,root
->mnt
->bp_mount
,nsp
,nsp
->mnt_ns
);
181 static inline struct hlist_head
*mp_hash(struct dentry
*dentry
)
183 unsigned long tmp
= ((unsigned long)dentry
/ L1_CACHE_BYTES
);
184 tmp
= tmp
+ (tmp
>> mp_hash_shift
);
185 return &mountpoint_hashtable
[tmp
& mp_hash_mask
];
189 * allocation is serialized by namespace_sem, but we need the spinlock to
190 * serialize with freeing.
192 static int mnt_alloc_id(struct mount
*mnt
)
197 ida_pre_get(&mnt_id_ida
, GFP_KERNEL
);
198 spin_lock(&mnt_id_lock
);
199 res
= ida_get_new_above(&mnt_id_ida
, mnt_id_start
, &mnt
->mnt_id
);
201 mnt_id_start
= mnt
->mnt_id
+ 1;
202 spin_unlock(&mnt_id_lock
);
208 #ifdef CONFIG_RKP_NS_PROT
209 void rkp_init_ns(struct vfsmount
*vfsmnt
,struct mount
*mnt
)
211 rkp_call(RKP_CMDID(0x52),(u64
)vfsmnt
,(u64
)mnt
,0,0,0);
213 static int mnt_alloc_vfsmount(struct mount
*mnt
)
215 struct vfsmount
*vfsmnt
= NULL
;
217 vfsmnt
= kmem_cache_alloc(vfsmnt_cache
, GFP_KERNEL
);
221 spin_lock(&mnt_vfsmnt_lock
);
222 rkp_init_ns(vfsmnt
,mnt
);
223 // vfsmnt->bp_mount = mnt;
225 spin_unlock(&mnt_vfsmnt_lock
);
229 static void mnt_free_id(struct mount
*mnt
)
231 int id
= mnt
->mnt_id
;
232 spin_lock(&mnt_id_lock
);
233 ida_remove(&mnt_id_ida
, id
);
234 if (mnt_id_start
> id
)
236 spin_unlock(&mnt_id_lock
);
240 * Allocate a new peer group ID
242 * mnt_group_ida is protected by namespace_sem
244 static int mnt_alloc_group_id(struct mount
*mnt
)
248 if (!ida_pre_get(&mnt_group_ida
, GFP_KERNEL
))
251 res
= ida_get_new_above(&mnt_group_ida
,
255 mnt_group_start
= mnt
->mnt_group_id
+ 1;
261 * Release a peer group ID
263 void mnt_release_group_id(struct mount
*mnt
)
265 int id
= mnt
->mnt_group_id
;
266 ida_remove(&mnt_group_ida
, id
);
267 if (mnt_group_start
> id
)
268 mnt_group_start
= id
;
269 mnt
->mnt_group_id
= 0;
273 * vfsmount lock must be held for read
275 static inline void mnt_add_count(struct mount
*mnt
, int n
)
278 this_cpu_add(mnt
->mnt_pcp
->mnt_count
, n
);
287 * vfsmount lock must be held for write
289 unsigned int mnt_get_count(struct mount
*mnt
)
292 unsigned int count
= 0;
295 for_each_possible_cpu(cpu
) {
296 count
+= per_cpu_ptr(mnt
->mnt_pcp
, cpu
)->mnt_count
;
301 return mnt
->mnt_count
;
305 static void drop_mountpoint(struct fs_pin
*p
)
307 struct mount
*m
= container_of(p
, struct mount
, mnt_umount
);
308 dput(m
->mnt_ex_mountpoint
);
310 #ifdef CONFIG_RKP_NS_PROT
317 static struct mount
*alloc_vfsmnt(const char *name
)
319 struct mount
*mnt
= kmem_cache_zalloc(mnt_cache
, GFP_KERNEL
);
323 err
= mnt_alloc_id(mnt
);
326 #ifdef CONFIG_RKP_NS_PROT
327 err
= mnt_alloc_vfsmount(mnt
);
332 mnt
->mnt_devname
= kstrdup_const(name
, GFP_KERNEL
);
333 if (!mnt
->mnt_devname
)
338 mnt
->mnt_pcp
= alloc_percpu(struct mnt_pcp
);
340 goto out_free_devname
;
342 this_cpu_add(mnt
->mnt_pcp
->mnt_count
, 1);
345 mnt
->mnt_writers
= 0;
348 INIT_HLIST_NODE(&mnt
->mnt_hash
);
349 INIT_LIST_HEAD(&mnt
->mnt_child
);
350 INIT_LIST_HEAD(&mnt
->mnt_mounts
);
351 INIT_LIST_HEAD(&mnt
->mnt_list
);
352 INIT_LIST_HEAD(&mnt
->mnt_expire
);
353 INIT_LIST_HEAD(&mnt
->mnt_share
);
354 INIT_LIST_HEAD(&mnt
->mnt_slave_list
);
355 INIT_LIST_HEAD(&mnt
->mnt_slave
);
356 INIT_HLIST_NODE(&mnt
->mnt_mp_list
);
357 INIT_LIST_HEAD(&mnt
->mnt_umounting
);
358 #ifdef CONFIG_FSNOTIFY
359 INIT_HLIST_HEAD(&mnt
->mnt_fsnotify_marks
);
361 init_fs_pin(&mnt
->mnt_umount
, drop_mountpoint
);
367 kfree_const(mnt
->mnt_devname
);
372 kmem_cache_free(mnt_cache
, mnt
);
377 * Most r/o checks on a fs are for operations that take
378 * discrete amounts of time, like a write() or unlink().
379 * We must keep track of when those operations start
380 * (for permission checks) and when they end, so that
381 * we can determine when writes are able to occur to
385 * __mnt_is_readonly: check whether a mount is read-only
386 * @mnt: the mount to check for its write status
388 * This shouldn't be used directly ouside of the VFS.
389 * It does not guarantee that the filesystem will stay
390 * r/w, just that it is right *now*. This can not and
391 * should not be used in place of IS_RDONLY(inode).
392 * mnt_want/drop_write() will _keep_ the filesystem
395 int __mnt_is_readonly(struct vfsmount
*mnt
)
397 if (mnt
->mnt_flags
& MNT_READONLY
)
399 if (mnt
->mnt_sb
->s_flags
& MS_RDONLY
)
403 EXPORT_SYMBOL_GPL(__mnt_is_readonly
);
405 static inline void mnt_inc_writers(struct mount
*mnt
)
408 this_cpu_inc(mnt
->mnt_pcp
->mnt_writers
);
414 static inline void mnt_dec_writers(struct mount
*mnt
)
417 this_cpu_dec(mnt
->mnt_pcp
->mnt_writers
);
423 static unsigned int mnt_get_writers(struct mount
*mnt
)
426 unsigned int count
= 0;
429 for_each_possible_cpu(cpu
) {
430 count
+= per_cpu_ptr(mnt
->mnt_pcp
, cpu
)->mnt_writers
;
435 return mnt
->mnt_writers
;
439 static int mnt_is_readonly(struct vfsmount
*mnt
)
441 if (mnt
->mnt_sb
->s_readonly_remount
)
443 /* Order wrt setting s_flags/s_readonly_remount in do_remount() */
445 return __mnt_is_readonly(mnt
);
449 * Most r/o & frozen checks on a fs are for operations that take discrete
450 * amounts of time, like a write() or unlink(). We must keep track of when
451 * those operations start (for permission checks) and when they end, so that we
452 * can determine when writes are able to occur to a filesystem.
455 * __mnt_want_write - get write access to a mount without freeze protection
456 * @m: the mount on which to take a write
458 * This tells the low-level filesystem that a write is about to be performed to
459 * it, and makes sure that writes are allowed (mnt it read-write) before
460 * returning success. This operation does not protect against filesystem being
461 * frozen. When the write operation is finished, __mnt_drop_write() must be
462 * called. This is effectively a refcount.
464 int __mnt_want_write(struct vfsmount
*m
)
466 struct mount
*mnt
= real_mount(m
);
470 mnt_inc_writers(mnt
);
472 * The store to mnt_inc_writers must be visible before we pass
473 * MNT_WRITE_HOLD loop below, so that the slowpath can see our
474 * incremented count after it has set MNT_WRITE_HOLD.
477 #ifdef CONFIG_RKP_NS_PROT
478 while (ACCESS_ONCE(mnt
->mnt
->mnt_flags
) & MNT_WRITE_HOLD
)
480 while (ACCESS_ONCE(mnt
->mnt
.mnt_flags
) & MNT_WRITE_HOLD
)
484 * After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will
485 * be set to match its requirements. So we must not load that until
486 * MNT_WRITE_HOLD is cleared.
489 if (mnt_is_readonly(m
)) {
490 mnt_dec_writers(mnt
);
499 * mnt_want_write - get write access to a mount
500 * @m: the mount on which to take a write
502 * This tells the low-level filesystem that a write is about to be performed to
503 * it, and makes sure that writes are allowed (mount is read-write, filesystem
504 * is not frozen) before returning success. When the write operation is
505 * finished, mnt_drop_write() must be called. This is effectively a refcount.
507 int mnt_want_write(struct vfsmount
*m
)
511 sb_start_write(m
->mnt_sb
);
512 ret
= __mnt_want_write(m
);
514 sb_end_write(m
->mnt_sb
);
517 EXPORT_SYMBOL_GPL(mnt_want_write
);
520 * mnt_clone_write - get write access to a mount
521 * @mnt: the mount on which to take a write
523 * This is effectively like mnt_want_write, except
524 * it must only be used to take an extra write reference
525 * on a mountpoint that we already know has a write reference
526 * on it. This allows some optimisation.
528 * After finished, mnt_drop_write must be called as usual to
529 * drop the reference.
531 int mnt_clone_write(struct vfsmount
*mnt
)
533 /* superblock may be r/o */
534 if (__mnt_is_readonly(mnt
))
537 mnt_inc_writers(real_mount(mnt
));
541 EXPORT_SYMBOL_GPL(mnt_clone_write
);
544 * __mnt_want_write_file - get write access to a file's mount
545 * @file: the file who's mount on which to take a write
547 * This is like __mnt_want_write, but it takes a file and can
548 * do some optimisations if the file is open for write already
550 int __mnt_want_write_file(struct file
*file
)
552 if (!(file
->f_mode
& FMODE_WRITER
))
553 return __mnt_want_write(file
->f_path
.mnt
);
555 return mnt_clone_write(file
->f_path
.mnt
);
559 * mnt_want_write_file - get write access to a file's mount
560 * @file: the file who's mount on which to take a write
562 * This is like mnt_want_write, but it takes a file and can
563 * do some optimisations if the file is open for write already
565 int mnt_want_write_file(struct file
*file
)
569 sb_start_write(file
->f_path
.mnt
->mnt_sb
);
570 ret
= __mnt_want_write_file(file
);
572 sb_end_write(file
->f_path
.mnt
->mnt_sb
);
575 EXPORT_SYMBOL_GPL(mnt_want_write_file
);
578 * __mnt_drop_write - give up write access to a mount
579 * @mnt: the mount on which to give up write access
581 * Tells the low-level filesystem that we are done
582 * performing writes to it. Must be matched with
583 * __mnt_want_write() call above.
585 void __mnt_drop_write(struct vfsmount
*mnt
)
588 mnt_dec_writers(real_mount(mnt
));
593 * mnt_drop_write - give up write access to a mount
594 * @mnt: the mount on which to give up write access
596 * Tells the low-level filesystem that we are done performing writes to it and
597 * also allows filesystem to be frozen again. Must be matched with
598 * mnt_want_write() call above.
600 void mnt_drop_write(struct vfsmount
*mnt
)
602 __mnt_drop_write(mnt
);
603 sb_end_write(mnt
->mnt_sb
);
605 EXPORT_SYMBOL_GPL(mnt_drop_write
);
607 void __mnt_drop_write_file(struct file
*file
)
609 __mnt_drop_write(file
->f_path
.mnt
);
612 void mnt_drop_write_file(struct file
*file
)
614 mnt_drop_write(file
->f_path
.mnt
);
616 EXPORT_SYMBOL(mnt_drop_write_file
);
617 #ifdef CONFIG_RKP_NS_PROT
618 void rkp_set_mnt_root_sb(struct vfsmount
*mnt
, struct dentry
*mnt_root
,struct super_block
*mnt_sb
)
620 rkp_call(RKP_CMDID(0x53),(u64
)mnt
,(u64
)mnt_root
,(u64
)mnt_sb
,0,0);
622 void rkp_assign_mnt_flags(struct vfsmount
*mnt
,int flags
)
624 rkp_call(RKP_CMDID(0x54),(u64
)mnt
,(u64
)flags
,0,0,0);
626 void rkp_set_mnt_flags(struct vfsmount
*mnt
,int flags
)
628 int f
= mnt
->mnt_flags
;
630 rkp_assign_mnt_flags(mnt
,f
);
633 void rkp_reset_mnt_flags(struct vfsmount
*mnt
,int flags
)
635 int f
= mnt
->mnt_flags
;
637 rkp_assign_mnt_flags(mnt
,f
);
641 static int mnt_make_readonly(struct mount
*mnt
)
646 #ifdef CONFIG_RKP_NS_PROT
647 rkp_set_mnt_flags(mnt
->mnt
,MNT_WRITE_HOLD
);
649 mnt
->mnt
.mnt_flags
|= MNT_WRITE_HOLD
;
652 * After storing MNT_WRITE_HOLD, we'll read the counters. This store
653 * should be visible before we do.
658 * With writers on hold, if this value is zero, then there are
659 * definitely no active writers (although held writers may subsequently
660 * increment the count, they'll have to wait, and decrement it after
661 * seeing MNT_READONLY).
663 * It is OK to have counter incremented on one CPU and decremented on
664 * another: the sum will add up correctly. The danger would be when we
665 * sum up each counter, if we read a counter before it is incremented,
666 * but then read another CPU's count which it has been subsequently
667 * decremented from -- we would see more decrements than we should.
668 * MNT_WRITE_HOLD protects against this scenario, because
669 * mnt_want_write first increments count, then smp_mb, then spins on
670 * MNT_WRITE_HOLD, so it can't be decremented by another CPU while
671 * we're counting up here.
673 if (mnt_get_writers(mnt
) > 0)
676 #ifdef CONFIG_RKP_NS_PROT
677 rkp_set_mnt_flags(mnt
->mnt
,MNT_READONLY
);
679 mnt
->mnt
.mnt_flags
|= MNT_READONLY
;
683 * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers
684 * that become unheld will see MNT_READONLY.
687 #ifdef CONFIG_RKP_NS_PROT
688 rkp_reset_mnt_flags(mnt
->mnt
,MNT_WRITE_HOLD
);
690 mnt
->mnt
.mnt_flags
&= ~MNT_WRITE_HOLD
;
696 static void __mnt_unmake_readonly(struct mount
*mnt
)
699 #ifdef CONFIG_RKP_NS_PROT
700 rkp_reset_mnt_flags(mnt
->mnt
,MNT_READONLY
);
702 mnt
->mnt
.mnt_flags
&= ~MNT_READONLY
;
707 int sb_prepare_remount_readonly(struct super_block
*sb
)
712 /* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */
713 if (atomic_long_read(&sb
->s_remove_count
))
717 list_for_each_entry(mnt
, &sb
->s_mounts
, mnt_instance
) {
718 #ifdef CONFIG_RKP_NS_PROT
719 if (!(mnt
->mnt
->mnt_flags
& MNT_READONLY
)) {
720 rkp_set_mnt_flags(mnt
->mnt
,MNT_WRITE_HOLD
);
722 if (!(mnt
->mnt
.mnt_flags
& MNT_READONLY
)) {
723 mnt
->mnt
.mnt_flags
|= MNT_WRITE_HOLD
;
726 if (mnt_get_writers(mnt
) > 0) {
732 if (!err
&& atomic_long_read(&sb
->s_remove_count
))
736 sb
->s_readonly_remount
= 1;
739 list_for_each_entry(mnt
, &sb
->s_mounts
, mnt_instance
) {
740 #ifdef CONFIG_RKP_NS_PROT
741 if (mnt
->mnt
->mnt_flags
& MNT_WRITE_HOLD
)
742 rkp_reset_mnt_flags(mnt
->mnt
,MNT_WRITE_HOLD
);
744 if (mnt
->mnt
.mnt_flags
& MNT_WRITE_HOLD
)
745 mnt
->mnt
.mnt_flags
&= ~MNT_WRITE_HOLD
;
752 #ifdef CONFIG_RKP_NS_PROT
753 extern int rkp_from_vfsmnt_cache(unsigned long addr
);
755 static void free_vfsmnt(struct mount
*mnt
)
757 #ifdef CONFIG_RKP_NS_PROT
758 kfree(mnt
->mnt
->data
);
760 kfree(mnt
->mnt
.data
);
762 kfree_const(mnt
->mnt_devname
);
764 free_percpu(mnt
->mnt_pcp
);
766 #ifdef CONFIG_RKP_NS_PROT
768 rkp_from_vfsmnt_cache((unsigned long)mnt
->mnt
))
769 kmem_cache_free(vfsmnt_cache
,mnt
->mnt
);
771 kmem_cache_free(mnt_cache
, mnt
);
774 static void delayed_free_vfsmnt(struct rcu_head
*head
)
776 free_vfsmnt(container_of(head
, struct mount
, mnt_rcu
));
779 /* call under rcu_read_lock */
780 int __legitimize_mnt(struct vfsmount
*bastard
, unsigned seq
)
783 if (read_seqretry(&mount_lock
, seq
))
787 mnt
= real_mount(bastard
);
788 mnt_add_count(mnt
, 1);
789 smp_mb(); // see mntput_no_expire()
790 if (likely(!read_seqretry(&mount_lock
, seq
)))
792 if (bastard
->mnt_flags
& MNT_SYNC_UMOUNT
) {
793 mnt_add_count(mnt
, -1);
797 if (unlikely(bastard
->mnt_flags
& MNT_DOOMED
)) {
798 mnt_add_count(mnt
, -1);
803 /* caller will mntput() */
807 /* call under rcu_read_lock */
808 bool legitimize_mnt(struct vfsmount
*bastard
, unsigned seq
)
810 int res
= __legitimize_mnt(bastard
, seq
);
813 if (unlikely(res
< 0)) {
822 * find the first mount at @dentry on vfsmount @mnt.
823 * call under rcu_read_lock()
825 struct mount
*__lookup_mnt(struct vfsmount
*mnt
, struct dentry
*dentry
)
827 struct hlist_head
*head
= m_hash(mnt
, dentry
);
830 hlist_for_each_entry_rcu(p
, head
, mnt_hash
)
831 #ifdef CONFIG_RKP_NS_PROT
832 if (p
->mnt_parent
->mnt
== mnt
&& p
->mnt_mountpoint
== dentry
)
834 if (&p
->mnt_parent
->mnt
== mnt
&& p
->mnt_mountpoint
== dentry
)
841 * lookup_mnt - Return the first child mount mounted at path
843 * "First" means first mounted chronologically. If you create the
846 * mount /dev/sda1 /mnt
847 * mount /dev/sda2 /mnt
848 * mount /dev/sda3 /mnt
850 * Then lookup_mnt() on the base /mnt dentry in the root mount will
851 * return successively the root dentry and vfsmount of /dev/sda1, then
852 * /dev/sda2, then /dev/sda3, then NULL.
854 * lookup_mnt takes a reference to the found vfsmount.
856 struct vfsmount
*lookup_mnt(struct path
*path
)
858 struct mount
*child_mnt
;
864 seq
= read_seqbegin(&mount_lock
);
865 child_mnt
= __lookup_mnt(path
->mnt
, path
->dentry
);
866 #ifdef CONFIG_RKP_NS_PROT
867 m
= child_mnt
? child_mnt
->mnt
: NULL
;
869 m
= child_mnt
? &child_mnt
->mnt
: NULL
;
871 } while (!legitimize_mnt(m
, seq
));
877 * __is_local_mountpoint - Test to see if dentry is a mountpoint in the
878 * current mount namespace.
880 * The common case is dentries are not mountpoints at all and that
881 * test is handled inline. For the slow case when we are actually
882 * dealing with a mountpoint of some kind, walk through all of the
883 * mounts in the current mount namespace and test to see if the dentry
886 * The mount_hashtable is not usable in the context because we
887 * need to identify all mounts that may be in the current mount
888 * namespace not just a mount that happens to have some specified
891 bool __is_local_mountpoint(struct dentry
*dentry
)
893 struct mnt_namespace
*ns
= current
->nsproxy
->mnt_ns
;
895 bool is_covered
= false;
897 if (!d_mountpoint(dentry
))
900 down_read(&namespace_sem
);
901 list_for_each_entry(mnt
, &ns
->list
, mnt_list
) {
902 is_covered
= (mnt
->mnt_mountpoint
== dentry
);
906 up_read(&namespace_sem
);
911 static struct mountpoint
*lookup_mountpoint(struct dentry
*dentry
)
913 struct hlist_head
*chain
= mp_hash(dentry
);
914 struct mountpoint
*mp
;
916 hlist_for_each_entry(mp
, chain
, m_hash
) {
917 if (mp
->m_dentry
== dentry
) {
918 /* might be worth a WARN_ON() */
919 if (d_unlinked(dentry
))
920 return ERR_PTR(-ENOENT
);
928 static struct mountpoint
*get_mountpoint(struct dentry
*dentry
)
930 struct mountpoint
*mp
, *new = NULL
;
933 if (d_mountpoint(dentry
)) {
935 read_seqlock_excl(&mount_lock
);
936 mp
= lookup_mountpoint(dentry
);
937 read_sequnlock_excl(&mount_lock
);
943 new = kmalloc(sizeof(struct mountpoint
), GFP_KERNEL
);
945 return ERR_PTR(-ENOMEM
);
948 /* Exactly one processes may set d_mounted */
949 ret
= d_set_mounted(dentry
);
951 /* Someone else set d_mounted? */
955 /* The dentry is not available as a mountpoint? */
960 /* Add the new mountpoint to the hash table */
961 read_seqlock_excl(&mount_lock
);
962 new->m_dentry
= dentry
;
964 hlist_add_head(&new->m_hash
, mp_hash(dentry
));
965 INIT_HLIST_HEAD(&new->m_list
);
966 read_sequnlock_excl(&mount_lock
);
975 static void put_mountpoint(struct mountpoint
*mp
)
977 if (!--mp
->m_count
) {
978 struct dentry
*dentry
= mp
->m_dentry
;
979 BUG_ON(!hlist_empty(&mp
->m_list
));
980 spin_lock(&dentry
->d_lock
);
981 dentry
->d_flags
&= ~DCACHE_MOUNTED
;
982 spin_unlock(&dentry
->d_lock
);
983 hlist_del(&mp
->m_hash
);
988 static inline int check_mnt(struct mount
*mnt
)
990 return mnt
->mnt_ns
== current
->nsproxy
->mnt_ns
;
994 * vfsmount lock must be held for write
996 static void touch_mnt_namespace(struct mnt_namespace
*ns
)
1000 wake_up_interruptible(&ns
->poll
);
1005 * vfsmount lock must be held for write
1007 static void __touch_mnt_namespace(struct mnt_namespace
*ns
)
1009 if (ns
&& ns
->event
!= event
) {
1011 wake_up_interruptible(&ns
->poll
);
1016 * vfsmount lock must be held for write
1018 static void unhash_mnt(struct mount
*mnt
)
1020 mnt
->mnt_parent
= mnt
;
1021 #ifdef CONFIG_RKP_NS_PROT
1022 mnt
->mnt_mountpoint
= mnt
->mnt
->mnt_root
;
1024 mnt
->mnt_mountpoint
= mnt
->mnt
.mnt_root
;
1026 list_del_init(&mnt
->mnt_child
);
1027 hlist_del_init_rcu(&mnt
->mnt_hash
);
1028 hlist_del_init(&mnt
->mnt_mp_list
);
1029 put_mountpoint(mnt
->mnt_mp
);
1034 * vfsmount lock must be held for write
1036 static void detach_mnt(struct mount
*mnt
, struct path
*old_path
)
1038 old_path
->dentry
= mnt
->mnt_mountpoint
;
1039 #ifdef CONFIG_RKP_NS_PROT
1040 old_path
->mnt
= mnt
->mnt_parent
->mnt
;
1042 old_path
->mnt
= &mnt
->mnt_parent
->mnt
;
1048 * vfsmount lock must be held for write
1050 static void umount_mnt(struct mount
*mnt
)
1052 /* old mountpoint will be dropped when we can do that */
1053 mnt
->mnt_ex_mountpoint
= mnt
->mnt_mountpoint
;
1058 * vfsmount lock must be held for write
1060 void mnt_set_mountpoint(struct mount
*mnt
,
1061 struct mountpoint
*mp
,
1062 struct mount
*child_mnt
)
1065 mnt_add_count(mnt
, 1); /* essentially, that's mntget */
1066 child_mnt
->mnt_mountpoint
= dget(mp
->m_dentry
);
1067 child_mnt
->mnt_parent
= mnt
;
1068 child_mnt
->mnt_mp
= mp
;
1069 hlist_add_head(&child_mnt
->mnt_mp_list
, &mp
->m_list
);
1072 static void __attach_mnt(struct mount
*mnt
, struct mount
*parent
)
1074 #ifdef CONFIG_RKP_NS_PROT
1075 hlist_add_head_rcu(&mnt
->mnt_hash
,
1076 m_hash(parent
->mnt
, mnt
->mnt_mountpoint
));
1078 hlist_add_head_rcu(&mnt
->mnt_hash
,
1079 m_hash(&parent
->mnt
, mnt
->mnt_mountpoint
));
1081 list_add_tail(&mnt
->mnt_child
, &parent
->mnt_mounts
);
1085 * vfsmount lock must be held for write
1087 static void attach_mnt(struct mount
*mnt
,
1088 struct mount
*parent
,
1089 struct mountpoint
*mp
)
1091 mnt_set_mountpoint(parent
, mp
, mnt
);
1092 __attach_mnt(mnt
, parent
);
1095 void mnt_change_mountpoint(struct mount
*parent
, struct mountpoint
*mp
, struct mount
*mnt
)
1097 struct mountpoint
*old_mp
= mnt
->mnt_mp
;
1098 struct dentry
*old_mountpoint
= mnt
->mnt_mountpoint
;
1099 struct mount
*old_parent
= mnt
->mnt_parent
;
1101 list_del_init(&mnt
->mnt_child
);
1102 hlist_del_init(&mnt
->mnt_mp_list
);
1103 hlist_del_init_rcu(&mnt
->mnt_hash
);
1105 attach_mnt(mnt
, parent
, mp
);
1107 put_mountpoint(old_mp
);
1110 * Safely avoid even the suggestion this code might sleep or
1111 * lock the mount hash by taking advantage of the knowledge that
1112 * mnt_change_mountpoint will not release the final reference
1115 * During mounting, the mount passed in as the parent mount will
1116 * continue to use the old mountpoint and during unmounting, the
1117 * old mountpoint will continue to exist until namespace_unlock,
1118 * which happens well after mnt_change_mountpoint.
1120 spin_lock(&old_mountpoint
->d_lock
);
1121 old_mountpoint
->d_lockref
.count
--;
1122 spin_unlock(&old_mountpoint
->d_lock
);
1124 mnt_add_count(old_parent
, -1);
1128 * vfsmount lock must be held for write
1130 static void commit_tree(struct mount
*mnt
)
1132 struct mount
*parent
= mnt
->mnt_parent
;
1135 struct mnt_namespace
*n
= parent
->mnt_ns
;
1137 BUG_ON(parent
== mnt
);
1139 list_add_tail(&head
, &mnt
->mnt_list
);
1140 list_for_each_entry(m
, &head
, mnt_list
)
1143 list_splice(&head
, n
->list
.prev
);
1145 n
->mounts
+= n
->pending_mounts
;
1146 n
->pending_mounts
= 0;
1148 __attach_mnt(mnt
, parent
);
1149 touch_mnt_namespace(n
);
1152 static struct mount
*next_mnt(struct mount
*p
, struct mount
*root
)
1154 struct list_head
*next
= p
->mnt_mounts
.next
;
1155 if (next
== &p
->mnt_mounts
) {
1159 next
= p
->mnt_child
.next
;
1160 if (next
!= &p
->mnt_parent
->mnt_mounts
)
1165 return list_entry(next
, struct mount
, mnt_child
);
1168 static struct mount
*skip_mnt_tree(struct mount
*p
)
1170 struct list_head
*prev
= p
->mnt_mounts
.prev
;
1171 while (prev
!= &p
->mnt_mounts
) {
1172 p
= list_entry(prev
, struct mount
, mnt_child
);
1173 prev
= p
->mnt_mounts
.prev
;
1179 vfs_kern_mount(struct file_system_type
*type
, int flags
, const char *name
, void *data
)
1182 struct dentry
*root
;
1185 return ERR_PTR(-ENODEV
);
1187 mnt
= alloc_vfsmnt(name
);
1189 return ERR_PTR(-ENOMEM
);
1191 #ifdef CONFIG_RKP_NS_PROT
1192 rkp_call(RKP_CMDID(0x56), (u64
)(mnt
->mnt
), (u64
)NULL
, 0, 0, 0);
1194 mnt
->mnt
.data
= NULL
;
1196 if (type
->alloc_mnt_data
) {
1197 #ifdef CONFIG_RKP_NS_PROT
1198 u64
*mnt_data
= (u64
*)(type
->alloc_mnt_data());
1200 rkp_call(RKP_CMDID(0x56), (u64
)(mnt
->mnt
), (u64
)mnt_data
, 0, 0, 0);
1201 if (!mnt
->mnt
->data
) {
1203 mnt
->mnt
.data
= type
->alloc_mnt_data();
1204 if (!mnt
->mnt
.data
) {
1208 return ERR_PTR(-ENOMEM
);
1212 if (flags
& MS_KERNMOUNT
) {
1213 #ifdef CONFIG_RKP_NS_PROT
1214 rkp_set_mnt_flags(mnt
->mnt
,MNT_INTERNAL
);
1216 mnt
->mnt
.mnt_flags
= MNT_INTERNAL
;
1219 #ifdef CONFIG_RKP_NS_PROT
1220 root
= mount_fs(type
, flags
, name
, mnt
->mnt
, data
);
1222 root
= mount_fs(type
, flags
, name
, &mnt
->mnt
, data
);
1227 return ERR_CAST(root
);
1229 #ifdef CONFIG_RKP_NS_PROT
1230 rkp_set_mnt_root_sb(mnt
->mnt
,root
,root
->d_sb
);
1231 mnt
->mnt_mountpoint
= mnt
->mnt
->mnt_root
;
1233 mnt
->mnt
.mnt_root
= root
;
1234 mnt
->mnt
.mnt_sb
= root
->d_sb
;
1235 mnt
->mnt_mountpoint
= mnt
->mnt
.mnt_root
;
1237 mnt
->mnt_parent
= mnt
;
1239 list_add_tail(&mnt
->mnt_instance
, &root
->d_sb
->s_mounts
);
1240 unlock_mount_hash();
1241 #ifdef CONFIG_RKP_NS_PROT
1247 EXPORT_SYMBOL_GPL(vfs_kern_mount
);
1249 static struct mount
*clone_mnt(struct mount
*old
, struct dentry
*root
,
1252 #ifdef CONFIG_RKP_NS_PROT
1253 struct super_block
*sb
= old
->mnt
->mnt_sb
;
1255 struct super_block
*sb
= old
->mnt
.mnt_sb
;
1259 #ifdef CONFIG_RKP_NS_PROT
1263 mnt
= alloc_vfsmnt(old
->mnt_devname
);
1265 return ERR_PTR(-ENOMEM
);
1267 if (sb
->s_op
->clone_mnt_data
) {
1268 #ifdef CONFIG_RKP_NS_PROT
1269 u64
*mnt_data
= (u64
*)(sb
->s_op
->clone_mnt_data(old
->mnt
->data
));
1271 rkp_call(RKP_CMDID(0x56), (u64
)(mnt
->mnt
), (u64
)mnt_data
, 0, 0, 0);
1272 if (!mnt
->mnt
->data
) {
1277 mnt
->mnt
.data
= sb
->s_op
->clone_mnt_data(old
->mnt
.data
);
1278 if (!mnt
->mnt
.data
) {
1285 if (flag
& (CL_SLAVE
| CL_PRIVATE
| CL_SHARED_TO_SLAVE
))
1286 mnt
->mnt_group_id
= 0; /* not a peer of original */
1288 mnt
->mnt_group_id
= old
->mnt_group_id
;
1290 if ((flag
& CL_MAKE_SHARED
) && !mnt
->mnt_group_id
) {
1291 err
= mnt_alloc_group_id(mnt
);
1296 #ifdef CONFIG_RKP_NS_PROT
1297 nsflags
= old
->mnt
->mnt_flags
& ~(MNT_WRITE_HOLD
|MNT_MARKED
);
1298 /* Don't allow unprivileged users to change mount flags */
1299 if (flag
& CL_UNPRIVILEGED
) {
1300 nsflags
|= MNT_LOCK_ATIME
;
1302 if (nsflags
& MNT_READONLY
)
1303 nsflags
|= MNT_LOCK_READONLY
;
1305 if (nsflags
& MNT_NODEV
)
1306 nsflags
|= MNT_LOCK_NODEV
;
1308 if (nsflags
& MNT_NOSUID
)
1309 nsflags
|= MNT_LOCK_NOSUID
;
1311 if (nsflags
& MNT_NOEXEC
)
1312 nsflags
|= MNT_LOCK_NOEXEC
;
1314 if ((flag
& CL_UNPRIVILEGED
) &&
1315 (!(flag
& CL_EXPIRE
) || list_empty(&old
->mnt_expire
)))
1316 nsflags
|= MNT_LOCKED
;
1317 rkp_assign_mnt_flags(mnt
->mnt
,nsflags
);
1319 mnt
->mnt
.mnt_flags
= old
->mnt
.mnt_flags
& ~(MNT_WRITE_HOLD
|MNT_MARKED
);
1320 /* Don't allow unprivileged users to change mount flags */
1321 if (flag
& CL_UNPRIVILEGED
) {
1322 mnt
->mnt
.mnt_flags
|= MNT_LOCK_ATIME
;
1324 if (mnt
->mnt
.mnt_flags
& MNT_READONLY
)
1325 mnt
->mnt
.mnt_flags
|= MNT_LOCK_READONLY
;
1327 if (mnt
->mnt
.mnt_flags
& MNT_NODEV
)
1328 mnt
->mnt
.mnt_flags
|= MNT_LOCK_NODEV
;
1330 if (mnt
->mnt
.mnt_flags
& MNT_NOSUID
)
1331 mnt
->mnt
.mnt_flags
|= MNT_LOCK_NOSUID
;
1333 if (mnt
->mnt
.mnt_flags
& MNT_NOEXEC
)
1334 mnt
->mnt
.mnt_flags
|= MNT_LOCK_NOEXEC
;
1336 if ((flag
& CL_UNPRIVILEGED
) &&
1337 (!(flag
& CL_EXPIRE
) || list_empty(&old
->mnt_expire
)))
1338 mnt
->mnt
.mnt_flags
|= MNT_LOCKED
;
1340 /* Don't allow unprivileged users to reveal what is under a mount */
1341 atomic_inc(&sb
->s_active
);
1342 #ifdef CONFIG_RKP_NS_PROT
1343 rkp_set_mnt_root_sb(mnt
->mnt
,dget(root
),sb
);
1344 mnt
->mnt_mountpoint
= mnt
->mnt
->mnt_root
;
1346 mnt
->mnt
.mnt_sb
= sb
;
1347 mnt
->mnt
.mnt_root
= dget(root
);
1348 mnt
->mnt_mountpoint
= mnt
->mnt
.mnt_root
;
1350 mnt
->mnt_parent
= mnt
;
1352 list_add_tail(&mnt
->mnt_instance
, &sb
->s_mounts
);
1353 unlock_mount_hash();
1355 if ((flag
& CL_SLAVE
) ||
1356 ((flag
& CL_SHARED_TO_SLAVE
) && IS_MNT_SHARED(old
))) {
1357 list_add(&mnt
->mnt_slave
, &old
->mnt_slave_list
);
1358 mnt
->mnt_master
= old
;
1359 CLEAR_MNT_SHARED(mnt
);
1360 } else if (!(flag
& CL_PRIVATE
)) {
1361 if ((flag
& CL_MAKE_SHARED
) || IS_MNT_SHARED(old
))
1362 list_add(&mnt
->mnt_share
, &old
->mnt_share
);
1363 if (IS_MNT_SLAVE(old
))
1364 list_add(&mnt
->mnt_slave
, &old
->mnt_slave
);
1365 mnt
->mnt_master
= old
->mnt_master
;
1367 if (flag
& CL_MAKE_SHARED
)
1368 set_mnt_shared(mnt
);
1370 /* stick the duplicate mount on the same expiry list
1371 * as the original if that was on one */
1372 if (flag
& CL_EXPIRE
) {
1373 if (!list_empty(&old
->mnt_expire
))
1374 list_add(&mnt
->mnt_expire
, &old
->mnt_expire
);
1382 return ERR_PTR(err
);
1385 static void cleanup_mnt(struct mount
*mnt
)
1388 * This probably indicates that somebody messed
1389 * up a mnt_want/drop_write() pair. If this
1390 * happens, the filesystem was probably unable
1391 * to make r/w->r/o transitions.
1394 * The locking used to deal with mnt_count decrement provides barriers,
1395 * so mnt_get_writers() below is safe.
1397 WARN_ON(mnt_get_writers(mnt
));
1398 if (unlikely(mnt
->mnt_pins
.first
))
1400 #ifdef CONFIG_RKP_NS_PROT
1401 fsnotify_vfsmount_delete(mnt
->mnt
);
1402 dput(mnt
->mnt
->mnt_root
);
1403 deactivate_super(mnt
->mnt
->mnt_sb
);
1405 fsnotify_vfsmount_delete(&mnt
->mnt
);
1406 dput(mnt
->mnt
.mnt_root
);
1407 deactivate_super(mnt
->mnt
.mnt_sb
);
1410 call_rcu(&mnt
->mnt_rcu
, delayed_free_vfsmnt
);
1413 static void __cleanup_mnt(struct rcu_head
*head
)
1415 cleanup_mnt(container_of(head
, struct mount
, mnt_rcu
));
1418 static LLIST_HEAD(delayed_mntput_list
);
1419 static void delayed_mntput(struct work_struct
*unused
)
1421 struct llist_node
*node
= llist_del_all(&delayed_mntput_list
);
1422 struct llist_node
*next
;
1424 for (; node
; node
= next
) {
1425 next
= llist_next(node
);
1426 cleanup_mnt(llist_entry(node
, struct mount
, mnt_llist
));
1429 static DECLARE_DELAYED_WORK(delayed_mntput_work
, delayed_mntput
);
1431 static void mntput_no_expire(struct mount
*mnt
)
1434 if (likely(READ_ONCE(mnt
->mnt_ns
))) {
1436 * Since we don't do lock_mount_hash() here,
1437 * ->mnt_ns can change under us. However, if it's
1438 * non-NULL, then there's a reference that won't
1439 * be dropped until after an RCU delay done after
1440 * turning ->mnt_ns NULL. So if we observe it
1441 * non-NULL under rcu_read_lock(), the reference
1442 * we are dropping is not the final one.
1444 mnt_add_count(mnt
, -1);
1446 sys_umount_trace_set_status(UMOUNT_END_REMAIN_NS
);
1451 * make sure that if __legitimize_mnt() has not seen us grab
1452 * mount_lock, we'll see their refcount increment here.
1455 mnt_add_count(mnt
, -1);
1456 if (mnt_get_count(mnt
)) {
1458 unlock_mount_hash();
1459 sys_umount_trace_set_status(UMOUNT_END_REMAIN_MNT_COUNT
);
1463 #ifdef CONFIG_RKP_NS_PROT
1464 if (unlikely(mnt
->mnt
->mnt_flags
& MNT_DOOMED
)) {
1466 if (unlikely(mnt
->mnt
.mnt_flags
& MNT_DOOMED
)) {
1469 unlock_mount_hash();
1472 #ifdef CONFIG_RKP_NS_PROT
1473 rkp_set_mnt_flags(mnt
->mnt
,MNT_DOOMED
);
1475 mnt
->mnt
.mnt_flags
|= MNT_DOOMED
;
1479 list_del(&mnt
->mnt_instance
);
1481 if (unlikely(!list_empty(&mnt
->mnt_mounts
))) {
1482 struct mount
*p
, *tmp
;
1483 list_for_each_entry_safe(p
, tmp
, &mnt
->mnt_mounts
, mnt_child
) {
1487 unlock_mount_hash();
1489 #ifdef CONFIG_RKP_NS_PROT
1490 if (likely(!(mnt
->mnt
->mnt_flags
& MNT_INTERNAL
))) {
1492 if (likely(!(mnt
->mnt
.mnt_flags
& MNT_INTERNAL
))) {
1494 struct task_struct
*task
= current
;
1495 if (likely(!(task
->flags
& PF_KTHREAD
))) {
1496 init_task_work(&mnt
->mnt_rcu
, __cleanup_mnt
);
1497 if (!task_work_add(task
, &mnt
->mnt_rcu
, true)) {
1498 sys_umount_trace_set_status(UMOUNT_END_ADD_TASK
);
1502 if (llist_add(&mnt
->mnt_llist
, &delayed_mntput_list
)) {
1503 schedule_delayed_work(&delayed_mntput_work
, 1);
1504 sys_umount_trace_set_status(UMOUNT_END_ADD_DELAYED_WORK
);
1511 void mntput(struct vfsmount
*mnt
)
1514 struct mount
*m
= real_mount(mnt
);
1515 /* avoid cacheline pingpong, hope gcc doesn't get "smart" */
1516 if (unlikely(m
->mnt_expiry_mark
))
1517 m
->mnt_expiry_mark
= 0;
1518 mntput_no_expire(m
);
1521 EXPORT_SYMBOL(mntput
);
1523 struct vfsmount
*mntget(struct vfsmount
*mnt
)
1526 mnt_add_count(real_mount(mnt
), 1);
1529 EXPORT_SYMBOL(mntget
);
1531 struct vfsmount
*mnt_clone_internal(struct path
*path
)
1534 p
= clone_mnt(real_mount(path
->mnt
), path
->dentry
, CL_PRIVATE
);
1537 #ifdef CONFIG_RKP_NS_PROT
1538 rkp_set_mnt_flags(p
->mnt
,MNT_INTERNAL
);
1541 p
->mnt
.mnt_flags
|= MNT_INTERNAL
;
1546 static inline void mangle(struct seq_file
*m
, const char *s
)
1548 seq_escape(m
, s
, " \t\n\\");
1552 * Simple .show_options callback for filesystems which don't want to
1553 * implement more complex mount option showing.
1555 * See also save_mount_options().
1557 int generic_show_options(struct seq_file
*m
, struct dentry
*root
)
1559 const char *options
;
1562 options
= rcu_dereference(root
->d_sb
->s_options
);
1564 if (options
!= NULL
&& options
[0]) {
1572 EXPORT_SYMBOL(generic_show_options
);
1575 * If filesystem uses generic_show_options(), this function should be
1576 * called from the fill_super() callback.
1578 * The .remount_fs callback usually needs to be handled in a special
1579 * way, to make sure, that previous options are not overwritten if the
1582 * Also note, that if the filesystem's .remount_fs function doesn't
1583 * reset all options to their default value, but changes only newly
1584 * given options, then the displayed options will not reflect reality
1587 void save_mount_options(struct super_block
*sb
, char *options
)
1589 BUG_ON(sb
->s_options
);
1590 rcu_assign_pointer(sb
->s_options
, kstrdup(options
, GFP_KERNEL
));
1592 EXPORT_SYMBOL(save_mount_options
);
1594 void replace_mount_options(struct super_block
*sb
, char *options
)
1596 char *old
= sb
->s_options
;
1597 rcu_assign_pointer(sb
->s_options
, options
);
1603 EXPORT_SYMBOL(replace_mount_options
);
1605 #ifdef CONFIG_PROC_FS
1606 /* iterator; we want it to have access to namespace_sem, thus here... */
1607 static void *m_start(struct seq_file
*m
, loff_t
*pos
)
1609 struct proc_mounts
*p
= m
->private;
1611 down_read(&namespace_sem
);
1612 if (p
->cached_event
== p
->ns
->event
) {
1613 void *v
= p
->cached_mount
;
1614 if (*pos
== p
->cached_index
)
1616 if (*pos
== p
->cached_index
+ 1) {
1617 v
= seq_list_next(v
, &p
->ns
->list
, &p
->cached_index
);
1618 return p
->cached_mount
= v
;
1622 p
->cached_event
= p
->ns
->event
;
1623 p
->cached_mount
= seq_list_start(&p
->ns
->list
, *pos
);
1624 p
->cached_index
= *pos
;
1625 return p
->cached_mount
;
1628 static void *m_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
1630 struct proc_mounts
*p
= m
->private;
1632 p
->cached_mount
= seq_list_next(v
, &p
->ns
->list
, pos
);
1633 p
->cached_index
= *pos
;
1634 return p
->cached_mount
;
1637 static void m_stop(struct seq_file
*m
, void *v
)
1639 up_read(&namespace_sem
);
1642 static int m_show(struct seq_file
*m
, void *v
)
1644 struct proc_mounts
*p
= m
->private;
1645 struct mount
*r
= list_entry(v
, struct mount
, mnt_list
);
1646 #ifdef CONFIG_RKP_NS_PROT
1647 return p
->show(m
, r
->mnt
);
1649 return p
->show(m
, &r
->mnt
);
1653 const struct seq_operations mounts_op
= {
1659 #endif /* CONFIG_PROC_FS */
1662 * may_umount_tree - check if a mount tree is busy
1663 * @mnt: root of mount tree
1665 * This is called to check if a tree of mounts has any
1666 * open files, pwds, chroots or sub mounts that are
1669 int may_umount_tree(struct vfsmount
*m
)
1671 struct mount
*mnt
= real_mount(m
);
1672 int actual_refs
= 0;
1673 int minimum_refs
= 0;
1677 /* write lock needed for mnt_get_count */
1679 for (p
= mnt
; p
; p
= next_mnt(p
, mnt
)) {
1680 actual_refs
+= mnt_get_count(p
);
1683 unlock_mount_hash();
1685 if (actual_refs
> minimum_refs
)
1691 EXPORT_SYMBOL(may_umount_tree
);
1694 * may_umount - check if a mount point is busy
1695 * @mnt: root of mount
1697 * This is called to check if a mount point has any
1698 * open files, pwds, chroots or sub mounts. If the
1699 * mount has sub mounts this will return busy
1700 * regardless of whether the sub mounts are busy.
1702 * Doesn't take quota and stuff into account. IOW, in some cases it will
1703 * give false negatives. The main reason why it's here is that we need
1704 * a non-destructive way to look for easily umountable filesystems.
1706 int may_umount(struct vfsmount
*mnt
)
1709 down_read(&namespace_sem
);
1711 if (propagate_mount_busy(real_mount(mnt
), 2))
1713 unlock_mount_hash();
1714 up_read(&namespace_sem
);
1718 EXPORT_SYMBOL(may_umount
);
1720 static HLIST_HEAD(unmounted
); /* protected by namespace_sem */
1722 static void namespace_unlock(void)
1724 struct hlist_head head
;
1726 hlist_move_list(&unmounted
, &head
);
1728 up_write(&namespace_sem
);
1730 if (likely(hlist_empty(&head
)))
1735 group_pin_kill(&head
);
1738 static inline void namespace_lock(void)
1740 down_write(&namespace_sem
);
1743 enum umount_tree_flags
{
1745 UMOUNT_PROPAGATE
= 2,
1746 UMOUNT_CONNECTED
= 4,
1749 static bool disconnect_mount(struct mount
*mnt
, enum umount_tree_flags how
)
1751 /* Leaving mounts connected is only valid for lazy umounts */
1752 if (how
& UMOUNT_SYNC
)
1755 /* A mount without a parent has nothing to be connected to */
1756 if (!mnt_has_parent(mnt
))
1759 /* Because the reference counting rules change when mounts are
1760 * unmounted and connected, umounted mounts may not be
1761 * connected to mounted mounts.
1763 #ifdef CONFIG_RKP_NS_PROT
1764 if (!(mnt
->mnt_parent
->mnt
->mnt_flags
& MNT_UMOUNT
))
1766 if (!(mnt
->mnt_parent
->mnt
.mnt_flags
& MNT_UMOUNT
))
1770 /* Has it been requested that the mount remain connected? */
1771 if (how
& UMOUNT_CONNECTED
)
1774 /* Is the mount locked such that it needs to remain connected? */
1775 if (IS_MNT_LOCKED(mnt
))
1778 /* By default disconnect the mount */
1783 * mount_lock must be held
1784 * namespace_sem must be held for write
1786 static void umount_tree(struct mount
*mnt
, enum umount_tree_flags how
)
1788 LIST_HEAD(tmp_list
);
1791 if (how
& UMOUNT_PROPAGATE
)
1792 propagate_mount_unlock(mnt
);
1794 /* Gather the mounts to umount */
1795 for (p
= mnt
; p
; p
= next_mnt(p
, mnt
)) {
1797 #ifdef CONFIG_RKP_NS_PROT
1798 rkp_set_mnt_flags(p
->mnt
,MNT_UMOUNT
);
1800 p
->mnt
.mnt_flags
|= MNT_UMOUNT
;
1802 list_move(&p
->mnt_list
, &tmp_list
);
1805 /* Hide the mounts from mnt_mounts */
1806 list_for_each_entry(p
, &tmp_list
, mnt_list
) {
1807 list_del_init(&p
->mnt_child
);
1810 /* Add propogated mounts to the tmp_list */
1811 if (how
& UMOUNT_PROPAGATE
)
1812 propagate_umount(&tmp_list
);
1814 while (!list_empty(&tmp_list
)) {
1815 struct mnt_namespace
*ns
;
1817 p
= list_first_entry(&tmp_list
, struct mount
, mnt_list
);
1818 list_del_init(&p
->mnt_expire
);
1819 list_del_init(&p
->mnt_list
);
1823 __touch_mnt_namespace(ns
);
1826 if (how
& UMOUNT_SYNC
)
1827 #ifdef CONFIG_RKP_NS_PROT
1828 rkp_set_mnt_flags(p
->mnt
,MNT_SYNC_UMOUNT
);
1830 p
->mnt
.mnt_flags
|= MNT_SYNC_UMOUNT
;
1832 disconnect
= disconnect_mount(p
, how
);
1834 #ifdef CONFIG_RKP_NS_PROT
1835 pin_insert_group(&p
->mnt_umount
, p
->mnt_parent
->mnt
,
1837 pin_insert_group(&p
->mnt_umount
, &p
->mnt_parent
->mnt
,
1839 disconnect
? &unmounted
: NULL
);
1840 if (mnt_has_parent(p
)) {
1841 mnt_add_count(p
->mnt_parent
, -1);
1843 /* Don't forget about p */
1844 list_add_tail(&p
->mnt_child
, &p
->mnt_parent
->mnt_mounts
);
1849 change_mnt_propagation(p
, MS_PRIVATE
);
1853 static void shrink_submounts(struct mount
*mnt
);
1855 static int do_umount(struct mount
*mnt
, int flags
)
1857 #ifdef CONFIG_RKP_NS_PROT
1858 struct super_block
*sb
= mnt
->mnt
->mnt_sb
;
1860 struct super_block
*sb
= mnt
->mnt
.mnt_sb
;
1864 #ifdef CONFIG_RKP_NS_PROT
1865 retval
= security_sb_umount(mnt
->mnt
, flags
);
1867 retval
= security_sb_umount(&mnt
->mnt
, flags
);
1873 * Allow userspace to request a mountpoint be expired rather than
1874 * unmounting unconditionally. Unmount only happens if:
1875 * (1) the mark is already set (the mark is cleared by mntput())
1876 * (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount]
1878 if (flags
& MNT_EXPIRE
) {
1879 #ifdef CONFIG_RKP_NS_PROT
1880 if (mnt
->mnt
== current
->fs
->root
.mnt
||
1882 if (&mnt
->mnt
== current
->fs
->root
.mnt
||
1884 flags
& (MNT_FORCE
| MNT_DETACH
))
1888 * probably don't strictly need the lock here if we examined
1889 * all race cases, but it's a slowpath.
1892 if (mnt_get_count(mnt
) != 2) {
1893 unlock_mount_hash();
1896 unlock_mount_hash();
1898 if (!xchg(&mnt
->mnt_expiry_mark
, 1))
1903 * If we may have to abort operations to get out of this
1904 * mount, and they will themselves hold resources we must
1905 * allow the fs to do things. In the Unix tradition of
1906 * 'Gee thats tricky lets do it in userspace' the umount_begin
1907 * might fail to complete on the first run through as other tasks
1908 * must return, and the like. Thats for the mount program to worry
1909 * about for the moment.
1912 if (flags
& MNT_FORCE
&& sb
->s_op
->umount_begin
) {
1913 sb
->s_op
->umount_begin(sb
);
1917 * No sense to grab the lock for this test, but test itself looks
1918 * somewhat bogus. Suggestions for better replacement?
1919 * Ho-hum... In principle, we might treat that as umount + switch
1920 * to rootfs. GC would eventually take care of the old vfsmount.
1921 * Actually it makes sense, especially if rootfs would contain a
1922 * /reboot - static binary that would close all descriptors and
1923 * call reboot(9). Then init(8) could umount root and exec /reboot.
1925 #ifdef CONFIG_RKP_NS_PROT
1926 if (mnt
->mnt
== current
->fs
->root
.mnt
&& !(flags
& MNT_DETACH
)) {
1928 if (&mnt
->mnt
== current
->fs
->root
.mnt
&& !(flags
& MNT_DETACH
)) {
1931 * Special case for "unmounting" root ...
1932 * we just try to remount it readonly.
1934 if (!capable(CAP_SYS_ADMIN
))
1936 down_write(&sb
->s_umount
);
1937 if (!(sb
->s_flags
& MS_RDONLY
))
1938 retval
= do_remount_sb(sb
, MS_RDONLY
, NULL
, 0);
1939 up_write(&sb
->s_umount
);
1947 if (flags
& MNT_DETACH
) {
1948 if (!list_empty(&mnt
->mnt_list
))
1949 umount_tree(mnt
, UMOUNT_PROPAGATE
);
1952 shrink_submounts(mnt
);
1954 if (!propagate_mount_busy(mnt
, 2)) {
1955 if (!list_empty(&mnt
->mnt_list
))
1956 umount_tree(mnt
, UMOUNT_PROPAGATE
|UMOUNT_SYNC
);
1960 unlock_mount_hash();
1966 * __detach_mounts - lazily unmount all mounts on the specified dentry
1968 * During unlink, rmdir, and d_drop it is possible to loose the path
1969 * to an existing mountpoint, and wind up leaking the mount.
1970 * detach_mounts allows lazily unmounting those mounts instead of
1973 * The caller may hold dentry->d_inode->i_mutex.
1975 void __detach_mounts(struct dentry
*dentry
)
1977 struct mountpoint
*mp
;
1982 mp
= lookup_mountpoint(dentry
);
1983 if (IS_ERR_OR_NULL(mp
))
1987 while (!hlist_empty(&mp
->m_list
)) {
1988 mnt
= hlist_entry(mp
->m_list
.first
, struct mount
, mnt_mp_list
);
1989 #ifdef CONFIG_RKP_NS_PROT
1990 if (mnt
->mnt
->mnt_flags
& MNT_UMOUNT
) {
1992 if (mnt
->mnt
.mnt_flags
& MNT_UMOUNT
) {
1994 hlist_add_head(&mnt
->mnt_umount
.s_list
, &unmounted
);
1997 else umount_tree(mnt
, UMOUNT_CONNECTED
);
2001 unlock_mount_hash();
2006 * Is the caller allowed to modify his namespace?
2008 static inline bool may_mount(void)
2010 return ns_capable(current
->nsproxy
->mnt_ns
->user_ns
, CAP_SYS_ADMIN
);
2014 * Now umount can handle mount points as well as block devices.
2015 * This is important for filesystems which use unnamed block devices.
2017 * We now support a flag for forced unmount like the other 'big iron'
2018 * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD
2021 SYSCALL_DEFINE2(umount
, char __user
*, name
, int, flags
)
2026 int lookup_flags
= 0, stlog
= 0;
2028 if (flags
& ~(MNT_FORCE
| MNT_DETACH
| MNT_EXPIRE
| UMOUNT_NOFOLLOW
))
2034 if (!(flags
& UMOUNT_NOFOLLOW
))
2035 lookup_flags
|= LOOKUP_FOLLOW
;
2037 retval
= user_path_mountpoint_at(AT_FDCWD
, name
, lookup_flags
, &path
);
2040 mnt
= real_mount(path
.mnt
);
2042 if (path
.dentry
!= path
.mnt
->mnt_root
)
2044 if (!check_mnt(mnt
))
2047 #ifdef CONFIG_RKP_NS_PROT
2048 if (mnt
->mnt
->mnt_flags
& MNT_LOCKED
)
2050 if (mnt
->mnt
.mnt_flags
& MNT_LOCKED
)
2054 if (flags
& MNT_FORCE
&& !capable(CAP_SYS_ADMIN
))
2057 stlog
= sys_umount_trace_start(mnt
, flags
);
2058 retval
= do_umount(mnt
, flags
);
2060 /* we mustn't call path_put() as that would clear mnt_expiry_mark */
2062 mntput_no_expire(mnt
);
2063 sys_umount_trace_end(mnt
, stlog
);
2068 #ifdef __ARCH_WANT_SYS_OLDUMOUNT
2071 * The 2.0 compatible umount. No flags.
2073 SYSCALL_DEFINE1(oldumount
, char __user
*, name
)
2075 return sys_umount(name
, 0);
2080 static bool is_mnt_ns_file(struct dentry
*dentry
)
2082 /* Is this a proxy for a mount namespace? */
2083 return dentry
->d_op
== &ns_dentry_operations
&&
2084 dentry
->d_fsdata
== &mntns_operations
;
2087 struct mnt_namespace
*to_mnt_ns(struct ns_common
*ns
)
2089 return container_of(ns
, struct mnt_namespace
, ns
);
2092 static bool mnt_ns_loop(struct dentry
*dentry
)
2094 /* Could bind mounting the mount namespace inode cause a
2095 * mount namespace loop?
2097 struct mnt_namespace
*mnt_ns
;
2098 if (!is_mnt_ns_file(dentry
))
2101 mnt_ns
= to_mnt_ns(get_proc_ns(dentry
->d_inode
));
2102 return current
->nsproxy
->mnt_ns
->seq
>= mnt_ns
->seq
;
2105 struct mount
*copy_tree(struct mount
*mnt
, struct dentry
*dentry
,
2108 struct mount
*res
, *p
, *q
, *r
, *parent
;
2110 if (!(flag
& CL_COPY_UNBINDABLE
) && IS_MNT_UNBINDABLE(mnt
))
2111 return ERR_PTR(-EINVAL
);
2113 if (!(flag
& CL_COPY_MNT_NS_FILE
) && is_mnt_ns_file(dentry
))
2114 return ERR_PTR(-EINVAL
);
2116 res
= q
= clone_mnt(mnt
, dentry
, flag
);
2120 q
->mnt_mountpoint
= mnt
->mnt_mountpoint
;
2123 list_for_each_entry(r
, &mnt
->mnt_mounts
, mnt_child
) {
2125 if (!is_subdir(r
->mnt_mountpoint
, dentry
))
2128 for (s
= r
; s
; s
= next_mnt(s
, r
)) {
2129 if (!(flag
& CL_COPY_UNBINDABLE
) &&
2130 IS_MNT_UNBINDABLE(s
)) {
2131 s
= skip_mnt_tree(s
);
2134 if (!(flag
& CL_COPY_MNT_NS_FILE
) &&
2135 #ifdef CONFIG_RKP_NS_PROT
2136 is_mnt_ns_file(s
->mnt
->mnt_root
)) {
2138 is_mnt_ns_file(s
->mnt
.mnt_root
)) {
2140 s
= skip_mnt_tree(s
);
2143 while (p
!= s
->mnt_parent
) {
2149 #ifdef CONFIG_RKP_NS_PROT
2150 q
= clone_mnt(p
, p
->mnt
->mnt_root
, flag
);
2152 q
= clone_mnt(p
, p
->mnt
.mnt_root
, flag
);
2157 list_add_tail(&q
->mnt_list
, &res
->mnt_list
);
2158 attach_mnt(q
, parent
, p
->mnt_mp
);
2159 unlock_mount_hash();
2166 umount_tree(res
, UMOUNT_SYNC
);
2167 unlock_mount_hash();
2172 /* Caller should check returned pointer for errors */
2174 struct vfsmount
*collect_mounts(struct path
*path
)
2178 if (!check_mnt(real_mount(path
->mnt
)))
2179 tree
= ERR_PTR(-EINVAL
);
2181 tree
= copy_tree(real_mount(path
->mnt
), path
->dentry
,
2182 CL_COPY_ALL
| CL_PRIVATE
);
2185 return ERR_CAST(tree
);
2186 #ifdef CONFIG_RKP_NS_PROT
2193 void drop_collected_mounts(struct vfsmount
*mnt
)
2197 umount_tree(real_mount(mnt
), UMOUNT_SYNC
);
2198 unlock_mount_hash();
2203 * clone_private_mount - create a private clone of a path
2205 * This creates a new vfsmount, which will be the clone of @path. The new will
2206 * not be attached anywhere in the namespace and will be private (i.e. changes
2207 * to the originating mount won't be propagated into this).
2209 * Release with mntput().
2211 struct vfsmount
*clone_private_mount(struct path
*path
)
2213 struct mount
*old_mnt
= real_mount(path
->mnt
);
2214 struct mount
*new_mnt
;
2216 if (IS_MNT_UNBINDABLE(old_mnt
))
2217 return ERR_PTR(-EINVAL
);
2219 down_read(&namespace_sem
);
2220 new_mnt
= clone_mnt(old_mnt
, path
->dentry
, CL_PRIVATE
);
2221 up_read(&namespace_sem
);
2222 if (IS_ERR(new_mnt
))
2223 return ERR_CAST(new_mnt
);
2225 #ifdef CONFIG_RKP_NS_PROT
2226 return new_mnt
->mnt
;
2228 return &new_mnt
->mnt
;
2231 EXPORT_SYMBOL_GPL(clone_private_mount
);
2233 int iterate_mounts(int (*f
)(struct vfsmount
*, void *), void *arg
,
2234 struct vfsmount
*root
)
2237 int res
= f(root
, arg
);
2240 list_for_each_entry(mnt
, &real_mount(root
)->mnt_list
, mnt_list
) {
2241 #ifdef CONFIG_RKP_NS_PROT
2242 res
= f(mnt
->mnt
, arg
);
2244 res
= f(&mnt
->mnt
, arg
);
2252 static void cleanup_group_ids(struct mount
*mnt
, struct mount
*end
)
2256 for (p
= mnt
; p
!= end
; p
= next_mnt(p
, mnt
)) {
2257 if (p
->mnt_group_id
&& !IS_MNT_SHARED(p
))
2258 mnt_release_group_id(p
);
2262 static int invent_group_ids(struct mount
*mnt
, bool recurse
)
2266 for (p
= mnt
; p
; p
= recurse
? next_mnt(p
, mnt
) : NULL
) {
2267 if (!p
->mnt_group_id
&& !IS_MNT_SHARED(p
)) {
2268 int err
= mnt_alloc_group_id(p
);
2270 cleanup_group_ids(mnt
, p
);
2279 int count_mounts(struct mnt_namespace
*ns
, struct mount
*mnt
)
2281 unsigned int max
= READ_ONCE(sysctl_mount_max
);
2282 unsigned int mounts
= 0, old
, pending
, sum
;
2285 for (p
= mnt
; p
; p
= next_mnt(p
, mnt
))
2289 pending
= ns
->pending_mounts
;
2290 sum
= old
+ pending
;
2294 (mounts
> (max
- sum
)))
2297 ns
->pending_mounts
= pending
+ mounts
;
2302 * @source_mnt : mount tree to be attached
2303 * @nd : place the mount tree @source_mnt is attached
2304 * @parent_nd : if non-null, detach the source_mnt from its parent and
2305 * store the parent mount and mountpoint dentry.
2306 * (done when source_mnt is moved)
2308 * NOTE: in the table below explains the semantics when a source mount
2309 * of a given type is attached to a destination mount of a given type.
2310 * ---------------------------------------------------------------------------
2311 * | BIND MOUNT OPERATION |
2312 * |**************************************************************************
2313 * | source-->| shared | private | slave | unbindable |
2317 * |**************************************************************************
2318 * | shared | shared (++) | shared (+) | shared(+++)| invalid |
2320 * |non-shared| shared (+) | private | slave (*) | invalid |
2321 * ***************************************************************************
2322 * A bind operation clones the source mount and mounts the clone on the
2323 * destination mount.
2325 * (++) the cloned mount is propagated to all the mounts in the propagation
2326 * tree of the destination mount and the cloned mount is added to
2327 * the peer group of the source mount.
2328 * (+) the cloned mount is created under the destination mount and is marked
2329 * as shared. The cloned mount is added to the peer group of the source
2331 * (+++) the mount is propagated to all the mounts in the propagation tree
2332 * of the destination mount and the cloned mount is made slave
2333 * of the same master as that of the source mount. The cloned mount
2334 * is marked as 'shared and slave'.
2335 * (*) the cloned mount is made a slave of the same master as that of the
2338 * ---------------------------------------------------------------------------
2339 * | MOVE MOUNT OPERATION |
2340 * |**************************************************************************
2341 * | source-->| shared | private | slave | unbindable |
2345 * |**************************************************************************
2346 * | shared | shared (+) | shared (+) | shared(+++) | invalid |
2348 * |non-shared| shared (+*) | private | slave (*) | unbindable |
2349 * ***************************************************************************
2351 * (+) the mount is moved to the destination. And is then propagated to
2352 * all the mounts in the propagation tree of the destination mount.
2353 * (+*) the mount is moved to the destination.
2354 * (+++) the mount is moved to the destination and is then propagated to
2355 * all the mounts belonging to the destination mount's propagation tree.
2356 * the mount is marked as 'shared and slave'.
2357 * (*) the mount continues to be a slave at the new location.
2359 * if the source mount is a tree, the operations explained above is
2360 * applied to each mount in the tree.
2361 * Must be called without spinlocks held, since this function can sleep
2364 static int attach_recursive_mnt(struct mount
*source_mnt
,
2365 struct mount
*dest_mnt
,
2366 struct mountpoint
*dest_mp
,
2367 struct path
*parent_path
)
2369 HLIST_HEAD(tree_list
);
2370 struct mnt_namespace
*ns
= dest_mnt
->mnt_ns
;
2371 struct mountpoint
*smp
;
2372 struct mount
*child
, *p
;
2373 struct hlist_node
*n
;
2376 /* Preallocate a mountpoint in case the new mounts need
2377 * to be tucked under other mounts.
2379 #ifdef CONFIG_RKP_NS_PROT
2380 smp
= get_mountpoint(source_mnt
->mnt
->mnt_root
);
2382 smp
= get_mountpoint(source_mnt
->mnt
.mnt_root
);
2385 return PTR_ERR(smp
);
2387 /* Is there space to add these mounts to the mount namespace? */
2389 err
= count_mounts(ns
, source_mnt
);
2394 if (IS_MNT_SHARED(dest_mnt
)) {
2395 err
= invent_group_ids(source_mnt
, true);
2398 err
= propagate_mnt(dest_mnt
, dest_mp
, source_mnt
, &tree_list
);
2401 goto out_cleanup_ids
;
2402 for (p
= source_mnt
; p
; p
= next_mnt(p
, source_mnt
))
2408 detach_mnt(source_mnt
, parent_path
);
2409 attach_mnt(source_mnt
, dest_mnt
, dest_mp
);
2410 touch_mnt_namespace(source_mnt
->mnt_ns
);
2412 mnt_set_mountpoint(dest_mnt
, dest_mp
, source_mnt
);
2413 commit_tree(source_mnt
);
2416 hlist_for_each_entry_safe(child
, n
, &tree_list
, mnt_hash
) {
2418 hlist_del_init(&child
->mnt_hash
);
2419 #ifdef CONFIG_RKP_NS_PROT
2420 q
= __lookup_mnt(child
->mnt_parent
->mnt
,
2421 child
->mnt_mountpoint
);
2423 q
= __lookup_mnt(&child
->mnt_parent
->mnt
,
2424 child
->mnt_mountpoint
);
2427 mnt_change_mountpoint(child
, smp
, q
);
2430 put_mountpoint(smp
);
2431 unlock_mount_hash();
2436 while (!hlist_empty(&tree_list
)) {
2437 child
= hlist_entry(tree_list
.first
, struct mount
, mnt_hash
);
2438 child
->mnt_parent
->mnt_ns
->pending_mounts
= 0;
2439 umount_tree(child
, UMOUNT_SYNC
);
2441 unlock_mount_hash();
2442 cleanup_group_ids(source_mnt
, NULL
);
2444 ns
->pending_mounts
= 0;
2446 read_seqlock_excl(&mount_lock
);
2447 put_mountpoint(smp
);
2448 read_sequnlock_excl(&mount_lock
);
2453 static struct mountpoint
*lock_mount(struct path
*path
)
2455 struct vfsmount
*mnt
;
2456 struct dentry
*dentry
= path
->dentry
;
2458 mutex_lock(&dentry
->d_inode
->i_mutex
);
2459 if (unlikely(cant_mount(dentry
))) {
2460 mutex_unlock(&dentry
->d_inode
->i_mutex
);
2461 return ERR_PTR(-ENOENT
);
2464 mnt
= lookup_mnt(path
);
2466 struct mountpoint
*mp
= get_mountpoint(dentry
);
2469 mutex_unlock(&dentry
->d_inode
->i_mutex
);
2475 mutex_unlock(&path
->dentry
->d_inode
->i_mutex
);
2478 dentry
= path
->dentry
= dget(mnt
->mnt_root
);
2482 static void unlock_mount(struct mountpoint
*where
)
2484 struct dentry
*dentry
= where
->m_dentry
;
2486 read_seqlock_excl(&mount_lock
);
2487 put_mountpoint(where
);
2488 read_sequnlock_excl(&mount_lock
);
2491 mutex_unlock(&dentry
->d_inode
->i_mutex
);
2494 static int graft_tree(struct mount
*mnt
, struct mount
*p
, struct mountpoint
*mp
)
2496 #ifdef CONFIG_RKP_NS_PROT
2497 if (mnt
->mnt
->mnt_sb
->s_flags
& MS_NOUSER
)
2499 if (mnt
->mnt
.mnt_sb
->s_flags
& MS_NOUSER
)
2503 if (d_is_dir(mp
->m_dentry
) !=
2504 #ifdef CONFIG_RKP_NS_PROT
2505 d_is_dir(mnt
->mnt
->mnt_root
))
2507 d_is_dir(mnt
->mnt
.mnt_root
))
2511 return attach_recursive_mnt(mnt
, p
, mp
, NULL
);
2515 * Sanity check the flags to change_mnt_propagation.
2518 static int flags_to_propagation_type(int flags
)
2520 int type
= flags
& ~(MS_REC
| MS_SILENT
);
2522 /* Fail if any non-propagation flags are set */
2523 if (type
& ~(MS_SHARED
| MS_PRIVATE
| MS_SLAVE
| MS_UNBINDABLE
))
2525 /* Only one propagation flag should be set */
2526 if (!is_power_of_2(type
))
2532 * recursively change the type of the mountpoint.
2534 static int do_change_type(struct path
*path
, int flag
)
2537 struct mount
*mnt
= real_mount(path
->mnt
);
2538 int recurse
= flag
& MS_REC
;
2542 if (path
->dentry
!= path
->mnt
->mnt_root
)
2545 type
= flags_to_propagation_type(flag
);
2550 if (type
== MS_SHARED
) {
2551 err
= invent_group_ids(mnt
, recurse
);
2557 for (m
= mnt
; m
; m
= (recurse
? next_mnt(m
, mnt
) : NULL
))
2558 change_mnt_propagation(m
, type
);
2559 unlock_mount_hash();
2566 static bool has_locked_children(struct mount
*mnt
, struct dentry
*dentry
)
2568 struct mount
*child
;
2569 list_for_each_entry(child
, &mnt
->mnt_mounts
, mnt_child
) {
2570 if (!is_subdir(child
->mnt_mountpoint
, dentry
))
2573 #ifdef CONFIG_RKP_NS_PROT
2574 if (child
->mnt
->mnt_flags
& MNT_LOCKED
)
2576 if (child
->mnt
.mnt_flags
& MNT_LOCKED
)
2584 * do loopback mount.
2586 static int do_loopback(struct path
*path
, const char *old_name
,
2589 struct path old_path
;
2590 struct mount
*mnt
= NULL
, *old
, *parent
;
2591 struct mountpoint
*mp
;
2593 if (!old_name
|| !*old_name
)
2595 err
= kern_path(old_name
, LOOKUP_FOLLOW
|LOOKUP_AUTOMOUNT
, &old_path
);
2600 if (mnt_ns_loop(old_path
.dentry
))
2603 mp
= lock_mount(path
);
2608 old
= real_mount(old_path
.mnt
);
2609 parent
= real_mount(path
->mnt
);
2612 if (IS_MNT_UNBINDABLE(old
))
2615 if (!check_mnt(parent
))
2618 if (!check_mnt(old
) && old_path
.dentry
->d_op
!= &ns_dentry_operations
)
2621 if (!recurse
&& has_locked_children(old
, old_path
.dentry
))
2625 mnt
= copy_tree(old
, old_path
.dentry
, CL_COPY_MNT_NS_FILE
);
2627 mnt
= clone_mnt(old
, old_path
.dentry
, 0);
2634 #ifdef CONFIG_RKP_NS_PROT
2635 rkp_reset_mnt_flags(mnt
->mnt
,MNT_LOCKED
);
2637 mnt
->mnt
.mnt_flags
&= ~MNT_LOCKED
;
2639 err
= graft_tree(mnt
, parent
, mp
);
2642 umount_tree(mnt
, UMOUNT_SYNC
);
2643 unlock_mount_hash();
2648 path_put(&old_path
);
2652 static int change_mount_flags(struct vfsmount
*mnt
, int ms_flags
)
2655 int readonly_request
= 0;
2657 if (ms_flags
& MS_RDONLY
)
2658 readonly_request
= 1;
2659 if (readonly_request
== __mnt_is_readonly(mnt
))
2662 if (readonly_request
)
2663 error
= mnt_make_readonly(real_mount(mnt
));
2665 __mnt_unmake_readonly(real_mount(mnt
));
2670 * change filesystem flags. dir should be a physical root of filesystem.
2671 * If you've mounted a non-root directory somewhere and want to do remount
2672 * on it - tough luck.
2674 static int do_remount(struct path
*path
, int flags
, int mnt_flags
,
2678 struct super_block
*sb
= path
->mnt
->mnt_sb
;
2679 struct mount
*mnt
= real_mount(path
->mnt
);
2681 if (!check_mnt(mnt
))
2684 if (path
->dentry
!= path
->mnt
->mnt_root
)
2687 /* Don't allow changing of locked mnt flags.
2689 * No locks need to be held here while testing the various
2690 * MNT_LOCK flags because those flags can never be cleared
2691 * once they are set.
2693 #ifdef CONFIG_RKP_NS_PROT
2694 if ((mnt
->mnt
->mnt_flags
& MNT_LOCK_READONLY
) &&
2696 if ((mnt
->mnt
.mnt_flags
& MNT_LOCK_READONLY
) &&
2698 !(mnt_flags
& MNT_READONLY
)) {
2701 #ifdef CONFIG_RKP_NS_PROT
2702 if ((mnt
->mnt
->mnt_flags
& MNT_LOCK_NODEV
) &&
2704 if ((mnt
->mnt
.mnt_flags
& MNT_LOCK_NODEV
) &&
2706 !(mnt_flags
& MNT_NODEV
)) {
2707 /* Was the nodev implicitly added in mount? */
2708 if ((mnt
->mnt_ns
->user_ns
!= &init_user_ns
) &&
2709 !(sb
->s_type
->fs_flags
& FS_USERNS_DEV_MOUNT
)) {
2710 mnt_flags
|= MNT_NODEV
;
2716 #ifdef CONFIG_RKP_NS_PROT
2717 if ((mnt
->mnt
->mnt_flags
& MNT_LOCK_NOSUID
) &&
2719 if ((mnt
->mnt
.mnt_flags
& MNT_LOCK_NOSUID
) &&
2721 !(mnt_flags
& MNT_NOSUID
)) {
2724 #ifdef CONFIG_RKP_NS_PROT
2725 if ((mnt
->mnt
->mnt_flags
& MNT_LOCK_NOEXEC
) &&
2727 if ((mnt
->mnt
.mnt_flags
& MNT_LOCK_NOEXEC
) &&
2729 !(mnt_flags
& MNT_NOEXEC
)) {
2732 #ifdef CONFIG_RKP_NS_PROT
2733 if ((mnt
->mnt
->mnt_flags
& MNT_LOCK_ATIME
) &&
2734 ((mnt
->mnt
->mnt_flags
& MNT_ATIME_MASK
) != (mnt_flags
& MNT_ATIME_MASK
))) {
2736 if ((mnt
->mnt
.mnt_flags
& MNT_LOCK_ATIME
) &&
2737 ((mnt
->mnt
.mnt_flags
& MNT_ATIME_MASK
) != (mnt_flags
& MNT_ATIME_MASK
))) {
2742 err
= security_sb_remount(sb
, data
);
2746 down_write(&sb
->s_umount
);
2747 if (flags
& MS_BIND
)
2748 err
= change_mount_flags(path
->mnt
, flags
);
2749 else if (!capable(CAP_SYS_ADMIN
))
2752 err
= do_remount_sb2(path
->mnt
, sb
, flags
, data
, 0);
2755 propagate_remount(mnt
);
2756 unlock_mount_hash();
2761 #ifdef CONFIG_RKP_NS_PROT
2762 mnt_flags
|= mnt
->mnt
->mnt_flags
& ~MNT_USER_SETTABLE_MASK
;
2763 rkp_assign_mnt_flags(mnt
->mnt
,mnt_flags
);
2765 mnt_flags
|= mnt
->mnt
.mnt_flags
& ~MNT_USER_SETTABLE_MASK
;
2766 mnt
->mnt
.mnt_flags
= mnt_flags
;
2768 touch_mnt_namespace(mnt
->mnt_ns
);
2769 unlock_mount_hash();
2771 up_write(&sb
->s_umount
);
2775 static inline int tree_contains_unbindable(struct mount
*mnt
)
2778 for (p
= mnt
; p
; p
= next_mnt(p
, mnt
)) {
2779 if (IS_MNT_UNBINDABLE(p
))
2785 static int do_move_mount(struct path
*path
, const char *old_name
)
2787 struct path old_path
, parent_path
;
2790 struct mountpoint
*mp
;
2792 if (!old_name
|| !*old_name
)
2794 err
= kern_path(old_name
, LOOKUP_FOLLOW
, &old_path
);
2798 mp
= lock_mount(path
);
2803 old
= real_mount(old_path
.mnt
);
2804 p
= real_mount(path
->mnt
);
2807 if (!check_mnt(p
) || !check_mnt(old
))
2810 #ifdef CONFIG_RKP_NS_PROT
2811 if (old
->mnt
->mnt_flags
& MNT_LOCKED
)
2814 if (old
->mnt
.mnt_flags
& MNT_LOCKED
)
2818 if (old_path
.dentry
!= old_path
.mnt
->mnt_root
)
2821 if (!mnt_has_parent(old
))
2824 if (d_is_dir(path
->dentry
) !=
2825 d_is_dir(old_path
.dentry
))
2828 * Don't move a mount residing in a shared parent.
2830 if (IS_MNT_SHARED(old
->mnt_parent
))
2833 * Don't move a mount tree containing unbindable mounts to a destination
2834 * mount which is shared.
2836 if (IS_MNT_SHARED(p
) && tree_contains_unbindable(old
))
2839 for (; mnt_has_parent(p
); p
= p
->mnt_parent
)
2843 err
= attach_recursive_mnt(old
, real_mount(path
->mnt
), mp
, &parent_path
);
2847 /* if the mount is moved, it should no longer be expire
2849 list_del_init(&old
->mnt_expire
);
2854 path_put(&parent_path
);
2855 path_put(&old_path
);
2859 static struct vfsmount
*fs_set_subtype(struct vfsmount
*mnt
, const char *fstype
)
2862 const char *subtype
= strchr(fstype
, '.');
2871 mnt
->mnt_sb
->s_subtype
= kstrdup(subtype
, GFP_KERNEL
);
2873 if (!mnt
->mnt_sb
->s_subtype
)
2879 return ERR_PTR(err
);
2883 * add a mount into a namespace's mount tree
2885 static int do_add_mount(struct mount
*newmnt
, struct path
*path
, int mnt_flags
)
2887 struct mountpoint
*mp
;
2888 struct mount
*parent
;
2891 mnt_flags
&= ~MNT_INTERNAL_FLAGS
;
2893 mp
= lock_mount(path
);
2897 parent
= real_mount(path
->mnt
);
2899 if (unlikely(!check_mnt(parent
))) {
2900 /* that's acceptable only for automounts done in private ns */
2901 if (!(mnt_flags
& MNT_SHRINKABLE
))
2903 /* ... and for those we'd better have mountpoint still alive */
2904 if (!parent
->mnt_ns
)
2908 /* Refuse the same filesystem on the same mount point */
2910 #ifdef CONFIG_RKP_NS_PROT
2911 if (path
->mnt
->mnt_sb
== newmnt
->mnt
->mnt_sb
&&
2913 if (path
->mnt
->mnt_sb
== newmnt
->mnt
.mnt_sb
&&
2915 path
->mnt
->mnt_root
== path
->dentry
)
2919 #ifdef CONFIG_RKP_NS_PROT
2920 if (d_is_symlink(newmnt
->mnt
->mnt_root
))
2922 if (d_is_symlink(newmnt
->mnt
.mnt_root
))
2926 #ifdef CONFIG_RKP_NS_PROT
2927 rkp_assign_mnt_flags(newmnt
->mnt
,mnt_flags
);
2929 newmnt
->mnt
.mnt_flags
= mnt_flags
;
2931 err
= graft_tree(newmnt
, parent
, mp
);
2938 static bool fs_fully_visible(struct file_system_type
*fs_type
, int *new_mnt_flags
);
2941 * create a new mount for userspace and request it to be added into the
2944 #ifdef CONFIG_RKP_NS_PROT
2945 static int do_new_mount(const char __user
*dir_name
,struct path
*path
, const char *fstype
, int flags
,
2946 int mnt_flags
, const char *name
, void *data
)
2948 static int do_new_mount(struct path
*path
, const char *fstype
, int flags
,
2949 int mnt_flags
, const char *name
, void *data
)
2952 struct file_system_type
*type
;
2953 struct user_namespace
*user_ns
= current
->nsproxy
->mnt_ns
->user_ns
;
2954 struct vfsmount
*mnt
;
2960 type
= get_fs_type(fstype
);
2964 if (user_ns
!= &init_user_ns
) {
2965 /* Only in special cases allow devices from mounts
2966 * created outside the initial user namespace.
2968 if (!(type
->fs_flags
& FS_USERNS_DEV_MOUNT
)) {
2970 mnt_flags
|= MNT_NODEV
| MNT_LOCK_NODEV
;
2972 if (type
->fs_flags
& FS_USERNS_VISIBLE
) {
2973 if (!fs_fully_visible(type
, &mnt_flags
)) {
2974 put_filesystem(type
);
2980 mnt
= vfs_kern_mount(type
, flags
, name
, data
);
2981 if (!IS_ERR(mnt
) && (type
->fs_flags
& FS_HAS_SUBTYPE
) &&
2982 !mnt
->mnt_sb
->s_subtype
)
2983 mnt
= fs_set_subtype(mnt
, fstype
);
2985 put_filesystem(type
);
2987 return PTR_ERR(mnt
);
2989 err
= do_add_mount(real_mount(mnt
), path
, mnt_flags
);
2992 #ifdef CONFIG_RKP_NS_PROT
2996 mount_point
= copy_mount_string(dir_name
);
2997 if(!strcmp(mount_point
,"/system")) {
2998 rkp_call(RKP_CMDID(0x55),(u64
)&sys_sb
,(u64
)mnt
,0,0,0);
3007 int finish_automount(struct vfsmount
*m
, struct path
*path
)
3009 struct mount
*mnt
= real_mount(m
);
3011 /* The new mount record should have at least 2 refs to prevent it being
3012 * expired before we get a chance to add it
3014 BUG_ON(mnt_get_count(mnt
) < 2);
3016 if (m
->mnt_sb
== path
->mnt
->mnt_sb
&&
3017 m
->mnt_root
== path
->dentry
) {
3022 err
= do_add_mount(mnt
, path
, path
->mnt
->mnt_flags
| MNT_SHRINKABLE
);
3026 /* remove m from any expiration list it may be on */
3027 if (!list_empty(&mnt
->mnt_expire
)) {
3029 list_del_init(&mnt
->mnt_expire
);
3038 * mnt_set_expiry - Put a mount on an expiration list
3039 * @mnt: The mount to list.
3040 * @expiry_list: The list to add the mount to.
3042 void mnt_set_expiry(struct vfsmount
*mnt
, struct list_head
*expiry_list
)
3046 list_add_tail(&real_mount(mnt
)->mnt_expire
, expiry_list
);
3050 EXPORT_SYMBOL(mnt_set_expiry
);
3053 * process a list of expirable mountpoints with the intent of discarding any
3054 * mountpoints that aren't in use and haven't been touched since last we came
3057 void mark_mounts_for_expiry(struct list_head
*mounts
)
3059 struct mount
*mnt
, *next
;
3060 LIST_HEAD(graveyard
);
3062 if (list_empty(mounts
))
3068 /* extract from the expiration list every vfsmount that matches the
3069 * following criteria:
3070 * - only referenced by its parent vfsmount
3071 * - still marked for expiry (marked on the last call here; marks are
3072 * cleared by mntput())
3074 list_for_each_entry_safe(mnt
, next
, mounts
, mnt_expire
) {
3075 if (!xchg(&mnt
->mnt_expiry_mark
, 1) ||
3076 propagate_mount_busy(mnt
, 1))
3078 list_move(&mnt
->mnt_expire
, &graveyard
);
3080 while (!list_empty(&graveyard
)) {
3081 mnt
= list_first_entry(&graveyard
, struct mount
, mnt_expire
);
3082 touch_mnt_namespace(mnt
->mnt_ns
);
3083 umount_tree(mnt
, UMOUNT_PROPAGATE
|UMOUNT_SYNC
);
3085 unlock_mount_hash();
3089 EXPORT_SYMBOL_GPL(mark_mounts_for_expiry
);
3092 * Ripoff of 'select_parent()'
3094 * search the list of submounts for a given mountpoint, and move any
3095 * shrinkable submounts to the 'graveyard' list.
3097 static int select_submounts(struct mount
*parent
, struct list_head
*graveyard
)
3099 struct mount
*this_parent
= parent
;
3100 struct list_head
*next
;
3104 next
= this_parent
->mnt_mounts
.next
;
3106 while (next
!= &this_parent
->mnt_mounts
) {
3107 struct list_head
*tmp
= next
;
3108 struct mount
*mnt
= list_entry(tmp
, struct mount
, mnt_child
);
3111 #ifdef CONFIG_RKP_NS_PROT
3112 if (!(mnt
->mnt
->mnt_flags
& MNT_SHRINKABLE
))
3114 if (!(mnt
->mnt
.mnt_flags
& MNT_SHRINKABLE
))
3118 * Descend a level if the d_mounts list is non-empty.
3120 if (!list_empty(&mnt
->mnt_mounts
)) {
3125 if (!propagate_mount_busy(mnt
, 1)) {
3126 list_move_tail(&mnt
->mnt_expire
, graveyard
);
3131 * All done at this level ... ascend and resume the search
3133 if (this_parent
!= parent
) {
3134 next
= this_parent
->mnt_child
.next
;
3135 this_parent
= this_parent
->mnt_parent
;
3142 * process a list of expirable mountpoints with the intent of discarding any
3143 * submounts of a specific parent mountpoint
3145 * mount_lock must be held for write
3147 static void shrink_submounts(struct mount
*mnt
)
3149 LIST_HEAD(graveyard
);
3152 /* extract submounts of 'mountpoint' from the expiration list */
3153 while (select_submounts(mnt
, &graveyard
)) {
3154 while (!list_empty(&graveyard
)) {
3155 m
= list_first_entry(&graveyard
, struct mount
,
3157 touch_mnt_namespace(m
->mnt_ns
);
3158 umount_tree(m
, UMOUNT_PROPAGATE
|UMOUNT_SYNC
);
3164 * Some copy_from_user() implementations do not return the exact number of
3165 * bytes remaining to copy on a fault. But copy_mount_options() requires that.
3166 * Note that this function differs from copy_from_user() in that it will oops
3167 * on bad values of `to', rather than returning a short copy.
3169 static long exact_copy_from_user(void *to
, const void __user
* from
,
3173 const char __user
*f
= from
;
3176 if (!access_ok(VERIFY_READ
, from
, n
))
3180 if (__get_user(c
, f
)) {
3191 int copy_mount_options(const void __user
* data
, unsigned long *where
)
3201 if (!(page
= __get_free_page(GFP_KERNEL
)))
3204 /* We only care that *some* data at the address the user
3205 * gave us is valid. Just in case, we'll zero
3206 * the remainder of the page.
3208 /* copy_from_user cannot cross TASK_SIZE ! */
3209 size
= TASK_SIZE
- (unsigned long)data
;
3210 if (size
> PAGE_SIZE
)
3213 i
= size
- exact_copy_from_user((void *)page
, data
, size
);
3219 memset((char *)page
+ i
, 0, PAGE_SIZE
- i
);
3224 char *copy_mount_string(const void __user
*data
)
3226 return data
? strndup_user(data
, PAGE_SIZE
) : NULL
;
3230 * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to
3231 * be given to the mount() call (ie: read-only, no-dev, no-suid etc).
3233 * data is a (void *) that can point to any structure up to
3234 * PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent
3235 * information (or be NULL).
3237 * Pre-0.97 versions of mount() didn't have a flags word.
3238 * When the flags word was introduced its top half was required
3239 * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9.
3240 * Therefore, if this magic number is present, it carries no information
3241 * and must be discarded.
3243 long do_mount(const char *dev_name
, const char __user
*dir_name
,
3244 const char *type_page
, unsigned long flags
, void *data_page
)
3251 if ((flags
& MS_MGC_MSK
) == MS_MGC_VAL
)
3252 flags
&= ~MS_MGC_MSK
;
3254 /* Basic sanity checks */
3256 ((char *)data_page
)[PAGE_SIZE
- 1] = 0;
3258 /* ... and get the mountpoint */
3259 retval
= user_path(dir_name
, &path
);
3263 retval
= security_sb_mount(dev_name
, &path
,
3264 type_page
, flags
, data_page
);
3265 if (!retval
&& !may_mount())
3270 /* Default to relatime unless overriden */
3271 if (!(flags
& MS_NOATIME
))
3272 mnt_flags
|= MNT_RELATIME
;
3274 /* Separate the per-mountpoint flags */
3275 if (flags
& MS_NOSUID
)
3276 mnt_flags
|= MNT_NOSUID
;
3277 if (flags
& MS_NODEV
)
3278 mnt_flags
|= MNT_NODEV
;
3279 if (flags
& MS_NOEXEC
)
3280 mnt_flags
|= MNT_NOEXEC
;
3281 if (flags
& MS_NOATIME
)
3282 mnt_flags
|= MNT_NOATIME
;
3283 if (flags
& MS_NODIRATIME
)
3284 mnt_flags
|= MNT_NODIRATIME
;
3285 if (flags
& MS_STRICTATIME
)
3286 mnt_flags
&= ~(MNT_RELATIME
| MNT_NOATIME
);
3287 if (flags
& MS_RDONLY
)
3288 mnt_flags
|= MNT_READONLY
;
3290 /* The default atime for remount is preservation */
3291 if ((flags
& MS_REMOUNT
) &&
3292 ((flags
& (MS_NOATIME
| MS_NODIRATIME
| MS_RELATIME
|
3293 MS_STRICTATIME
)) == 0)) {
3294 mnt_flags
&= ~MNT_ATIME_MASK
;
3295 mnt_flags
|= path
.mnt
->mnt_flags
& MNT_ATIME_MASK
;
3298 flags
&= ~(MS_NOSUID
| MS_NOEXEC
| MS_NODEV
| MS_ACTIVE
| MS_BORN
|
3299 MS_NOATIME
| MS_NODIRATIME
| MS_RELATIME
| MS_KERNMOUNT
|
3302 if (flags
& MS_REMOUNT
)
3303 retval
= do_remount(&path
, flags
& ~MS_REMOUNT
, mnt_flags
,
3305 else if (flags
& MS_BIND
)
3306 retval
= do_loopback(&path
, dev_name
, flags
& MS_REC
);
3307 else if (flags
& (MS_SHARED
| MS_PRIVATE
| MS_SLAVE
| MS_UNBINDABLE
))
3308 retval
= do_change_type(&path
, flags
);
3309 else if (flags
& MS_MOVE
)
3310 retval
= do_move_mount(&path
, dev_name
);
3312 #ifdef CONFIG_RKP_NS_PROT
3313 retval
= do_new_mount(dir_name
,&path
, type_page
, flags
, mnt_flags
,
3314 dev_name
, data_page
);
3316 retval
= do_new_mount(&path
, type_page
, flags
, mnt_flags
,
3317 dev_name
, data_page
);
3324 static void free_mnt_ns(struct mnt_namespace
*ns
)
3326 ns_free_inum(&ns
->ns
);
3327 put_user_ns(ns
->user_ns
);
3332 * Assign a sequence number so we can detect when we attempt to bind
3333 * mount a reference to an older mount namespace into the current
3334 * mount namespace, preventing reference counting loops. A 64bit
3335 * number incrementing at 10Ghz will take 12,427 years to wrap which
3336 * is effectively never, so we can ignore the possibility.
3338 static atomic64_t mnt_ns_seq
= ATOMIC64_INIT(1);
3340 static struct mnt_namespace
*alloc_mnt_ns(struct user_namespace
*user_ns
)
3342 struct mnt_namespace
*new_ns
;
3345 new_ns
= kmalloc(sizeof(struct mnt_namespace
), GFP_KERNEL
);
3347 return ERR_PTR(-ENOMEM
);
3348 ret
= ns_alloc_inum(&new_ns
->ns
);
3351 return ERR_PTR(ret
);
3353 new_ns
->ns
.ops
= &mntns_operations
;
3354 new_ns
->seq
= atomic64_add_return(1, &mnt_ns_seq
);
3355 atomic_set(&new_ns
->count
, 1);
3356 new_ns
->root
= NULL
;
3357 INIT_LIST_HEAD(&new_ns
->list
);
3358 init_waitqueue_head(&new_ns
->poll
);
3360 new_ns
->user_ns
= get_user_ns(user_ns
);
3362 new_ns
->pending_mounts
= 0;
3366 struct mnt_namespace
*copy_mnt_ns(unsigned long flags
, struct mnt_namespace
*ns
,
3367 struct user_namespace
*user_ns
, struct fs_struct
*new_fs
)
3369 struct mnt_namespace
*new_ns
;
3370 struct vfsmount
*rootmnt
= NULL
, *pwdmnt
= NULL
;
3371 struct mount
*p
, *q
;
3378 if (likely(!(flags
& CLONE_NEWNS
))) {
3385 new_ns
= alloc_mnt_ns(user_ns
);
3390 /* First pass: copy the tree topology */
3391 copy_flags
= CL_COPY_UNBINDABLE
| CL_EXPIRE
;
3392 if (user_ns
!= ns
->user_ns
)
3393 copy_flags
|= CL_SHARED_TO_SLAVE
| CL_UNPRIVILEGED
;
3394 #ifdef CONFIG_RKP_NS_PROT
3395 new = copy_tree(old
, old
->mnt
->mnt_root
, copy_flags
);
3397 new = copy_tree(old
, old
->mnt
.mnt_root
, copy_flags
);
3401 free_mnt_ns(new_ns
);
3402 return ERR_CAST(new);
3405 list_add_tail(&new_ns
->list
, &new->mnt_list
);
3408 * Second pass: switch the tsk->fs->* elements and mark new vfsmounts
3409 * as belonging to new namespace. We have already acquired a private
3410 * fs_struct, so tsk->fs->lock is not needed.
3418 #ifdef CONFIG_RKP_NS_PROT
3419 if (p
->mnt
== new_fs
->root
.mnt
) {
3420 new_fs
->root
.mnt
= mntget(q
->mnt
);
3423 if (p
->mnt
== new_fs
->pwd
.mnt
) {
3424 new_fs
->pwd
.mnt
= mntget(q
->mnt
);
3429 if (&p
->mnt
== new_fs
->root
.mnt
) {
3430 new_fs
->root
.mnt
= mntget(&q
->mnt
);
3433 if (&p
->mnt
== new_fs
->pwd
.mnt
) {
3434 new_fs
->pwd
.mnt
= mntget(&q
->mnt
);
3439 p
= next_mnt(p
, old
);
3440 q
= next_mnt(q
, new);
3443 #ifdef CONFIG_RKP_NS_PROT
3444 while (p
->mnt
->mnt_root
!= q
->mnt
->mnt_root
)
3446 while (p
->mnt
.mnt_root
!= q
->mnt
.mnt_root
)
3448 p
= next_mnt(p
, old
);
3461 * create_mnt_ns - creates a private namespace and adds a root filesystem
3462 * @mnt: pointer to the new root filesystem mountpoint
3464 static struct mnt_namespace
*create_mnt_ns(struct vfsmount
*m
)
3466 struct mnt_namespace
*new_ns
= alloc_mnt_ns(&init_user_ns
);
3467 if (!IS_ERR(new_ns
)) {
3468 struct mount
*mnt
= real_mount(m
);
3469 mnt
->mnt_ns
= new_ns
;
3472 list_add(&mnt
->mnt_list
, &new_ns
->list
);
3479 struct dentry
*mount_subtree(struct vfsmount
*mnt
, const char *name
)
3481 struct mnt_namespace
*ns
;
3482 struct super_block
*s
;
3486 ns
= create_mnt_ns(mnt
);
3488 return ERR_CAST(ns
);
3490 err
= vfs_path_lookup(mnt
->mnt_root
, mnt
,
3491 name
, LOOKUP_FOLLOW
|LOOKUP_AUTOMOUNT
, &path
);
3496 return ERR_PTR(err
);
3498 /* trade a vfsmount reference for active sb one */
3499 s
= path
.mnt
->mnt_sb
;
3500 atomic_inc(&s
->s_active
);
3502 /* lock the sucker */
3503 down_write(&s
->s_umount
);
3504 /* ... and return the root of (sub)tree on it */
3507 EXPORT_SYMBOL(mount_subtree
);
3509 SYSCALL_DEFINE5(mount
, char __user
*, dev_name
, char __user
*, dir_name
,
3510 char __user
*, type
, unsigned long, flags
, void __user
*, data
)
3515 unsigned long data_page
;
3517 kernel_type
= copy_mount_string(type
);
3518 ret
= PTR_ERR(kernel_type
);
3519 if (IS_ERR(kernel_type
))
3522 kernel_dev
= copy_mount_string(dev_name
);
3523 ret
= PTR_ERR(kernel_dev
);
3524 if (IS_ERR(kernel_dev
))
3527 ret
= copy_mount_options(data
, &data_page
);
3531 ret
= do_mount(kernel_dev
, dir_name
, kernel_type
, flags
,
3532 (void *) data_page
);
3534 free_page(data_page
);
3544 * Return true if path is reachable from root
3546 * namespace_sem or mount_lock is held
3548 bool is_path_reachable(struct mount
*mnt
, struct dentry
*dentry
,
3549 const struct path
*root
)
3551 #ifdef CONFIG_RKP_NS_PROT
3552 while (mnt
->mnt
!= root
->mnt
&& mnt_has_parent(mnt
)) {
3554 while (&mnt
->mnt
!= root
->mnt
&& mnt_has_parent(mnt
)) {
3556 dentry
= mnt
->mnt_mountpoint
;
3557 mnt
= mnt
->mnt_parent
;
3559 #ifdef CONFIG_RKP_NS_PROT
3560 return mnt
->mnt
== root
->mnt
&& is_subdir(dentry
, root
->dentry
);
3562 return &mnt
->mnt
== root
->mnt
&& is_subdir(dentry
, root
->dentry
);
3566 int path_is_under(struct path
*path1
, struct path
*path2
)
3569 read_seqlock_excl(&mount_lock
);
3570 res
= is_path_reachable(real_mount(path1
->mnt
), path1
->dentry
, path2
);
3571 read_sequnlock_excl(&mount_lock
);
3574 EXPORT_SYMBOL(path_is_under
);
3577 * pivot_root Semantics:
3578 * Moves the root file system of the current process to the directory put_old,
3579 * makes new_root as the new root file system of the current process, and sets
3580 * root/cwd of all processes which had them on the current root to new_root.
3583 * The new_root and put_old must be directories, and must not be on the
3584 * same file system as the current process root. The put_old must be
3585 * underneath new_root, i.e. adding a non-zero number of /.. to the string
3586 * pointed to by put_old must yield the same directory as new_root. No other
3587 * file system may be mounted on put_old. After all, new_root is a mountpoint.
3589 * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem.
3590 * See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives
3591 * in this situation.
3594 * - we don't move root/cwd if they are not at the root (reason: if something
3595 * cared enough to change them, it's probably wrong to force them elsewhere)
3596 * - it's okay to pick a root that isn't the root of a file system, e.g.
3597 * /nfs/my_root where /nfs is the mount point. It must be a mountpoint,
3598 * though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
3601 SYSCALL_DEFINE2(pivot_root
, const char __user
*, new_root
,
3602 const char __user
*, put_old
)
3604 struct path
new, old
, parent_path
, root_parent
, root
;
3605 struct mount
*new_mnt
, *root_mnt
, *old_mnt
;
3606 struct mountpoint
*old_mp
, *root_mp
;
3612 error
= user_path_dir(new_root
, &new);
3616 error
= user_path_dir(put_old
, &old
);
3620 error
= security_sb_pivotroot(&old
, &new);
3624 get_fs_root(current
->fs
, &root
);
3625 old_mp
= lock_mount(&old
);
3626 error
= PTR_ERR(old_mp
);
3631 new_mnt
= real_mount(new.mnt
);
3632 root_mnt
= real_mount(root
.mnt
);
3633 old_mnt
= real_mount(old
.mnt
);
3634 if (IS_MNT_SHARED(old_mnt
) ||
3635 IS_MNT_SHARED(new_mnt
->mnt_parent
) ||
3636 IS_MNT_SHARED(root_mnt
->mnt_parent
))
3638 if (!check_mnt(root_mnt
) || !check_mnt(new_mnt
))
3640 #ifdef CONFIG_RKP_NS_PROT
3641 if (new_mnt
->mnt
->mnt_flags
& MNT_LOCKED
)
3643 if (new_mnt
->mnt
.mnt_flags
& MNT_LOCKED
)
3647 if (d_unlinked(new.dentry
))
3650 if (new_mnt
== root_mnt
|| old_mnt
== root_mnt
)
3651 goto out4
; /* loop, on the same file system */
3653 if (root
.mnt
->mnt_root
!= root
.dentry
)
3654 goto out4
; /* not a mountpoint */
3655 if (!mnt_has_parent(root_mnt
))
3656 goto out4
; /* not attached */
3657 root_mp
= root_mnt
->mnt_mp
;
3658 if (new.mnt
->mnt_root
!= new.dentry
)
3659 goto out4
; /* not a mountpoint */
3660 if (!mnt_has_parent(new_mnt
))
3661 goto out4
; /* not attached */
3662 /* make sure we can reach put_old from new_root */
3663 if (!is_path_reachable(old_mnt
, old
.dentry
, &new))
3665 /* make certain new is below the root */
3666 if (!is_path_reachable(new_mnt
, new.dentry
, &root
))
3668 root_mp
->m_count
++; /* pin it so it won't go away */
3670 detach_mnt(new_mnt
, &parent_path
);
3671 detach_mnt(root_mnt
, &root_parent
);
3672 #ifdef CONFIG_RKP_NS_PROT
3673 if (root_mnt
->mnt
->mnt_flags
& MNT_LOCKED
) {
3674 rkp_set_mnt_flags(new_mnt
->mnt
,MNT_LOCKED
);
3675 rkp_reset_mnt_flags(root_mnt
->mnt
,MNT_LOCKED
);
3678 if (root_mnt
->mnt
.mnt_flags
& MNT_LOCKED
) {
3679 new_mnt
->mnt
.mnt_flags
|= MNT_LOCKED
;
3680 root_mnt
->mnt
.mnt_flags
&= ~MNT_LOCKED
;
3683 /* mount old root on put_old */
3684 attach_mnt(root_mnt
, old_mnt
, old_mp
);
3685 /* mount new_root on / */
3686 attach_mnt(new_mnt
, real_mount(root_parent
.mnt
), root_mp
);
3687 touch_mnt_namespace(current
->nsproxy
->mnt_ns
);
3688 /* A moved mount should not expire automatically */
3689 list_del_init(&new_mnt
->mnt_expire
);
3690 put_mountpoint(root_mp
);
3691 unlock_mount_hash();
3692 chroot_fs_refs(&root
, &new);
3695 unlock_mount(old_mp
);
3697 path_put(&root_parent
);
3698 path_put(&parent_path
);
3710 static void __init
init_mount_tree(void)
3712 struct vfsmount
*mnt
;
3713 struct mnt_namespace
*ns
;
3715 struct file_system_type
*type
;
3717 type
= get_fs_type("rootfs");
3719 panic("Can't find rootfs type");
3720 mnt
= vfs_kern_mount(type
, 0, "rootfs", NULL
);
3721 put_filesystem(type
);
3723 panic("Can't create rootfs");
3724 #ifdef CONFIG_RKP_NS_PROT
3726 rkp_call(RKP_CMDID(0x55),(u64
)&rootfs_sb
,(u64
)mnt
,0,0,0);
3729 ns
= create_mnt_ns(mnt
);
3731 panic("Can't allocate initial namespace");
3733 init_task
.nsproxy
->mnt_ns
= ns
;
3737 root
.dentry
= mnt
->mnt_root
;
3738 #ifdef CONFIG_RKP_NS_PROT
3739 rkp_set_mnt_flags(mnt
,MNT_LOCKED
);
3741 mnt
->mnt_flags
|= MNT_LOCKED
;
3743 set_fs_pwd(current
->fs
, &root
);
3744 set_fs_root(current
->fs
, &root
);
3746 #ifdef CONFIG_RKP_NS_PROT
3747 void cred_ctor_vfsmount(void *data
)
3749 /* Dummy constructor to make sure we have separate slabs caches. */
3753 void __init
mnt_init(void)
3757 #ifdef CONFIG_RKP_NS_PROT
3758 struct vfsmount_offset voff
;
3760 mnt_cache
= kmem_cache_create("mnt_cache", sizeof(struct mount
),
3761 0, SLAB_HWCACHE_ALIGN
| SLAB_PANIC
, NULL
);
3763 #ifdef CONFIG_RKP_NS_PROT
3764 vfsmnt_cache
= kmem_cache_create("vfsmnt_cache", sizeof(struct vfsmount
),
3765 0, SLAB_HWCACHE_ALIGN
| SLAB_PANIC
, cred_ctor_vfsmount
);
3768 panic("Failed to allocate vfsmnt_cache \n");
3769 voff
.bp_mount_offset
= (u64
)offsetof(struct vfsmount
, bp_mount
);
3770 voff
.mnt_sb_offset
= (u64
)offsetof(struct vfsmount
, mnt_sb
);
3771 voff
.mnt_flags_offset
= (u64
)offsetof(struct vfsmount
, mnt_flags
);
3772 voff
.data_offset
= (u64
)offsetof(struct vfsmount
, data
);
3774 rkp_call(RKP_CMDID(0x41), (u64
)vfsmnt_cache
->size
, (u64
)sizeof(struct vfsmount
),
3778 mount_hashtable
= alloc_large_system_hash("Mount-cache",
3779 sizeof(struct hlist_head
),
3782 &m_hash_shift
, &m_hash_mask
, 0, 0);
3783 mountpoint_hashtable
= alloc_large_system_hash("Mountpoint-cache",
3784 sizeof(struct hlist_head
),
3787 &mp_hash_shift
, &mp_hash_mask
, 0, 0);
3789 if (!mount_hashtable
|| !mountpoint_hashtable
)
3790 panic("Failed to allocate mount hash table\n");
3792 for (u
= 0; u
<= m_hash_mask
; u
++)
3793 INIT_HLIST_HEAD(&mount_hashtable
[u
]);
3794 for (u
= 0; u
<= mp_hash_mask
; u
++)
3795 INIT_HLIST_HEAD(&mountpoint_hashtable
[u
]);
3801 printk(KERN_WARNING
"%s: sysfs_init error: %d\n",
3803 fs_kobj
= kobject_create_and_add("fs", NULL
);
3805 printk(KERN_WARNING
"%s: kobj create error\n", __func__
);
3810 void put_mnt_ns(struct mnt_namespace
*ns
)
3812 if (!atomic_dec_and_test(&ns
->count
))
3814 #ifdef CONFIG_RKP_NS_PROT
3815 drop_collected_mounts(ns
->root
->mnt
);
3817 drop_collected_mounts(&ns
->root
->mnt
);
3822 struct vfsmount
*kern_mount_data(struct file_system_type
*type
, void *data
)
3824 struct vfsmount
*mnt
;
3825 mnt
= vfs_kern_mount(type
, MS_KERNMOUNT
, type
->name
, data
);
3828 * it is a longterm mount, don't release mnt until
3829 * we unmount before file sys is unregistered
3831 real_mount(mnt
)->mnt_ns
= MNT_NS_INTERNAL
;
3835 EXPORT_SYMBOL_GPL(kern_mount_data
);
3837 void kern_unmount(struct vfsmount
*mnt
)
3839 /* release long term mount so mount point can be released */
3840 if (!IS_ERR_OR_NULL(mnt
)) {
3841 real_mount(mnt
)->mnt_ns
= NULL
;
3842 synchronize_rcu(); /* yecchhh... */
3846 EXPORT_SYMBOL(kern_unmount
);
3848 bool our_mnt(struct vfsmount
*mnt
)
3850 return check_mnt(real_mount(mnt
));
3853 bool current_chrooted(void)
3855 /* Does the current process have a non-standard root */
3856 struct path ns_root
;
3857 struct path fs_root
;
3860 /* Find the namespace root */
3861 #ifdef CONFIG_RKP_NS_PROT
3862 ns_root
.mnt
= current
->nsproxy
->mnt_ns
->root
->mnt
;
3864 ns_root
.mnt
= ¤t
->nsproxy
->mnt_ns
->root
->mnt
;
3866 ns_root
.dentry
= ns_root
.mnt
->mnt_root
;
3868 while (d_mountpoint(ns_root
.dentry
) && follow_down_one(&ns_root
))
3871 get_fs_root(current
->fs
, &fs_root
);
3873 chrooted
= !path_equal(&fs_root
, &ns_root
);
3881 static bool fs_fully_visible(struct file_system_type
*type
, int *new_mnt_flags
)
3883 struct mnt_namespace
*ns
= current
->nsproxy
->mnt_ns
;
3884 int new_flags
= *new_mnt_flags
;
3886 bool visible
= false;
3891 down_read(&namespace_sem
);
3892 list_for_each_entry(mnt
, &ns
->list
, mnt_list
) {
3893 struct mount
*child
;
3896 #ifdef CONFIG_RKP_NS_PROT
3897 if (mnt
->mnt
->mnt_sb
->s_type
!= type
)
3900 /* This mount is not fully visible if it's root directory
3901 * is not the root directory of the filesystem.
3903 if (mnt
->mnt
->mnt_root
!= mnt
->mnt
->mnt_sb
->s_root
)
3906 /* Read the mount flags and filter out flags that
3907 * may safely be ignored.
3909 mnt_flags
= mnt
->mnt
->mnt_flags
;
3910 if (mnt
->mnt
->mnt_sb
->s_iflags
& SB_I_NOEXEC
)
3911 mnt_flags
&= ~(MNT_LOCK_NOSUID
| MNT_LOCK_NOEXEC
);
3913 /* Don't miss readonly hidden in the superblock flags */
3914 if (mnt
->mnt
->mnt_sb
->s_flags
& MS_RDONLY
)
3915 mnt_flags
|= MNT_LOCK_READONLY
;
3917 if (mnt
->mnt
.mnt_sb
->s_type
!= type
)
3920 /* This mount is not fully visible if it's root directory
3921 * is not the root directory of the filesystem.
3923 if (mnt
->mnt
.mnt_root
!= mnt
->mnt
.mnt_sb
->s_root
)
3926 /* Read the mount flags and filter out flags that
3927 * may safely be ignored.
3929 mnt_flags
= mnt
->mnt
.mnt_flags
;
3930 if (mnt
->mnt
.mnt_sb
->s_iflags
& SB_I_NOEXEC
)
3931 mnt_flags
&= ~(MNT_LOCK_NOSUID
| MNT_LOCK_NOEXEC
);
3933 /* Don't miss readonly hidden in the superblock flags */
3934 if (mnt
->mnt
.mnt_sb
->s_flags
& MS_RDONLY
)
3935 mnt_flags
|= MNT_LOCK_READONLY
;
3938 /* Verify the mount flags are equal to or more permissive
3939 * than the proposed new mount.
3941 if ((mnt_flags
& MNT_LOCK_READONLY
) &&
3942 !(new_flags
& MNT_READONLY
))
3944 if ((mnt_flags
& MNT_LOCK_NODEV
) &&
3945 !(new_flags
& MNT_NODEV
))
3947 if ((mnt_flags
& MNT_LOCK_NOSUID
) &&
3948 !(new_flags
& MNT_NOSUID
))
3950 if ((mnt_flags
& MNT_LOCK_NOEXEC
) &&
3951 !(new_flags
& MNT_NOEXEC
))
3953 if ((mnt_flags
& MNT_LOCK_ATIME
) &&
3954 ((mnt_flags
& MNT_ATIME_MASK
) != (new_flags
& MNT_ATIME_MASK
)))
3957 /* This mount is not fully visible if there are any
3958 * locked child mounts that cover anything except for
3959 * empty directories.
3961 list_for_each_entry(child
, &mnt
->mnt_mounts
, mnt_child
) {
3962 struct inode
*inode
= child
->mnt_mountpoint
->d_inode
;
3963 /* Only worry about locked mounts */
3964 #ifdef CONFIG_RKP_NS_PROT
3965 if (!(child
->mnt
->mnt_flags
& MNT_LOCKED
))
3967 if (!(child
->mnt
.mnt_flags
& MNT_LOCKED
))
3970 /* Is the directory permanetly empty? */
3971 if (!is_empty_dir_inode(inode
))
3974 /* Preserve the locked attributes */
3975 *new_mnt_flags
|= mnt_flags
& (MNT_LOCK_READONLY
| \
3985 up_read(&namespace_sem
);
3989 static struct ns_common
*mntns_get(struct task_struct
*task
)
3991 struct ns_common
*ns
= NULL
;
3992 struct nsproxy
*nsproxy
;
3995 nsproxy
= task
->nsproxy
;
3997 ns
= &nsproxy
->mnt_ns
->ns
;
3998 get_mnt_ns(to_mnt_ns(ns
));
4005 static void mntns_put(struct ns_common
*ns
)
4007 put_mnt_ns(to_mnt_ns(ns
));
4010 static int mntns_install(struct nsproxy
*nsproxy
, struct ns_common
*ns
)
4012 struct fs_struct
*fs
= current
->fs
;
4013 struct mnt_namespace
*mnt_ns
= to_mnt_ns(ns
);
4016 if (!ns_capable(mnt_ns
->user_ns
, CAP_SYS_ADMIN
) ||
4017 !ns_capable(current_user_ns(), CAP_SYS_CHROOT
) ||
4018 !ns_capable(current_user_ns(), CAP_SYS_ADMIN
))
4025 put_mnt_ns(nsproxy
->mnt_ns
);
4026 nsproxy
->mnt_ns
= mnt_ns
;
4029 #ifdef CONFIG_RKP_NS_PROT
4030 root
.mnt
= mnt_ns
->root
->mnt
;
4031 root
.dentry
= mnt_ns
->root
->mnt
->mnt_root
;
4033 root
.mnt
= &mnt_ns
->root
->mnt
;
4034 root
.dentry
= mnt_ns
->root
->mnt
.mnt_root
;
4037 while(d_mountpoint(root
.dentry
) && follow_down_one(&root
))
4040 /* Update the pwd and root */
4041 set_fs_pwd(fs
, &root
);
4042 set_fs_root(fs
, &root
);
4048 const struct proc_ns_operations mntns_operations
= {
4050 .type
= CLONE_NEWNS
,
4053 .install
= mntns_install
,