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/acct.h> /* acct_auto_close_mnt */
20 #include <linux/ramfs.h> /* init_rootfs */
21 #include <linux/fs_struct.h> /* get_fs_root et.al. */
22 #include <linux/fsnotify.h> /* fsnotify_vfsmount_delete */
23 #include <linux/uaccess.h>
24 #include <linux/proc_fs.h>
28 #define HASH_SHIFT ilog2(PAGE_SIZE / sizeof(struct list_head))
29 #define HASH_SIZE (1UL << HASH_SHIFT)
32 static DEFINE_IDA(mnt_id_ida
);
33 static DEFINE_IDA(mnt_group_ida
);
34 static DEFINE_SPINLOCK(mnt_id_lock
);
35 static int mnt_id_start
= 0;
36 static int mnt_group_start
= 1;
38 static struct list_head
*mount_hashtable __read_mostly
;
39 static struct kmem_cache
*mnt_cache __read_mostly
;
40 static struct rw_semaphore namespace_sem
;
43 struct kobject
*fs_kobj
;
44 EXPORT_SYMBOL_GPL(fs_kobj
);
47 * vfsmount lock may be taken for read to prevent changes to the
48 * vfsmount hash, ie. during mountpoint lookups or walking back
51 * It should be taken for write in all cases where the vfsmount
52 * tree or hash is modified or when a vfsmount structure is modified.
54 DEFINE_BRLOCK(vfsmount_lock
);
56 static inline unsigned long hash(struct vfsmount
*mnt
, struct dentry
*dentry
)
58 unsigned long tmp
= ((unsigned long)mnt
/ L1_CACHE_BYTES
);
59 tmp
+= ((unsigned long)dentry
/ L1_CACHE_BYTES
);
60 tmp
= tmp
+ (tmp
>> HASH_SHIFT
);
61 return tmp
& (HASH_SIZE
- 1);
64 #define MNT_WRITER_UNDERFLOW_LIMIT -(1<<16)
67 * allocation is serialized by namespace_sem, but we need the spinlock to
68 * serialize with freeing.
70 static int mnt_alloc_id(struct mount
*mnt
)
75 ida_pre_get(&mnt_id_ida
, GFP_KERNEL
);
76 spin_lock(&mnt_id_lock
);
77 res
= ida_get_new_above(&mnt_id_ida
, mnt_id_start
, &mnt
->mnt_id
);
79 mnt_id_start
= mnt
->mnt_id
+ 1;
80 spin_unlock(&mnt_id_lock
);
87 static void mnt_free_id(struct mount
*mnt
)
90 spin_lock(&mnt_id_lock
);
91 ida_remove(&mnt_id_ida
, id
);
92 if (mnt_id_start
> id
)
94 spin_unlock(&mnt_id_lock
);
98 * Allocate a new peer group ID
100 * mnt_group_ida is protected by namespace_sem
102 static int mnt_alloc_group_id(struct mount
*mnt
)
106 if (!ida_pre_get(&mnt_group_ida
, GFP_KERNEL
))
109 res
= ida_get_new_above(&mnt_group_ida
,
113 mnt_group_start
= mnt
->mnt_group_id
+ 1;
119 * Release a peer group ID
121 void mnt_release_group_id(struct mount
*mnt
)
123 int id
= mnt
->mnt_group_id
;
124 ida_remove(&mnt_group_ida
, id
);
125 if (mnt_group_start
> id
)
126 mnt_group_start
= id
;
127 mnt
->mnt_group_id
= 0;
131 * vfsmount lock must be held for read
133 static inline void mnt_add_count(struct mount
*mnt
, int n
)
136 this_cpu_add(mnt
->mnt_pcp
->mnt_count
, n
);
145 * vfsmount lock must be held for write
147 unsigned int mnt_get_count(struct mount
*mnt
)
150 unsigned int count
= 0;
153 for_each_possible_cpu(cpu
) {
154 count
+= per_cpu_ptr(mnt
->mnt_pcp
, cpu
)->mnt_count
;
159 return mnt
->mnt_count
;
163 static struct mount
*alloc_vfsmnt(const char *name
)
165 struct mount
*mnt
= kmem_cache_zalloc(mnt_cache
, GFP_KERNEL
);
169 err
= mnt_alloc_id(mnt
);
174 mnt
->mnt_devname
= kstrdup(name
, GFP_KERNEL
);
175 if (!mnt
->mnt_devname
)
180 mnt
->mnt_pcp
= alloc_percpu(struct mnt_pcp
);
182 goto out_free_devname
;
184 this_cpu_add(mnt
->mnt_pcp
->mnt_count
, 1);
187 mnt
->mnt_writers
= 0;
190 INIT_LIST_HEAD(&mnt
->mnt_hash
);
191 INIT_LIST_HEAD(&mnt
->mnt_child
);
192 INIT_LIST_HEAD(&mnt
->mnt_mounts
);
193 INIT_LIST_HEAD(&mnt
->mnt_list
);
194 INIT_LIST_HEAD(&mnt
->mnt_expire
);
195 INIT_LIST_HEAD(&mnt
->mnt_share
);
196 INIT_LIST_HEAD(&mnt
->mnt_slave_list
);
197 INIT_LIST_HEAD(&mnt
->mnt_slave
);
198 #ifdef CONFIG_FSNOTIFY
199 INIT_HLIST_HEAD(&mnt
->mnt_fsnotify_marks
);
206 kfree(mnt
->mnt_devname
);
211 kmem_cache_free(mnt_cache
, mnt
);
216 * Most r/o checks on a fs are for operations that take
217 * discrete amounts of time, like a write() or unlink().
218 * We must keep track of when those operations start
219 * (for permission checks) and when they end, so that
220 * we can determine when writes are able to occur to
224 * __mnt_is_readonly: check whether a mount is read-only
225 * @mnt: the mount to check for its write status
227 * This shouldn't be used directly ouside of the VFS.
228 * It does not guarantee that the filesystem will stay
229 * r/w, just that it is right *now*. This can not and
230 * should not be used in place of IS_RDONLY(inode).
231 * mnt_want/drop_write() will _keep_ the filesystem
234 int __mnt_is_readonly(struct vfsmount
*mnt
)
236 if (mnt
->mnt_flags
& MNT_READONLY
)
238 if (mnt
->mnt_sb
->s_flags
& MS_RDONLY
)
242 EXPORT_SYMBOL_GPL(__mnt_is_readonly
);
244 static inline void mnt_inc_writers(struct mount
*mnt
)
247 this_cpu_inc(mnt
->mnt_pcp
->mnt_writers
);
253 static inline void mnt_dec_writers(struct mount
*mnt
)
256 this_cpu_dec(mnt
->mnt_pcp
->mnt_writers
);
262 static unsigned int mnt_get_writers(struct mount
*mnt
)
265 unsigned int count
= 0;
268 for_each_possible_cpu(cpu
) {
269 count
+= per_cpu_ptr(mnt
->mnt_pcp
, cpu
)->mnt_writers
;
274 return mnt
->mnt_writers
;
278 static int mnt_is_readonly(struct vfsmount
*mnt
)
280 if (mnt
->mnt_sb
->s_readonly_remount
)
282 /* Order wrt setting s_flags/s_readonly_remount in do_remount() */
284 return __mnt_is_readonly(mnt
);
288 * Most r/o & frozen checks on a fs are for operations that take discrete
289 * amounts of time, like a write() or unlink(). We must keep track of when
290 * those operations start (for permission checks) and when they end, so that we
291 * can determine when writes are able to occur to a filesystem.
294 * __mnt_want_write - get write access to a mount without freeze protection
295 * @m: the mount on which to take a write
297 * This tells the low-level filesystem that a write is about to be performed to
298 * it, and makes sure that writes are allowed (mnt it read-write) before
299 * returning success. This operation does not protect against filesystem being
300 * frozen. When the write operation is finished, __mnt_drop_write() must be
301 * called. This is effectively a refcount.
303 int __mnt_want_write(struct vfsmount
*m
)
305 struct mount
*mnt
= real_mount(m
);
309 mnt_inc_writers(mnt
);
311 * The store to mnt_inc_writers must be visible before we pass
312 * MNT_WRITE_HOLD loop below, so that the slowpath can see our
313 * incremented count after it has set MNT_WRITE_HOLD.
316 while (ACCESS_ONCE(mnt
->mnt
.mnt_flags
) & MNT_WRITE_HOLD
)
319 * After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will
320 * be set to match its requirements. So we must not load that until
321 * MNT_WRITE_HOLD is cleared.
324 if (mnt_is_readonly(m
)) {
325 mnt_dec_writers(mnt
);
334 * mnt_want_write - get write access to a mount
335 * @m: the mount on which to take a write
337 * This tells the low-level filesystem that a write is about to be performed to
338 * it, and makes sure that writes are allowed (mount is read-write, filesystem
339 * is not frozen) before returning success. When the write operation is
340 * finished, mnt_drop_write() must be called. This is effectively a refcount.
342 int mnt_want_write(struct vfsmount
*m
)
346 sb_start_write(m
->mnt_sb
);
347 ret
= __mnt_want_write(m
);
349 sb_end_write(m
->mnt_sb
);
352 EXPORT_SYMBOL_GPL(mnt_want_write
);
355 * mnt_clone_write - get write access to a mount
356 * @mnt: the mount on which to take a write
358 * This is effectively like mnt_want_write, except
359 * it must only be used to take an extra write reference
360 * on a mountpoint that we already know has a write reference
361 * on it. This allows some optimisation.
363 * After finished, mnt_drop_write must be called as usual to
364 * drop the reference.
366 int mnt_clone_write(struct vfsmount
*mnt
)
368 /* superblock may be r/o */
369 if (__mnt_is_readonly(mnt
))
372 mnt_inc_writers(real_mount(mnt
));
376 EXPORT_SYMBOL_GPL(mnt_clone_write
);
379 * __mnt_want_write_file - get write access to a file's mount
380 * @file: the file who's mount on which to take a write
382 * This is like __mnt_want_write, but it takes a file and can
383 * do some optimisations if the file is open for write already
385 int __mnt_want_write_file(struct file
*file
)
387 struct inode
*inode
= file
->f_dentry
->d_inode
;
389 if (!(file
->f_mode
& FMODE_WRITE
) || special_file(inode
->i_mode
))
390 return __mnt_want_write(file
->f_path
.mnt
);
392 return mnt_clone_write(file
->f_path
.mnt
);
396 * mnt_want_write_file - get write access to a file's mount
397 * @file: the file who's mount on which to take a write
399 * This is like mnt_want_write, but it takes a file and can
400 * do some optimisations if the file is open for write already
402 int mnt_want_write_file(struct file
*file
)
406 sb_start_write(file
->f_path
.mnt
->mnt_sb
);
407 ret
= __mnt_want_write_file(file
);
409 sb_end_write(file
->f_path
.mnt
->mnt_sb
);
412 EXPORT_SYMBOL_GPL(mnt_want_write_file
);
415 * __mnt_drop_write - give up write access to a mount
416 * @mnt: the mount on which to give up write access
418 * Tells the low-level filesystem that we are done
419 * performing writes to it. Must be matched with
420 * __mnt_want_write() call above.
422 void __mnt_drop_write(struct vfsmount
*mnt
)
425 mnt_dec_writers(real_mount(mnt
));
430 * mnt_drop_write - give up write access to a mount
431 * @mnt: the mount on which to give up write access
433 * Tells the low-level filesystem that we are done performing writes to it and
434 * also allows filesystem to be frozen again. Must be matched with
435 * mnt_want_write() call above.
437 void mnt_drop_write(struct vfsmount
*mnt
)
439 __mnt_drop_write(mnt
);
440 sb_end_write(mnt
->mnt_sb
);
442 EXPORT_SYMBOL_GPL(mnt_drop_write
);
444 void __mnt_drop_write_file(struct file
*file
)
446 __mnt_drop_write(file
->f_path
.mnt
);
449 void mnt_drop_write_file(struct file
*file
)
451 mnt_drop_write(file
->f_path
.mnt
);
453 EXPORT_SYMBOL(mnt_drop_write_file
);
455 static int mnt_make_readonly(struct mount
*mnt
)
459 br_write_lock(&vfsmount_lock
);
460 mnt
->mnt
.mnt_flags
|= MNT_WRITE_HOLD
;
462 * After storing MNT_WRITE_HOLD, we'll read the counters. This store
463 * should be visible before we do.
468 * With writers on hold, if this value is zero, then there are
469 * definitely no active writers (although held writers may subsequently
470 * increment the count, they'll have to wait, and decrement it after
471 * seeing MNT_READONLY).
473 * It is OK to have counter incremented on one CPU and decremented on
474 * another: the sum will add up correctly. The danger would be when we
475 * sum up each counter, if we read a counter before it is incremented,
476 * but then read another CPU's count which it has been subsequently
477 * decremented from -- we would see more decrements than we should.
478 * MNT_WRITE_HOLD protects against this scenario, because
479 * mnt_want_write first increments count, then smp_mb, then spins on
480 * MNT_WRITE_HOLD, so it can't be decremented by another CPU while
481 * we're counting up here.
483 if (mnt_get_writers(mnt
) > 0)
486 mnt
->mnt
.mnt_flags
|= MNT_READONLY
;
488 * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers
489 * that become unheld will see MNT_READONLY.
492 mnt
->mnt
.mnt_flags
&= ~MNT_WRITE_HOLD
;
493 br_write_unlock(&vfsmount_lock
);
497 static void __mnt_unmake_readonly(struct mount
*mnt
)
499 br_write_lock(&vfsmount_lock
);
500 mnt
->mnt
.mnt_flags
&= ~MNT_READONLY
;
501 br_write_unlock(&vfsmount_lock
);
504 int sb_prepare_remount_readonly(struct super_block
*sb
)
509 /* Racy optimization. Recheck the counter under MNT_WRITE_HOLD */
510 if (atomic_long_read(&sb
->s_remove_count
))
513 br_write_lock(&vfsmount_lock
);
514 list_for_each_entry(mnt
, &sb
->s_mounts
, mnt_instance
) {
515 if (!(mnt
->mnt
.mnt_flags
& MNT_READONLY
)) {
516 mnt
->mnt
.mnt_flags
|= MNT_WRITE_HOLD
;
518 if (mnt_get_writers(mnt
) > 0) {
524 if (!err
&& atomic_long_read(&sb
->s_remove_count
))
528 sb
->s_readonly_remount
= 1;
531 list_for_each_entry(mnt
, &sb
->s_mounts
, mnt_instance
) {
532 if (mnt
->mnt
.mnt_flags
& MNT_WRITE_HOLD
)
533 mnt
->mnt
.mnt_flags
&= ~MNT_WRITE_HOLD
;
535 br_write_unlock(&vfsmount_lock
);
540 static void free_vfsmnt(struct mount
*mnt
)
542 kfree(mnt
->mnt_devname
);
545 free_percpu(mnt
->mnt_pcp
);
547 kmem_cache_free(mnt_cache
, mnt
);
551 * find the first or last mount at @dentry on vfsmount @mnt depending on
552 * @dir. If @dir is set return the first mount else return the last mount.
553 * vfsmount_lock must be held for read or write.
555 struct mount
*__lookup_mnt(struct vfsmount
*mnt
, struct dentry
*dentry
,
558 struct list_head
*head
= mount_hashtable
+ hash(mnt
, dentry
);
559 struct list_head
*tmp
= head
;
560 struct mount
*p
, *found
= NULL
;
563 tmp
= dir
? tmp
->next
: tmp
->prev
;
567 p
= list_entry(tmp
, struct mount
, mnt_hash
);
568 if (&p
->mnt_parent
->mnt
== mnt
&& p
->mnt_mountpoint
== dentry
) {
577 * lookup_mnt - Return the first child mount mounted at path
579 * "First" means first mounted chronologically. If you create the
582 * mount /dev/sda1 /mnt
583 * mount /dev/sda2 /mnt
584 * mount /dev/sda3 /mnt
586 * Then lookup_mnt() on the base /mnt dentry in the root mount will
587 * return successively the root dentry and vfsmount of /dev/sda1, then
588 * /dev/sda2, then /dev/sda3, then NULL.
590 * lookup_mnt takes a reference to the found vfsmount.
592 struct vfsmount
*lookup_mnt(struct path
*path
)
594 struct mount
*child_mnt
;
596 br_read_lock(&vfsmount_lock
);
597 child_mnt
= __lookup_mnt(path
->mnt
, path
->dentry
, 1);
599 mnt_add_count(child_mnt
, 1);
600 br_read_unlock(&vfsmount_lock
);
601 return &child_mnt
->mnt
;
603 br_read_unlock(&vfsmount_lock
);
608 static inline int check_mnt(struct mount
*mnt
)
610 return mnt
->mnt_ns
== current
->nsproxy
->mnt_ns
;
614 * vfsmount lock must be held for write
616 static void touch_mnt_namespace(struct mnt_namespace
*ns
)
620 wake_up_interruptible(&ns
->poll
);
625 * vfsmount lock must be held for write
627 static void __touch_mnt_namespace(struct mnt_namespace
*ns
)
629 if (ns
&& ns
->event
!= event
) {
631 wake_up_interruptible(&ns
->poll
);
636 * Clear dentry's mounted state if it has no remaining mounts.
637 * vfsmount_lock must be held for write.
639 static void dentry_reset_mounted(struct dentry
*dentry
)
643 for (u
= 0; u
< HASH_SIZE
; u
++) {
646 list_for_each_entry(p
, &mount_hashtable
[u
], mnt_hash
) {
647 if (p
->mnt_mountpoint
== dentry
)
651 spin_lock(&dentry
->d_lock
);
652 dentry
->d_flags
&= ~DCACHE_MOUNTED
;
653 spin_unlock(&dentry
->d_lock
);
657 * vfsmount lock must be held for write
659 static void detach_mnt(struct mount
*mnt
, struct path
*old_path
)
661 old_path
->dentry
= mnt
->mnt_mountpoint
;
662 old_path
->mnt
= &mnt
->mnt_parent
->mnt
;
663 mnt
->mnt_parent
= mnt
;
664 mnt
->mnt_mountpoint
= mnt
->mnt
.mnt_root
;
665 list_del_init(&mnt
->mnt_child
);
666 list_del_init(&mnt
->mnt_hash
);
667 dentry_reset_mounted(old_path
->dentry
);
671 * vfsmount lock must be held for write
673 void mnt_set_mountpoint(struct mount
*mnt
, struct dentry
*dentry
,
674 struct mount
*child_mnt
)
676 mnt_add_count(mnt
, 1); /* essentially, that's mntget */
677 child_mnt
->mnt_mountpoint
= dget(dentry
);
678 child_mnt
->mnt_parent
= mnt
;
679 spin_lock(&dentry
->d_lock
);
680 dentry
->d_flags
|= DCACHE_MOUNTED
;
681 spin_unlock(&dentry
->d_lock
);
685 * vfsmount lock must be held for write
687 static void attach_mnt(struct mount
*mnt
, struct path
*path
)
689 mnt_set_mountpoint(real_mount(path
->mnt
), path
->dentry
, mnt
);
690 list_add_tail(&mnt
->mnt_hash
, mount_hashtable
+
691 hash(path
->mnt
, path
->dentry
));
692 list_add_tail(&mnt
->mnt_child
, &real_mount(path
->mnt
)->mnt_mounts
);
696 * vfsmount lock must be held for write
698 static void commit_tree(struct mount
*mnt
)
700 struct mount
*parent
= mnt
->mnt_parent
;
703 struct mnt_namespace
*n
= parent
->mnt_ns
;
705 BUG_ON(parent
== mnt
);
707 list_add_tail(&head
, &mnt
->mnt_list
);
708 list_for_each_entry(m
, &head
, mnt_list
)
711 list_splice(&head
, n
->list
.prev
);
713 list_add_tail(&mnt
->mnt_hash
, mount_hashtable
+
714 hash(&parent
->mnt
, mnt
->mnt_mountpoint
));
715 list_add_tail(&mnt
->mnt_child
, &parent
->mnt_mounts
);
716 touch_mnt_namespace(n
);
719 static struct mount
*next_mnt(struct mount
*p
, struct mount
*root
)
721 struct list_head
*next
= p
->mnt_mounts
.next
;
722 if (next
== &p
->mnt_mounts
) {
726 next
= p
->mnt_child
.next
;
727 if (next
!= &p
->mnt_parent
->mnt_mounts
)
732 return list_entry(next
, struct mount
, mnt_child
);
735 static struct mount
*skip_mnt_tree(struct mount
*p
)
737 struct list_head
*prev
= p
->mnt_mounts
.prev
;
738 while (prev
!= &p
->mnt_mounts
) {
739 p
= list_entry(prev
, struct mount
, mnt_child
);
740 prev
= p
->mnt_mounts
.prev
;
746 vfs_kern_mount(struct file_system_type
*type
, int flags
, const char *name
, void *data
)
752 return ERR_PTR(-ENODEV
);
754 mnt
= alloc_vfsmnt(name
);
756 return ERR_PTR(-ENOMEM
);
758 if (flags
& MS_KERNMOUNT
)
759 mnt
->mnt
.mnt_flags
= MNT_INTERNAL
;
761 root
= mount_fs(type
, flags
, name
, data
);
764 return ERR_CAST(root
);
767 mnt
->mnt
.mnt_root
= root
;
768 mnt
->mnt
.mnt_sb
= root
->d_sb
;
769 mnt
->mnt_mountpoint
= mnt
->mnt
.mnt_root
;
770 mnt
->mnt_parent
= mnt
;
771 br_write_lock(&vfsmount_lock
);
772 list_add_tail(&mnt
->mnt_instance
, &root
->d_sb
->s_mounts
);
773 br_write_unlock(&vfsmount_lock
);
776 EXPORT_SYMBOL_GPL(vfs_kern_mount
);
778 static struct mount
*clone_mnt(struct mount
*old
, struct dentry
*root
,
781 struct super_block
*sb
= old
->mnt
.mnt_sb
;
785 mnt
= alloc_vfsmnt(old
->mnt_devname
);
787 return ERR_PTR(-ENOMEM
);
789 if (flag
& (CL_SLAVE
| CL_PRIVATE
| CL_SHARED_TO_SLAVE
))
790 mnt
->mnt_group_id
= 0; /* not a peer of original */
792 mnt
->mnt_group_id
= old
->mnt_group_id
;
794 if ((flag
& CL_MAKE_SHARED
) && !mnt
->mnt_group_id
) {
795 err
= mnt_alloc_group_id(mnt
);
800 mnt
->mnt
.mnt_flags
= old
->mnt
.mnt_flags
& ~MNT_WRITE_HOLD
;
801 atomic_inc(&sb
->s_active
);
802 mnt
->mnt
.mnt_sb
= sb
;
803 mnt
->mnt
.mnt_root
= dget(root
);
804 mnt
->mnt_mountpoint
= mnt
->mnt
.mnt_root
;
805 mnt
->mnt_parent
= mnt
;
806 br_write_lock(&vfsmount_lock
);
807 list_add_tail(&mnt
->mnt_instance
, &sb
->s_mounts
);
808 br_write_unlock(&vfsmount_lock
);
810 if ((flag
& CL_SLAVE
) ||
811 ((flag
& CL_SHARED_TO_SLAVE
) && IS_MNT_SHARED(old
))) {
812 list_add(&mnt
->mnt_slave
, &old
->mnt_slave_list
);
813 mnt
->mnt_master
= old
;
814 CLEAR_MNT_SHARED(mnt
);
815 } else if (!(flag
& CL_PRIVATE
)) {
816 if ((flag
& CL_MAKE_SHARED
) || IS_MNT_SHARED(old
))
817 list_add(&mnt
->mnt_share
, &old
->mnt_share
);
818 if (IS_MNT_SLAVE(old
))
819 list_add(&mnt
->mnt_slave
, &old
->mnt_slave
);
820 mnt
->mnt_master
= old
->mnt_master
;
822 if (flag
& CL_MAKE_SHARED
)
825 /* stick the duplicate mount on the same expiry list
826 * as the original if that was on one */
827 if (flag
& CL_EXPIRE
) {
828 if (!list_empty(&old
->mnt_expire
))
829 list_add(&mnt
->mnt_expire
, &old
->mnt_expire
);
839 static inline void mntfree(struct mount
*mnt
)
841 struct vfsmount
*m
= &mnt
->mnt
;
842 struct super_block
*sb
= m
->mnt_sb
;
845 * This probably indicates that somebody messed
846 * up a mnt_want/drop_write() pair. If this
847 * happens, the filesystem was probably unable
848 * to make r/w->r/o transitions.
851 * The locking used to deal with mnt_count decrement provides barriers,
852 * so mnt_get_writers() below is safe.
854 WARN_ON(mnt_get_writers(mnt
));
855 fsnotify_vfsmount_delete(m
);
858 deactivate_super(sb
);
861 static void mntput_no_expire(struct mount
*mnt
)
865 br_read_lock(&vfsmount_lock
);
866 if (likely(mnt
->mnt_ns
)) {
867 /* shouldn't be the last one */
868 mnt_add_count(mnt
, -1);
869 br_read_unlock(&vfsmount_lock
);
872 br_read_unlock(&vfsmount_lock
);
874 br_write_lock(&vfsmount_lock
);
875 mnt_add_count(mnt
, -1);
876 if (mnt_get_count(mnt
)) {
877 br_write_unlock(&vfsmount_lock
);
881 mnt_add_count(mnt
, -1);
882 if (likely(mnt_get_count(mnt
)))
884 br_write_lock(&vfsmount_lock
);
886 if (unlikely(mnt
->mnt_pinned
)) {
887 mnt_add_count(mnt
, mnt
->mnt_pinned
+ 1);
889 br_write_unlock(&vfsmount_lock
);
890 acct_auto_close_mnt(&mnt
->mnt
);
894 list_del(&mnt
->mnt_instance
);
895 br_write_unlock(&vfsmount_lock
);
899 void mntput(struct vfsmount
*mnt
)
902 struct mount
*m
= real_mount(mnt
);
903 /* avoid cacheline pingpong, hope gcc doesn't get "smart" */
904 if (unlikely(m
->mnt_expiry_mark
))
905 m
->mnt_expiry_mark
= 0;
909 EXPORT_SYMBOL(mntput
);
911 struct vfsmount
*mntget(struct vfsmount
*mnt
)
914 mnt_add_count(real_mount(mnt
), 1);
917 EXPORT_SYMBOL(mntget
);
919 void mnt_pin(struct vfsmount
*mnt
)
921 br_write_lock(&vfsmount_lock
);
922 real_mount(mnt
)->mnt_pinned
++;
923 br_write_unlock(&vfsmount_lock
);
925 EXPORT_SYMBOL(mnt_pin
);
927 void mnt_unpin(struct vfsmount
*m
)
929 struct mount
*mnt
= real_mount(m
);
930 br_write_lock(&vfsmount_lock
);
931 if (mnt
->mnt_pinned
) {
932 mnt_add_count(mnt
, 1);
935 br_write_unlock(&vfsmount_lock
);
937 EXPORT_SYMBOL(mnt_unpin
);
939 static inline void mangle(struct seq_file
*m
, const char *s
)
941 seq_escape(m
, s
, " \t\n\\");
945 * Simple .show_options callback for filesystems which don't want to
946 * implement more complex mount option showing.
948 * See also save_mount_options().
950 int generic_show_options(struct seq_file
*m
, struct dentry
*root
)
955 options
= rcu_dereference(root
->d_sb
->s_options
);
957 if (options
!= NULL
&& options
[0]) {
965 EXPORT_SYMBOL(generic_show_options
);
968 * If filesystem uses generic_show_options(), this function should be
969 * called from the fill_super() callback.
971 * The .remount_fs callback usually needs to be handled in a special
972 * way, to make sure, that previous options are not overwritten if the
975 * Also note, that if the filesystem's .remount_fs function doesn't
976 * reset all options to their default value, but changes only newly
977 * given options, then the displayed options will not reflect reality
980 void save_mount_options(struct super_block
*sb
, char *options
)
982 BUG_ON(sb
->s_options
);
983 rcu_assign_pointer(sb
->s_options
, kstrdup(options
, GFP_KERNEL
));
985 EXPORT_SYMBOL(save_mount_options
);
987 void replace_mount_options(struct super_block
*sb
, char *options
)
989 char *old
= sb
->s_options
;
990 rcu_assign_pointer(sb
->s_options
, options
);
996 EXPORT_SYMBOL(replace_mount_options
);
998 #ifdef CONFIG_PROC_FS
999 /* iterator; we want it to have access to namespace_sem, thus here... */
1000 static void *m_start(struct seq_file
*m
, loff_t
*pos
)
1002 struct proc_mounts
*p
= proc_mounts(m
);
1004 down_read(&namespace_sem
);
1005 return seq_list_start(&p
->ns
->list
, *pos
);
1008 static void *m_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
1010 struct proc_mounts
*p
= proc_mounts(m
);
1012 return seq_list_next(v
, &p
->ns
->list
, pos
);
1015 static void m_stop(struct seq_file
*m
, void *v
)
1017 up_read(&namespace_sem
);
1020 static int m_show(struct seq_file
*m
, void *v
)
1022 struct proc_mounts
*p
= proc_mounts(m
);
1023 struct mount
*r
= list_entry(v
, struct mount
, mnt_list
);
1024 return p
->show(m
, &r
->mnt
);
1027 const struct seq_operations mounts_op
= {
1033 #endif /* CONFIG_PROC_FS */
1036 * may_umount_tree - check if a mount tree is busy
1037 * @mnt: root of mount tree
1039 * This is called to check if a tree of mounts has any
1040 * open files, pwds, chroots or sub mounts that are
1043 int may_umount_tree(struct vfsmount
*m
)
1045 struct mount
*mnt
= real_mount(m
);
1046 int actual_refs
= 0;
1047 int minimum_refs
= 0;
1051 /* write lock needed for mnt_get_count */
1052 br_write_lock(&vfsmount_lock
);
1053 for (p
= mnt
; p
; p
= next_mnt(p
, mnt
)) {
1054 actual_refs
+= mnt_get_count(p
);
1057 br_write_unlock(&vfsmount_lock
);
1059 if (actual_refs
> minimum_refs
)
1065 EXPORT_SYMBOL(may_umount_tree
);
1068 * may_umount - check if a mount point is busy
1069 * @mnt: root of mount
1071 * This is called to check if a mount point has any
1072 * open files, pwds, chroots or sub mounts. If the
1073 * mount has sub mounts this will return busy
1074 * regardless of whether the sub mounts are busy.
1076 * Doesn't take quota and stuff into account. IOW, in some cases it will
1077 * give false negatives. The main reason why it's here is that we need
1078 * a non-destructive way to look for easily umountable filesystems.
1080 int may_umount(struct vfsmount
*mnt
)
1083 down_read(&namespace_sem
);
1084 br_write_lock(&vfsmount_lock
);
1085 if (propagate_mount_busy(real_mount(mnt
), 2))
1087 br_write_unlock(&vfsmount_lock
);
1088 up_read(&namespace_sem
);
1092 EXPORT_SYMBOL(may_umount
);
1094 void release_mounts(struct list_head
*head
)
1097 while (!list_empty(head
)) {
1098 mnt
= list_first_entry(head
, struct mount
, mnt_hash
);
1099 list_del_init(&mnt
->mnt_hash
);
1100 if (mnt_has_parent(mnt
)) {
1101 struct dentry
*dentry
;
1104 br_write_lock(&vfsmount_lock
);
1105 dentry
= mnt
->mnt_mountpoint
;
1106 m
= mnt
->mnt_parent
;
1107 mnt
->mnt_mountpoint
= mnt
->mnt
.mnt_root
;
1108 mnt
->mnt_parent
= mnt
;
1110 br_write_unlock(&vfsmount_lock
);
1119 * vfsmount lock must be held for write
1120 * namespace_sem must be held for write
1122 void umount_tree(struct mount
*mnt
, int propagate
, struct list_head
*kill
)
1124 LIST_HEAD(tmp_list
);
1127 for (p
= mnt
; p
; p
= next_mnt(p
, mnt
))
1128 list_move(&p
->mnt_hash
, &tmp_list
);
1131 propagate_umount(&tmp_list
);
1133 list_for_each_entry(p
, &tmp_list
, mnt_hash
) {
1134 list_del_init(&p
->mnt_expire
);
1135 list_del_init(&p
->mnt_list
);
1136 __touch_mnt_namespace(p
->mnt_ns
);
1138 list_del_init(&p
->mnt_child
);
1139 if (mnt_has_parent(p
)) {
1140 p
->mnt_parent
->mnt_ghosts
++;
1141 dentry_reset_mounted(p
->mnt_mountpoint
);
1143 change_mnt_propagation(p
, MS_PRIVATE
);
1145 list_splice(&tmp_list
, kill
);
1148 static void shrink_submounts(struct mount
*mnt
, struct list_head
*umounts
);
1150 static int do_umount(struct mount
*mnt
, int flags
)
1152 struct super_block
*sb
= mnt
->mnt
.mnt_sb
;
1154 LIST_HEAD(umount_list
);
1156 retval
= security_sb_umount(&mnt
->mnt
, flags
);
1161 * Allow userspace to request a mountpoint be expired rather than
1162 * unmounting unconditionally. Unmount only happens if:
1163 * (1) the mark is already set (the mark is cleared by mntput())
1164 * (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount]
1166 if (flags
& MNT_EXPIRE
) {
1167 if (&mnt
->mnt
== current
->fs
->root
.mnt
||
1168 flags
& (MNT_FORCE
| MNT_DETACH
))
1172 * probably don't strictly need the lock here if we examined
1173 * all race cases, but it's a slowpath.
1175 br_write_lock(&vfsmount_lock
);
1176 if (mnt_get_count(mnt
) != 2) {
1177 br_write_unlock(&vfsmount_lock
);
1180 br_write_unlock(&vfsmount_lock
);
1182 if (!xchg(&mnt
->mnt_expiry_mark
, 1))
1187 * If we may have to abort operations to get out of this
1188 * mount, and they will themselves hold resources we must
1189 * allow the fs to do things. In the Unix tradition of
1190 * 'Gee thats tricky lets do it in userspace' the umount_begin
1191 * might fail to complete on the first run through as other tasks
1192 * must return, and the like. Thats for the mount program to worry
1193 * about for the moment.
1196 if (flags
& MNT_FORCE
&& sb
->s_op
->umount_begin
) {
1197 sb
->s_op
->umount_begin(sb
);
1201 * No sense to grab the lock for this test, but test itself looks
1202 * somewhat bogus. Suggestions for better replacement?
1203 * Ho-hum... In principle, we might treat that as umount + switch
1204 * to rootfs. GC would eventually take care of the old vfsmount.
1205 * Actually it makes sense, especially if rootfs would contain a
1206 * /reboot - static binary that would close all descriptors and
1207 * call reboot(9). Then init(8) could umount root and exec /reboot.
1209 if (&mnt
->mnt
== current
->fs
->root
.mnt
&& !(flags
& MNT_DETACH
)) {
1211 * Special case for "unmounting" root ...
1212 * we just try to remount it readonly.
1214 down_write(&sb
->s_umount
);
1215 if (!(sb
->s_flags
& MS_RDONLY
))
1216 retval
= do_remount_sb(sb
, MS_RDONLY
, NULL
, 0);
1217 up_write(&sb
->s_umount
);
1221 down_write(&namespace_sem
);
1222 br_write_lock(&vfsmount_lock
);
1225 if (!(flags
& MNT_DETACH
))
1226 shrink_submounts(mnt
, &umount_list
);
1229 if (flags
& MNT_DETACH
|| !propagate_mount_busy(mnt
, 2)) {
1230 if (!list_empty(&mnt
->mnt_list
))
1231 umount_tree(mnt
, 1, &umount_list
);
1234 br_write_unlock(&vfsmount_lock
);
1235 up_write(&namespace_sem
);
1236 release_mounts(&umount_list
);
1241 * Is the caller allowed to modify his namespace?
1243 static inline bool may_mount(void)
1245 return ns_capable(current
->nsproxy
->mnt_ns
->user_ns
, CAP_SYS_ADMIN
);
1249 * Now umount can handle mount points as well as block devices.
1250 * This is important for filesystems which use unnamed block devices.
1252 * We now support a flag for forced unmount like the other 'big iron'
1253 * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD
1256 SYSCALL_DEFINE2(umount
, char __user
*, name
, int, flags
)
1261 int lookup_flags
= 0;
1263 if (flags
& ~(MNT_FORCE
| MNT_DETACH
| MNT_EXPIRE
| UMOUNT_NOFOLLOW
))
1269 if (!(flags
& UMOUNT_NOFOLLOW
))
1270 lookup_flags
|= LOOKUP_FOLLOW
;
1272 retval
= user_path_at(AT_FDCWD
, name
, lookup_flags
, &path
);
1275 mnt
= real_mount(path
.mnt
);
1277 if (path
.dentry
!= path
.mnt
->mnt_root
)
1279 if (!check_mnt(mnt
))
1282 retval
= do_umount(mnt
, flags
);
1284 /* we mustn't call path_put() as that would clear mnt_expiry_mark */
1286 mntput_no_expire(mnt
);
1291 #ifdef __ARCH_WANT_SYS_OLDUMOUNT
1294 * The 2.0 compatible umount. No flags.
1296 SYSCALL_DEFINE1(oldumount
, char __user
*, name
)
1298 return sys_umount(name
, 0);
1303 static int mount_is_safe(struct path
*path
)
1309 if (S_ISLNK(path
->dentry
->d_inode
->i_mode
))
1311 if (path
->dentry
->d_inode
->i_mode
& S_ISVTX
) {
1312 if (current_uid() != path
->dentry
->d_inode
->i_uid
)
1315 if (inode_permission(path
->dentry
->d_inode
, MAY_WRITE
))
1321 static bool mnt_ns_loop(struct path
*path
)
1323 /* Could bind mounting the mount namespace inode cause a
1324 * mount namespace loop?
1326 struct inode
*inode
= path
->dentry
->d_inode
;
1327 struct proc_inode
*ei
;
1328 struct mnt_namespace
*mnt_ns
;
1330 if (!proc_ns_inode(inode
))
1334 if (ei
->ns_ops
!= &mntns_operations
)
1338 return current
->nsproxy
->mnt_ns
->seq
>= mnt_ns
->seq
;
1341 struct mount
*copy_tree(struct mount
*mnt
, struct dentry
*dentry
,
1344 struct mount
*res
, *p
, *q
, *r
;
1347 if (!(flag
& CL_COPY_ALL
) && IS_MNT_UNBINDABLE(mnt
))
1348 return ERR_PTR(-EINVAL
);
1350 res
= q
= clone_mnt(mnt
, dentry
, flag
);
1354 q
->mnt_mountpoint
= mnt
->mnt_mountpoint
;
1357 list_for_each_entry(r
, &mnt
->mnt_mounts
, mnt_child
) {
1359 if (!is_subdir(r
->mnt_mountpoint
, dentry
))
1362 for (s
= r
; s
; s
= next_mnt(s
, r
)) {
1363 if (!(flag
& CL_COPY_ALL
) && IS_MNT_UNBINDABLE(s
)) {
1364 s
= skip_mnt_tree(s
);
1367 while (p
!= s
->mnt_parent
) {
1373 path
.dentry
= p
->mnt_mountpoint
;
1374 q
= clone_mnt(p
, p
->mnt
.mnt_root
, flag
);
1377 br_write_lock(&vfsmount_lock
);
1378 list_add_tail(&q
->mnt_list
, &res
->mnt_list
);
1379 attach_mnt(q
, &path
);
1380 br_write_unlock(&vfsmount_lock
);
1386 LIST_HEAD(umount_list
);
1387 br_write_lock(&vfsmount_lock
);
1388 umount_tree(res
, 0, &umount_list
);
1389 br_write_unlock(&vfsmount_lock
);
1390 release_mounts(&umount_list
);
1395 /* Caller should check returned pointer for errors */
1397 struct vfsmount
*collect_mounts(struct path
*path
)
1400 down_write(&namespace_sem
);
1401 tree
= copy_tree(real_mount(path
->mnt
), path
->dentry
,
1402 CL_COPY_ALL
| CL_PRIVATE
);
1403 up_write(&namespace_sem
);
1409 void drop_collected_mounts(struct vfsmount
*mnt
)
1411 LIST_HEAD(umount_list
);
1412 down_write(&namespace_sem
);
1413 br_write_lock(&vfsmount_lock
);
1414 umount_tree(real_mount(mnt
), 0, &umount_list
);
1415 br_write_unlock(&vfsmount_lock
);
1416 up_write(&namespace_sem
);
1417 release_mounts(&umount_list
);
1420 int iterate_mounts(int (*f
)(struct vfsmount
*, void *), void *arg
,
1421 struct vfsmount
*root
)
1424 int res
= f(root
, arg
);
1427 list_for_each_entry(mnt
, &real_mount(root
)->mnt_list
, mnt_list
) {
1428 res
= f(&mnt
->mnt
, arg
);
1435 static void cleanup_group_ids(struct mount
*mnt
, struct mount
*end
)
1439 for (p
= mnt
; p
!= end
; p
= next_mnt(p
, mnt
)) {
1440 if (p
->mnt_group_id
&& !IS_MNT_SHARED(p
))
1441 mnt_release_group_id(p
);
1445 static int invent_group_ids(struct mount
*mnt
, bool recurse
)
1449 for (p
= mnt
; p
; p
= recurse
? next_mnt(p
, mnt
) : NULL
) {
1450 if (!p
->mnt_group_id
&& !IS_MNT_SHARED(p
)) {
1451 int err
= mnt_alloc_group_id(p
);
1453 cleanup_group_ids(mnt
, p
);
1463 * @source_mnt : mount tree to be attached
1464 * @nd : place the mount tree @source_mnt is attached
1465 * @parent_nd : if non-null, detach the source_mnt from its parent and
1466 * store the parent mount and mountpoint dentry.
1467 * (done when source_mnt is moved)
1469 * NOTE: in the table below explains the semantics when a source mount
1470 * of a given type is attached to a destination mount of a given type.
1471 * ---------------------------------------------------------------------------
1472 * | BIND MOUNT OPERATION |
1473 * |**************************************************************************
1474 * | source-->| shared | private | slave | unbindable |
1478 * |**************************************************************************
1479 * | shared | shared (++) | shared (+) | shared(+++)| invalid |
1481 * |non-shared| shared (+) | private | slave (*) | invalid |
1482 * ***************************************************************************
1483 * A bind operation clones the source mount and mounts the clone on the
1484 * destination mount.
1486 * (++) the cloned mount is propagated to all the mounts in the propagation
1487 * tree of the destination mount and the cloned mount is added to
1488 * the peer group of the source mount.
1489 * (+) the cloned mount is created under the destination mount and is marked
1490 * as shared. The cloned mount is added to the peer group of the source
1492 * (+++) the mount is propagated to all the mounts in the propagation tree
1493 * of the destination mount and the cloned mount is made slave
1494 * of the same master as that of the source mount. The cloned mount
1495 * is marked as 'shared and slave'.
1496 * (*) the cloned mount is made a slave of the same master as that of the
1499 * ---------------------------------------------------------------------------
1500 * | MOVE MOUNT OPERATION |
1501 * |**************************************************************************
1502 * | source-->| shared | private | slave | unbindable |
1506 * |**************************************************************************
1507 * | shared | shared (+) | shared (+) | shared(+++) | invalid |
1509 * |non-shared| shared (+*) | private | slave (*) | unbindable |
1510 * ***************************************************************************
1512 * (+) the mount is moved to the destination. And is then propagated to
1513 * all the mounts in the propagation tree of the destination mount.
1514 * (+*) the mount is moved to the destination.
1515 * (+++) the mount is moved to the destination and is then propagated to
1516 * all the mounts belonging to the destination mount's propagation tree.
1517 * the mount is marked as 'shared and slave'.
1518 * (*) the mount continues to be a slave at the new location.
1520 * if the source mount is a tree, the operations explained above is
1521 * applied to each mount in the tree.
1522 * Must be called without spinlocks held, since this function can sleep
1525 static int attach_recursive_mnt(struct mount
*source_mnt
,
1526 struct path
*path
, struct path
*parent_path
)
1528 LIST_HEAD(tree_list
);
1529 struct mount
*dest_mnt
= real_mount(path
->mnt
);
1530 struct dentry
*dest_dentry
= path
->dentry
;
1531 struct mount
*child
, *p
;
1534 if (IS_MNT_SHARED(dest_mnt
)) {
1535 err
= invent_group_ids(source_mnt
, true);
1539 err
= propagate_mnt(dest_mnt
, dest_dentry
, source_mnt
, &tree_list
);
1541 goto out_cleanup_ids
;
1543 br_write_lock(&vfsmount_lock
);
1545 if (IS_MNT_SHARED(dest_mnt
)) {
1546 for (p
= source_mnt
; p
; p
= next_mnt(p
, source_mnt
))
1550 detach_mnt(source_mnt
, parent_path
);
1551 attach_mnt(source_mnt
, path
);
1552 touch_mnt_namespace(source_mnt
->mnt_ns
);
1554 mnt_set_mountpoint(dest_mnt
, dest_dentry
, source_mnt
);
1555 commit_tree(source_mnt
);
1558 list_for_each_entry_safe(child
, p
, &tree_list
, mnt_hash
) {
1559 list_del_init(&child
->mnt_hash
);
1562 br_write_unlock(&vfsmount_lock
);
1567 if (IS_MNT_SHARED(dest_mnt
))
1568 cleanup_group_ids(source_mnt
, NULL
);
1573 static int lock_mount(struct path
*path
)
1575 struct vfsmount
*mnt
;
1577 mutex_lock(&path
->dentry
->d_inode
->i_mutex
);
1578 if (unlikely(cant_mount(path
->dentry
))) {
1579 mutex_unlock(&path
->dentry
->d_inode
->i_mutex
);
1582 down_write(&namespace_sem
);
1583 mnt
= lookup_mnt(path
);
1586 up_write(&namespace_sem
);
1587 mutex_unlock(&path
->dentry
->d_inode
->i_mutex
);
1590 path
->dentry
= dget(mnt
->mnt_root
);
1594 static void unlock_mount(struct path
*path
)
1596 up_write(&namespace_sem
);
1597 mutex_unlock(&path
->dentry
->d_inode
->i_mutex
);
1600 static int graft_tree(struct mount
*mnt
, struct path
*path
)
1602 if (mnt
->mnt
.mnt_sb
->s_flags
& MS_NOUSER
)
1605 if (S_ISDIR(path
->dentry
->d_inode
->i_mode
) !=
1606 S_ISDIR(mnt
->mnt
.mnt_root
->d_inode
->i_mode
))
1609 if (d_unlinked(path
->dentry
))
1612 return attach_recursive_mnt(mnt
, path
, NULL
);
1616 * Sanity check the flags to change_mnt_propagation.
1619 static int flags_to_propagation_type(int flags
)
1621 int type
= flags
& ~(MS_REC
| MS_SILENT
);
1623 /* Fail if any non-propagation flags are set */
1624 if (type
& ~(MS_SHARED
| MS_PRIVATE
| MS_SLAVE
| MS_UNBINDABLE
))
1626 /* Only one propagation flag should be set */
1627 if (!is_power_of_2(type
))
1633 * recursively change the type of the mountpoint.
1635 static int do_change_type(struct path
*path
, int flag
)
1638 struct mount
*mnt
= real_mount(path
->mnt
);
1639 int recurse
= flag
& MS_REC
;
1646 if (path
->dentry
!= path
->mnt
->mnt_root
)
1649 type
= flags_to_propagation_type(flag
);
1653 down_write(&namespace_sem
);
1654 if (type
== MS_SHARED
) {
1655 err
= invent_group_ids(mnt
, recurse
);
1660 br_write_lock(&vfsmount_lock
);
1661 for (m
= mnt
; m
; m
= (recurse
? next_mnt(m
, mnt
) : NULL
))
1662 change_mnt_propagation(m
, type
);
1663 br_write_unlock(&vfsmount_lock
);
1666 up_write(&namespace_sem
);
1671 * do loopback mount.
1673 static int do_loopback(struct path
*path
, const char *old_name
,
1676 LIST_HEAD(umount_list
);
1677 struct path old_path
;
1678 struct mount
*mnt
= NULL
, *old
;
1679 int err
= mount_is_safe(path
);
1682 if (!old_name
|| !*old_name
)
1684 err
= kern_path(old_name
, LOOKUP_FOLLOW
|LOOKUP_AUTOMOUNT
, &old_path
);
1689 if (mnt_ns_loop(&old_path
))
1692 err
= lock_mount(path
);
1696 old
= real_mount(old_path
.mnt
);
1699 if (IS_MNT_UNBINDABLE(old
))
1702 if (!check_mnt(real_mount(path
->mnt
)) || !check_mnt(old
))
1706 mnt
= copy_tree(old
, old_path
.dentry
, 0);
1708 mnt
= clone_mnt(old
, old_path
.dentry
, 0);
1715 err
= graft_tree(mnt
, path
);
1717 br_write_lock(&vfsmount_lock
);
1718 umount_tree(mnt
, 0, &umount_list
);
1719 br_write_unlock(&vfsmount_lock
);
1723 release_mounts(&umount_list
);
1725 path_put(&old_path
);
1729 static int change_mount_flags(struct vfsmount
*mnt
, int ms_flags
)
1732 int readonly_request
= 0;
1734 if (ms_flags
& MS_RDONLY
)
1735 readonly_request
= 1;
1736 if (readonly_request
== __mnt_is_readonly(mnt
))
1739 if (readonly_request
)
1740 error
= mnt_make_readonly(real_mount(mnt
));
1742 __mnt_unmake_readonly(real_mount(mnt
));
1747 * change filesystem flags. dir should be a physical root of filesystem.
1748 * If you've mounted a non-root directory somewhere and want to do remount
1749 * on it - tough luck.
1751 static int do_remount(struct path
*path
, int flags
, int mnt_flags
,
1755 struct super_block
*sb
= path
->mnt
->mnt_sb
;
1756 struct mount
*mnt
= real_mount(path
->mnt
);
1758 if (!capable(CAP_SYS_ADMIN
))
1761 if (!check_mnt(mnt
))
1764 if (path
->dentry
!= path
->mnt
->mnt_root
)
1767 err
= security_sb_remount(sb
, data
);
1771 down_write(&sb
->s_umount
);
1772 if (flags
& MS_BIND
)
1773 err
= change_mount_flags(path
->mnt
, flags
);
1775 err
= do_remount_sb(sb
, flags
, data
, 0);
1777 br_write_lock(&vfsmount_lock
);
1778 mnt_flags
|= mnt
->mnt
.mnt_flags
& MNT_PROPAGATION_MASK
;
1779 mnt
->mnt
.mnt_flags
= mnt_flags
;
1780 br_write_unlock(&vfsmount_lock
);
1782 up_write(&sb
->s_umount
);
1784 br_write_lock(&vfsmount_lock
);
1785 touch_mnt_namespace(mnt
->mnt_ns
);
1786 br_write_unlock(&vfsmount_lock
);
1791 static inline int tree_contains_unbindable(struct mount
*mnt
)
1794 for (p
= mnt
; p
; p
= next_mnt(p
, mnt
)) {
1795 if (IS_MNT_UNBINDABLE(p
))
1801 static int do_move_mount(struct path
*path
, const char *old_name
)
1803 struct path old_path
, parent_path
;
1809 if (!old_name
|| !*old_name
)
1811 err
= kern_path(old_name
, LOOKUP_FOLLOW
, &old_path
);
1815 err
= lock_mount(path
);
1819 old
= real_mount(old_path
.mnt
);
1820 p
= real_mount(path
->mnt
);
1823 if (!check_mnt(p
) || !check_mnt(old
))
1826 if (d_unlinked(path
->dentry
))
1830 if (old_path
.dentry
!= old_path
.mnt
->mnt_root
)
1833 if (!mnt_has_parent(old
))
1836 if (S_ISDIR(path
->dentry
->d_inode
->i_mode
) !=
1837 S_ISDIR(old_path
.dentry
->d_inode
->i_mode
))
1840 * Don't move a mount residing in a shared parent.
1842 if (IS_MNT_SHARED(old
->mnt_parent
))
1845 * Don't move a mount tree containing unbindable mounts to a destination
1846 * mount which is shared.
1848 if (IS_MNT_SHARED(p
) && tree_contains_unbindable(old
))
1851 for (; mnt_has_parent(p
); p
= p
->mnt_parent
)
1855 err
= attach_recursive_mnt(old
, path
, &parent_path
);
1859 /* if the mount is moved, it should no longer be expire
1861 list_del_init(&old
->mnt_expire
);
1866 path_put(&parent_path
);
1867 path_put(&old_path
);
1871 static struct vfsmount
*fs_set_subtype(struct vfsmount
*mnt
, const char *fstype
)
1874 const char *subtype
= strchr(fstype
, '.');
1883 mnt
->mnt_sb
->s_subtype
= kstrdup(subtype
, GFP_KERNEL
);
1885 if (!mnt
->mnt_sb
->s_subtype
)
1891 return ERR_PTR(err
);
1895 * add a mount into a namespace's mount tree
1897 static int do_add_mount(struct mount
*newmnt
, struct path
*path
, int mnt_flags
)
1901 mnt_flags
&= ~(MNT_SHARED
| MNT_WRITE_HOLD
| MNT_INTERNAL
);
1903 err
= lock_mount(path
);
1908 if (unlikely(!check_mnt(real_mount(path
->mnt
)))) {
1909 /* that's acceptable only for automounts done in private ns */
1910 if (!(mnt_flags
& MNT_SHRINKABLE
))
1912 /* ... and for those we'd better have mountpoint still alive */
1913 if (!real_mount(path
->mnt
)->mnt_ns
)
1917 /* Refuse the same filesystem on the same mount point */
1919 if (path
->mnt
->mnt_sb
== newmnt
->mnt
.mnt_sb
&&
1920 path
->mnt
->mnt_root
== path
->dentry
)
1924 if (S_ISLNK(newmnt
->mnt
.mnt_root
->d_inode
->i_mode
))
1927 newmnt
->mnt
.mnt_flags
= mnt_flags
;
1928 err
= graft_tree(newmnt
, path
);
1936 * create a new mount for userspace and request it to be added into the
1939 static int do_new_mount(struct path
*path
, const char *fstype
, int flags
,
1940 int mnt_flags
, const char *name
, void *data
)
1942 struct file_system_type
*type
;
1943 struct user_namespace
*user_ns
= current
->nsproxy
->mnt_ns
->user_ns
;
1944 struct vfsmount
*mnt
;
1953 type
= get_fs_type(fstype
);
1957 if (user_ns
!= &init_user_ns
) {
1958 if (!(type
->fs_flags
& FS_USERNS_MOUNT
)) {
1959 put_filesystem(type
);
1962 /* Only in special cases allow devices from mounts
1963 * created outside the initial user namespace.
1965 if (!(type
->fs_flags
& FS_USERNS_DEV_MOUNT
)) {
1967 mnt_flags
|= MNT_NODEV
;
1971 mnt
= vfs_kern_mount(type
, flags
, name
, data
);
1972 if (!IS_ERR(mnt
) && (type
->fs_flags
& FS_HAS_SUBTYPE
) &&
1973 !mnt
->mnt_sb
->s_subtype
)
1974 mnt
= fs_set_subtype(mnt
, fstype
);
1976 put_filesystem(type
);
1978 return PTR_ERR(mnt
);
1980 err
= do_add_mount(real_mount(mnt
), path
, mnt_flags
);
1986 int finish_automount(struct vfsmount
*m
, struct path
*path
)
1988 struct mount
*mnt
= real_mount(m
);
1990 /* The new mount record should have at least 2 refs to prevent it being
1991 * expired before we get a chance to add it
1993 BUG_ON(mnt_get_count(mnt
) < 2);
1995 if (m
->mnt_sb
== path
->mnt
->mnt_sb
&&
1996 m
->mnt_root
== path
->dentry
) {
2001 err
= do_add_mount(mnt
, path
, path
->mnt
->mnt_flags
| MNT_SHRINKABLE
);
2005 /* remove m from any expiration list it may be on */
2006 if (!list_empty(&mnt
->mnt_expire
)) {
2007 down_write(&namespace_sem
);
2008 br_write_lock(&vfsmount_lock
);
2009 list_del_init(&mnt
->mnt_expire
);
2010 br_write_unlock(&vfsmount_lock
);
2011 up_write(&namespace_sem
);
2019 * mnt_set_expiry - Put a mount on an expiration list
2020 * @mnt: The mount to list.
2021 * @expiry_list: The list to add the mount to.
2023 void mnt_set_expiry(struct vfsmount
*mnt
, struct list_head
*expiry_list
)
2025 down_write(&namespace_sem
);
2026 br_write_lock(&vfsmount_lock
);
2028 list_add_tail(&real_mount(mnt
)->mnt_expire
, expiry_list
);
2030 br_write_unlock(&vfsmount_lock
);
2031 up_write(&namespace_sem
);
2033 EXPORT_SYMBOL(mnt_set_expiry
);
2036 * process a list of expirable mountpoints with the intent of discarding any
2037 * mountpoints that aren't in use and haven't been touched since last we came
2040 void mark_mounts_for_expiry(struct list_head
*mounts
)
2042 struct mount
*mnt
, *next
;
2043 LIST_HEAD(graveyard
);
2046 if (list_empty(mounts
))
2049 down_write(&namespace_sem
);
2050 br_write_lock(&vfsmount_lock
);
2052 /* extract from the expiration list every vfsmount that matches the
2053 * following criteria:
2054 * - only referenced by its parent vfsmount
2055 * - still marked for expiry (marked on the last call here; marks are
2056 * cleared by mntput())
2058 list_for_each_entry_safe(mnt
, next
, mounts
, mnt_expire
) {
2059 if (!xchg(&mnt
->mnt_expiry_mark
, 1) ||
2060 propagate_mount_busy(mnt
, 1))
2062 list_move(&mnt
->mnt_expire
, &graveyard
);
2064 while (!list_empty(&graveyard
)) {
2065 mnt
= list_first_entry(&graveyard
, struct mount
, mnt_expire
);
2066 touch_mnt_namespace(mnt
->mnt_ns
);
2067 umount_tree(mnt
, 1, &umounts
);
2069 br_write_unlock(&vfsmount_lock
);
2070 up_write(&namespace_sem
);
2072 release_mounts(&umounts
);
2075 EXPORT_SYMBOL_GPL(mark_mounts_for_expiry
);
2078 * Ripoff of 'select_parent()'
2080 * search the list of submounts for a given mountpoint, and move any
2081 * shrinkable submounts to the 'graveyard' list.
2083 static int select_submounts(struct mount
*parent
, struct list_head
*graveyard
)
2085 struct mount
*this_parent
= parent
;
2086 struct list_head
*next
;
2090 next
= this_parent
->mnt_mounts
.next
;
2092 while (next
!= &this_parent
->mnt_mounts
) {
2093 struct list_head
*tmp
= next
;
2094 struct mount
*mnt
= list_entry(tmp
, struct mount
, mnt_child
);
2097 if (!(mnt
->mnt
.mnt_flags
& MNT_SHRINKABLE
))
2100 * Descend a level if the d_mounts list is non-empty.
2102 if (!list_empty(&mnt
->mnt_mounts
)) {
2107 if (!propagate_mount_busy(mnt
, 1)) {
2108 list_move_tail(&mnt
->mnt_expire
, graveyard
);
2113 * All done at this level ... ascend and resume the search
2115 if (this_parent
!= parent
) {
2116 next
= this_parent
->mnt_child
.next
;
2117 this_parent
= this_parent
->mnt_parent
;
2124 * process a list of expirable mountpoints with the intent of discarding any
2125 * submounts of a specific parent mountpoint
2127 * vfsmount_lock must be held for write
2129 static void shrink_submounts(struct mount
*mnt
, struct list_head
*umounts
)
2131 LIST_HEAD(graveyard
);
2134 /* extract submounts of 'mountpoint' from the expiration list */
2135 while (select_submounts(mnt
, &graveyard
)) {
2136 while (!list_empty(&graveyard
)) {
2137 m
= list_first_entry(&graveyard
, struct mount
,
2139 touch_mnt_namespace(m
->mnt_ns
);
2140 umount_tree(m
, 1, umounts
);
2146 * Some copy_from_user() implementations do not return the exact number of
2147 * bytes remaining to copy on a fault. But copy_mount_options() requires that.
2148 * Note that this function differs from copy_from_user() in that it will oops
2149 * on bad values of `to', rather than returning a short copy.
2151 static long exact_copy_from_user(void *to
, const void __user
* from
,
2155 const char __user
*f
= from
;
2158 if (!access_ok(VERIFY_READ
, from
, n
))
2162 if (__get_user(c
, f
)) {
2173 int copy_mount_options(const void __user
* data
, unsigned long *where
)
2183 if (!(page
= __get_free_page(GFP_KERNEL
)))
2186 /* We only care that *some* data at the address the user
2187 * gave us is valid. Just in case, we'll zero
2188 * the remainder of the page.
2190 /* copy_from_user cannot cross TASK_SIZE ! */
2191 size
= TASK_SIZE
- (unsigned long)data
;
2192 if (size
> PAGE_SIZE
)
2195 i
= size
- exact_copy_from_user((void *)page
, data
, size
);
2201 memset((char *)page
+ i
, 0, PAGE_SIZE
- i
);
2206 int copy_mount_string(const void __user
*data
, char **where
)
2215 tmp
= strndup_user(data
, PAGE_SIZE
);
2217 return PTR_ERR(tmp
);
2224 * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to
2225 * be given to the mount() call (ie: read-only, no-dev, no-suid etc).
2227 * data is a (void *) that can point to any structure up to
2228 * PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent
2229 * information (or be NULL).
2231 * Pre-0.97 versions of mount() didn't have a flags word.
2232 * When the flags word was introduced its top half was required
2233 * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9.
2234 * Therefore, if this magic number is present, it carries no information
2235 * and must be discarded.
2237 long do_mount(const char *dev_name
, const char *dir_name
,
2238 const char *type_page
, unsigned long flags
, void *data_page
)
2245 if ((flags
& MS_MGC_MSK
) == MS_MGC_VAL
)
2246 flags
&= ~MS_MGC_MSK
;
2248 /* Basic sanity checks */
2250 if (!dir_name
|| !*dir_name
|| !memchr(dir_name
, 0, PAGE_SIZE
))
2254 ((char *)data_page
)[PAGE_SIZE
- 1] = 0;
2256 /* ... and get the mountpoint */
2257 retval
= kern_path(dir_name
, LOOKUP_FOLLOW
, &path
);
2261 retval
= security_sb_mount(dev_name
, &path
,
2262 type_page
, flags
, data_page
);
2266 /* Default to relatime unless overriden */
2267 if (!(flags
& MS_NOATIME
))
2268 mnt_flags
|= MNT_RELATIME
;
2270 /* Separate the per-mountpoint flags */
2271 if (flags
& MS_NOSUID
)
2272 mnt_flags
|= MNT_NOSUID
;
2273 if (flags
& MS_NODEV
)
2274 mnt_flags
|= MNT_NODEV
;
2275 if (flags
& MS_NOEXEC
)
2276 mnt_flags
|= MNT_NOEXEC
;
2277 if (flags
& MS_NOATIME
)
2278 mnt_flags
|= MNT_NOATIME
;
2279 if (flags
& MS_NODIRATIME
)
2280 mnt_flags
|= MNT_NODIRATIME
;
2281 if (flags
& MS_STRICTATIME
)
2282 mnt_flags
&= ~(MNT_RELATIME
| MNT_NOATIME
);
2283 if (flags
& MS_RDONLY
)
2284 mnt_flags
|= MNT_READONLY
;
2286 flags
&= ~(MS_NOSUID
| MS_NOEXEC
| MS_NODEV
| MS_ACTIVE
| MS_BORN
|
2287 MS_NOATIME
| MS_NODIRATIME
| MS_RELATIME
| MS_KERNMOUNT
|
2290 if (flags
& MS_REMOUNT
)
2291 retval
= do_remount(&path
, flags
& ~MS_REMOUNT
, mnt_flags
,
2293 else if (flags
& MS_BIND
)
2294 retval
= do_loopback(&path
, dev_name
, flags
& MS_REC
);
2295 else if (flags
& (MS_SHARED
| MS_PRIVATE
| MS_SLAVE
| MS_UNBINDABLE
))
2296 retval
= do_change_type(&path
, flags
);
2297 else if (flags
& MS_MOVE
)
2298 retval
= do_move_mount(&path
, dev_name
);
2300 retval
= do_new_mount(&path
, type_page
, flags
, mnt_flags
,
2301 dev_name
, data_page
);
2307 static void free_mnt_ns(struct mnt_namespace
*ns
)
2309 proc_free_inum(ns
->proc_inum
);
2310 put_user_ns(ns
->user_ns
);
2315 * Assign a sequence number so we can detect when we attempt to bind
2316 * mount a reference to an older mount namespace into the current
2317 * mount namespace, preventing reference counting loops. A 64bit
2318 * number incrementing at 10Ghz will take 12,427 years to wrap which
2319 * is effectively never, so we can ignore the possibility.
2321 static atomic64_t mnt_ns_seq
= ATOMIC64_INIT(1);
2323 static struct mnt_namespace
*alloc_mnt_ns(struct user_namespace
*user_ns
)
2325 struct mnt_namespace
*new_ns
;
2328 new_ns
= kmalloc(sizeof(struct mnt_namespace
), GFP_KERNEL
);
2330 return ERR_PTR(-ENOMEM
);
2331 ret
= proc_alloc_inum(&new_ns
->proc_inum
);
2334 return ERR_PTR(ret
);
2336 new_ns
->seq
= atomic64_add_return(1, &mnt_ns_seq
);
2337 atomic_set(&new_ns
->count
, 1);
2338 new_ns
->root
= NULL
;
2339 INIT_LIST_HEAD(&new_ns
->list
);
2340 init_waitqueue_head(&new_ns
->poll
);
2342 new_ns
->user_ns
= get_user_ns(user_ns
);
2347 * Allocate a new namespace structure and populate it with contents
2348 * copied from the namespace of the passed in task structure.
2350 static struct mnt_namespace
*dup_mnt_ns(struct mnt_namespace
*mnt_ns
,
2351 struct user_namespace
*user_ns
, struct fs_struct
*fs
)
2353 struct mnt_namespace
*new_ns
;
2354 struct vfsmount
*rootmnt
= NULL
, *pwdmnt
= NULL
;
2355 struct mount
*p
, *q
;
2356 struct mount
*old
= mnt_ns
->root
;
2360 new_ns
= alloc_mnt_ns(user_ns
);
2364 down_write(&namespace_sem
);
2365 /* First pass: copy the tree topology */
2366 copy_flags
= CL_COPY_ALL
| CL_EXPIRE
;
2367 if (user_ns
!= mnt_ns
->user_ns
)
2368 copy_flags
|= CL_SHARED_TO_SLAVE
;
2369 new = copy_tree(old
, old
->mnt
.mnt_root
, copy_flags
);
2371 up_write(&namespace_sem
);
2372 free_mnt_ns(new_ns
);
2373 return ERR_CAST(new);
2376 br_write_lock(&vfsmount_lock
);
2377 list_add_tail(&new_ns
->list
, &new->mnt_list
);
2378 br_write_unlock(&vfsmount_lock
);
2381 * Second pass: switch the tsk->fs->* elements and mark new vfsmounts
2382 * as belonging to new namespace. We have already acquired a private
2383 * fs_struct, so tsk->fs->lock is not needed.
2390 if (&p
->mnt
== fs
->root
.mnt
) {
2391 fs
->root
.mnt
= mntget(&q
->mnt
);
2394 if (&p
->mnt
== fs
->pwd
.mnt
) {
2395 fs
->pwd
.mnt
= mntget(&q
->mnt
);
2399 p
= next_mnt(p
, old
);
2400 q
= next_mnt(q
, new);
2402 up_write(&namespace_sem
);
2412 struct mnt_namespace
*copy_mnt_ns(unsigned long flags
, struct mnt_namespace
*ns
,
2413 struct user_namespace
*user_ns
, struct fs_struct
*new_fs
)
2415 struct mnt_namespace
*new_ns
;
2420 if (!(flags
& CLONE_NEWNS
))
2423 new_ns
= dup_mnt_ns(ns
, user_ns
, new_fs
);
2430 * create_mnt_ns - creates a private namespace and adds a root filesystem
2431 * @mnt: pointer to the new root filesystem mountpoint
2433 static struct mnt_namespace
*create_mnt_ns(struct vfsmount
*m
)
2435 struct mnt_namespace
*new_ns
= alloc_mnt_ns(&init_user_ns
);
2436 if (!IS_ERR(new_ns
)) {
2437 struct mount
*mnt
= real_mount(m
);
2438 mnt
->mnt_ns
= new_ns
;
2440 list_add(&new_ns
->list
, &mnt
->mnt_list
);
2447 struct dentry
*mount_subtree(struct vfsmount
*mnt
, const char *name
)
2449 struct mnt_namespace
*ns
;
2450 struct super_block
*s
;
2454 ns
= create_mnt_ns(mnt
);
2456 return ERR_CAST(ns
);
2458 err
= vfs_path_lookup(mnt
->mnt_root
, mnt
,
2459 name
, LOOKUP_FOLLOW
|LOOKUP_AUTOMOUNT
, &path
);
2464 return ERR_PTR(err
);
2466 /* trade a vfsmount reference for active sb one */
2467 s
= path
.mnt
->mnt_sb
;
2468 atomic_inc(&s
->s_active
);
2470 /* lock the sucker */
2471 down_write(&s
->s_umount
);
2472 /* ... and return the root of (sub)tree on it */
2475 EXPORT_SYMBOL(mount_subtree
);
2477 SYSCALL_DEFINE5(mount
, char __user
*, dev_name
, char __user
*, dir_name
,
2478 char __user
*, type
, unsigned long, flags
, void __user
*, data
)
2482 struct filename
*kernel_dir
;
2484 unsigned long data_page
;
2486 ret
= copy_mount_string(type
, &kernel_type
);
2490 kernel_dir
= getname(dir_name
);
2491 if (IS_ERR(kernel_dir
)) {
2492 ret
= PTR_ERR(kernel_dir
);
2496 ret
= copy_mount_string(dev_name
, &kernel_dev
);
2500 ret
= copy_mount_options(data
, &data_page
);
2504 ret
= do_mount(kernel_dev
, kernel_dir
->name
, kernel_type
, flags
,
2505 (void *) data_page
);
2507 free_page(data_page
);
2511 putname(kernel_dir
);
2519 * Return true if path is reachable from root
2521 * namespace_sem or vfsmount_lock is held
2523 bool is_path_reachable(struct mount
*mnt
, struct dentry
*dentry
,
2524 const struct path
*root
)
2526 while (&mnt
->mnt
!= root
->mnt
&& mnt_has_parent(mnt
)) {
2527 dentry
= mnt
->mnt_mountpoint
;
2528 mnt
= mnt
->mnt_parent
;
2530 return &mnt
->mnt
== root
->mnt
&& is_subdir(dentry
, root
->dentry
);
2533 int path_is_under(struct path
*path1
, struct path
*path2
)
2536 br_read_lock(&vfsmount_lock
);
2537 res
= is_path_reachable(real_mount(path1
->mnt
), path1
->dentry
, path2
);
2538 br_read_unlock(&vfsmount_lock
);
2541 EXPORT_SYMBOL(path_is_under
);
2544 * pivot_root Semantics:
2545 * Moves the root file system of the current process to the directory put_old,
2546 * makes new_root as the new root file system of the current process, and sets
2547 * root/cwd of all processes which had them on the current root to new_root.
2550 * The new_root and put_old must be directories, and must not be on the
2551 * same file system as the current process root. The put_old must be
2552 * underneath new_root, i.e. adding a non-zero number of /.. to the string
2553 * pointed to by put_old must yield the same directory as new_root. No other
2554 * file system may be mounted on put_old. After all, new_root is a mountpoint.
2556 * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem.
2557 * See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives
2558 * in this situation.
2561 * - we don't move root/cwd if they are not at the root (reason: if something
2562 * cared enough to change them, it's probably wrong to force them elsewhere)
2563 * - it's okay to pick a root that isn't the root of a file system, e.g.
2564 * /nfs/my_root where /nfs is the mount point. It must be a mountpoint,
2565 * though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
2568 SYSCALL_DEFINE2(pivot_root
, const char __user
*, new_root
,
2569 const char __user
*, put_old
)
2571 struct path
new, old
, parent_path
, root_parent
, root
;
2572 struct mount
*new_mnt
, *root_mnt
;
2578 error
= user_path_dir(new_root
, &new);
2582 error
= user_path_dir(put_old
, &old
);
2586 error
= security_sb_pivotroot(&old
, &new);
2590 get_fs_root(current
->fs
, &root
);
2591 error
= lock_mount(&old
);
2596 new_mnt
= real_mount(new.mnt
);
2597 root_mnt
= real_mount(root
.mnt
);
2598 if (IS_MNT_SHARED(real_mount(old
.mnt
)) ||
2599 IS_MNT_SHARED(new_mnt
->mnt_parent
) ||
2600 IS_MNT_SHARED(root_mnt
->mnt_parent
))
2602 if (!check_mnt(root_mnt
) || !check_mnt(new_mnt
))
2605 if (d_unlinked(new.dentry
))
2607 if (d_unlinked(old
.dentry
))
2610 if (new.mnt
== root
.mnt
||
2611 old
.mnt
== root
.mnt
)
2612 goto out4
; /* loop, on the same file system */
2614 if (root
.mnt
->mnt_root
!= root
.dentry
)
2615 goto out4
; /* not a mountpoint */
2616 if (!mnt_has_parent(root_mnt
))
2617 goto out4
; /* not attached */
2618 if (new.mnt
->mnt_root
!= new.dentry
)
2619 goto out4
; /* not a mountpoint */
2620 if (!mnt_has_parent(new_mnt
))
2621 goto out4
; /* not attached */
2622 /* make sure we can reach put_old from new_root */
2623 if (!is_path_reachable(real_mount(old
.mnt
), old
.dentry
, &new))
2625 br_write_lock(&vfsmount_lock
);
2626 detach_mnt(new_mnt
, &parent_path
);
2627 detach_mnt(root_mnt
, &root_parent
);
2628 /* mount old root on put_old */
2629 attach_mnt(root_mnt
, &old
);
2630 /* mount new_root on / */
2631 attach_mnt(new_mnt
, &root_parent
);
2632 touch_mnt_namespace(current
->nsproxy
->mnt_ns
);
2633 br_write_unlock(&vfsmount_lock
);
2634 chroot_fs_refs(&root
, &new);
2639 path_put(&root_parent
);
2640 path_put(&parent_path
);
2652 static void __init
init_mount_tree(void)
2654 struct vfsmount
*mnt
;
2655 struct mnt_namespace
*ns
;
2657 struct file_system_type
*type
;
2659 type
= get_fs_type("rootfs");
2661 panic("Can't find rootfs type");
2662 mnt
= vfs_kern_mount(type
, 0, "rootfs", NULL
);
2663 put_filesystem(type
);
2665 panic("Can't create rootfs");
2667 ns
= create_mnt_ns(mnt
);
2669 panic("Can't allocate initial namespace");
2671 init_task
.nsproxy
->mnt_ns
= ns
;
2675 root
.dentry
= mnt
->mnt_root
;
2677 set_fs_pwd(current
->fs
, &root
);
2678 set_fs_root(current
->fs
, &root
);
2681 void __init
mnt_init(void)
2686 init_rwsem(&namespace_sem
);
2688 mnt_cache
= kmem_cache_create("mnt_cache", sizeof(struct mount
),
2689 0, SLAB_HWCACHE_ALIGN
| SLAB_PANIC
, NULL
);
2691 mount_hashtable
= (struct list_head
*)__get_free_page(GFP_ATOMIC
);
2693 if (!mount_hashtable
)
2694 panic("Failed to allocate mount hash table\n");
2696 printk(KERN_INFO
"Mount-cache hash table entries: %lu\n", HASH_SIZE
);
2698 for (u
= 0; u
< HASH_SIZE
; u
++)
2699 INIT_LIST_HEAD(&mount_hashtable
[u
]);
2701 br_lock_init(&vfsmount_lock
);
2705 printk(KERN_WARNING
"%s: sysfs_init error: %d\n",
2707 fs_kobj
= kobject_create_and_add("fs", NULL
);
2709 printk(KERN_WARNING
"%s: kobj create error\n", __func__
);
2714 void put_mnt_ns(struct mnt_namespace
*ns
)
2716 LIST_HEAD(umount_list
);
2718 if (!atomic_dec_and_test(&ns
->count
))
2720 down_write(&namespace_sem
);
2721 br_write_lock(&vfsmount_lock
);
2722 umount_tree(ns
->root
, 0, &umount_list
);
2723 br_write_unlock(&vfsmount_lock
);
2724 up_write(&namespace_sem
);
2725 release_mounts(&umount_list
);
2729 struct vfsmount
*kern_mount_data(struct file_system_type
*type
, void *data
)
2731 struct vfsmount
*mnt
;
2732 mnt
= vfs_kern_mount(type
, MS_KERNMOUNT
, type
->name
, data
);
2735 * it is a longterm mount, don't release mnt until
2736 * we unmount before file sys is unregistered
2738 real_mount(mnt
)->mnt_ns
= MNT_NS_INTERNAL
;
2742 EXPORT_SYMBOL_GPL(kern_mount_data
);
2744 void kern_unmount(struct vfsmount
*mnt
)
2746 /* release long term mount so mount point can be released */
2747 if (!IS_ERR_OR_NULL(mnt
)) {
2748 br_write_lock(&vfsmount_lock
);
2749 real_mount(mnt
)->mnt_ns
= NULL
;
2750 br_write_unlock(&vfsmount_lock
);
2754 EXPORT_SYMBOL(kern_unmount
);
2756 bool our_mnt(struct vfsmount
*mnt
)
2758 return check_mnt(real_mount(mnt
));
2761 static void *mntns_get(struct task_struct
*task
)
2763 struct mnt_namespace
*ns
= NULL
;
2764 struct nsproxy
*nsproxy
;
2767 nsproxy
= task_nsproxy(task
);
2769 ns
= nsproxy
->mnt_ns
;
2777 static void mntns_put(void *ns
)
2782 static int mntns_install(struct nsproxy
*nsproxy
, void *ns
)
2784 struct fs_struct
*fs
= current
->fs
;
2785 struct mnt_namespace
*mnt_ns
= ns
;
2788 if (!ns_capable(mnt_ns
->user_ns
, CAP_SYS_ADMIN
) ||
2789 !nsown_capable(CAP_SYS_CHROOT
) ||
2790 !nsown_capable(CAP_SYS_ADMIN
))
2797 put_mnt_ns(nsproxy
->mnt_ns
);
2798 nsproxy
->mnt_ns
= mnt_ns
;
2801 root
.mnt
= &mnt_ns
->root
->mnt
;
2802 root
.dentry
= mnt_ns
->root
->mnt
.mnt_root
;
2804 while(d_mountpoint(root
.dentry
) && follow_down_one(&root
))
2807 /* Update the pwd and root */
2808 set_fs_pwd(fs
, &root
);
2809 set_fs_root(fs
, &root
);
2815 static unsigned int mntns_inum(void *ns
)
2817 struct mnt_namespace
*mnt_ns
= ns
;
2818 return mnt_ns
->proc_inum
;
2821 const struct proc_ns_operations mntns_operations
= {
2823 .type
= CLONE_NEWNS
,
2826 .install
= mntns_install
,