BKL: remove extraneous #include <smp_lock.h>
[linux-3.10.git] / fs / namespace.c
1 /*
2  *  linux/fs/namespace.c
3  *
4  * (C) Copyright Al Viro 2000, 2001
5  *      Released under GPL v2.
6  *
7  * Based on code from fs/super.c, copyright Linus Torvalds and others.
8  * Heavily rewritten.
9  */
10
11 #include <linux/syscalls.h>
12 #include <linux/slab.h>
13 #include <linux/sched.h>
14 #include <linux/spinlock.h>
15 #include <linux/percpu.h>
16 #include <linux/init.h>
17 #include <linux/kernel.h>
18 #include <linux/acct.h>
19 #include <linux/capability.h>
20 #include <linux/cpumask.h>
21 #include <linux/module.h>
22 #include <linux/sysfs.h>
23 #include <linux/seq_file.h>
24 #include <linux/mnt_namespace.h>
25 #include <linux/namei.h>
26 #include <linux/nsproxy.h>
27 #include <linux/security.h>
28 #include <linux/mount.h>
29 #include <linux/ramfs.h>
30 #include <linux/log2.h>
31 #include <linux/idr.h>
32 #include <linux/fs_struct.h>
33 #include <linux/fsnotify.h>
34 #include <asm/uaccess.h>
35 #include <asm/unistd.h>
36 #include "pnode.h"
37 #include "internal.h"
38
39 #define HASH_SHIFT ilog2(PAGE_SIZE / sizeof(struct list_head))
40 #define HASH_SIZE (1UL << HASH_SHIFT)
41
42 static int event;
43 static DEFINE_IDA(mnt_id_ida);
44 static DEFINE_IDA(mnt_group_ida);
45 static DEFINE_SPINLOCK(mnt_id_lock);
46 static int mnt_id_start = 0;
47 static int mnt_group_start = 1;
48
49 static struct list_head *mount_hashtable __read_mostly;
50 static struct kmem_cache *mnt_cache __read_mostly;
51 static struct rw_semaphore namespace_sem;
52
53 /* /sys/fs */
54 struct kobject *fs_kobj;
55 EXPORT_SYMBOL_GPL(fs_kobj);
56
57 /*
58  * vfsmount lock may be taken for read to prevent changes to the
59  * vfsmount hash, ie. during mountpoint lookups or walking back
60  * up the tree.
61  *
62  * It should be taken for write in all cases where the vfsmount
63  * tree or hash is modified or when a vfsmount structure is modified.
64  */
65 DEFINE_BRLOCK(vfsmount_lock);
66
67 static inline unsigned long hash(struct vfsmount *mnt, struct dentry *dentry)
68 {
69         unsigned long tmp = ((unsigned long)mnt / L1_CACHE_BYTES);
70         tmp += ((unsigned long)dentry / L1_CACHE_BYTES);
71         tmp = tmp + (tmp >> HASH_SHIFT);
72         return tmp & (HASH_SIZE - 1);
73 }
74
75 #define MNT_WRITER_UNDERFLOW_LIMIT -(1<<16)
76
77 /*
78  * allocation is serialized by namespace_sem, but we need the spinlock to
79  * serialize with freeing.
80  */
81 static int mnt_alloc_id(struct vfsmount *mnt)
82 {
83         int res;
84
85 retry:
86         ida_pre_get(&mnt_id_ida, GFP_KERNEL);
87         spin_lock(&mnt_id_lock);
88         res = ida_get_new_above(&mnt_id_ida, mnt_id_start, &mnt->mnt_id);
89         if (!res)
90                 mnt_id_start = mnt->mnt_id + 1;
91         spin_unlock(&mnt_id_lock);
92         if (res == -EAGAIN)
93                 goto retry;
94
95         return res;
96 }
97
98 static void mnt_free_id(struct vfsmount *mnt)
99 {
100         int id = mnt->mnt_id;
101         spin_lock(&mnt_id_lock);
102         ida_remove(&mnt_id_ida, id);
103         if (mnt_id_start > id)
104                 mnt_id_start = id;
105         spin_unlock(&mnt_id_lock);
106 }
107
108 /*
109  * Allocate a new peer group ID
110  *
111  * mnt_group_ida is protected by namespace_sem
112  */
113 static int mnt_alloc_group_id(struct vfsmount *mnt)
114 {
115         int res;
116
117         if (!ida_pre_get(&mnt_group_ida, GFP_KERNEL))
118                 return -ENOMEM;
119
120         res = ida_get_new_above(&mnt_group_ida,
121                                 mnt_group_start,
122                                 &mnt->mnt_group_id);
123         if (!res)
124                 mnt_group_start = mnt->mnt_group_id + 1;
125
126         return res;
127 }
128
129 /*
130  * Release a peer group ID
131  */
132 void mnt_release_group_id(struct vfsmount *mnt)
133 {
134         int id = mnt->mnt_group_id;
135         ida_remove(&mnt_group_ida, id);
136         if (mnt_group_start > id)
137                 mnt_group_start = id;
138         mnt->mnt_group_id = 0;
139 }
140
141 struct vfsmount *alloc_vfsmnt(const char *name)
142 {
143         struct vfsmount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
144         if (mnt) {
145                 int err;
146
147                 err = mnt_alloc_id(mnt);
148                 if (err)
149                         goto out_free_cache;
150
151                 if (name) {
152                         mnt->mnt_devname = kstrdup(name, GFP_KERNEL);
153                         if (!mnt->mnt_devname)
154                                 goto out_free_id;
155                 }
156
157                 atomic_set(&mnt->mnt_count, 1);
158                 INIT_LIST_HEAD(&mnt->mnt_hash);
159                 INIT_LIST_HEAD(&mnt->mnt_child);
160                 INIT_LIST_HEAD(&mnt->mnt_mounts);
161                 INIT_LIST_HEAD(&mnt->mnt_list);
162                 INIT_LIST_HEAD(&mnt->mnt_expire);
163                 INIT_LIST_HEAD(&mnt->mnt_share);
164                 INIT_LIST_HEAD(&mnt->mnt_slave_list);
165                 INIT_LIST_HEAD(&mnt->mnt_slave);
166 #ifdef CONFIG_FSNOTIFY
167                 INIT_HLIST_HEAD(&mnt->mnt_fsnotify_marks);
168 #endif
169 #ifdef CONFIG_SMP
170                 mnt->mnt_writers = alloc_percpu(int);
171                 if (!mnt->mnt_writers)
172                         goto out_free_devname;
173 #else
174                 mnt->mnt_writers = 0;
175 #endif
176         }
177         return mnt;
178
179 #ifdef CONFIG_SMP
180 out_free_devname:
181         kfree(mnt->mnt_devname);
182 #endif
183 out_free_id:
184         mnt_free_id(mnt);
185 out_free_cache:
186         kmem_cache_free(mnt_cache, mnt);
187         return NULL;
188 }
189
190 /*
191  * Most r/o checks on a fs are for operations that take
192  * discrete amounts of time, like a write() or unlink().
193  * We must keep track of when those operations start
194  * (for permission checks) and when they end, so that
195  * we can determine when writes are able to occur to
196  * a filesystem.
197  */
198 /*
199  * __mnt_is_readonly: check whether a mount is read-only
200  * @mnt: the mount to check for its write status
201  *
202  * This shouldn't be used directly ouside of the VFS.
203  * It does not guarantee that the filesystem will stay
204  * r/w, just that it is right *now*.  This can not and
205  * should not be used in place of IS_RDONLY(inode).
206  * mnt_want/drop_write() will _keep_ the filesystem
207  * r/w.
208  */
209 int __mnt_is_readonly(struct vfsmount *mnt)
210 {
211         if (mnt->mnt_flags & MNT_READONLY)
212                 return 1;
213         if (mnt->mnt_sb->s_flags & MS_RDONLY)
214                 return 1;
215         return 0;
216 }
217 EXPORT_SYMBOL_GPL(__mnt_is_readonly);
218
219 static inline void inc_mnt_writers(struct vfsmount *mnt)
220 {
221 #ifdef CONFIG_SMP
222         (*per_cpu_ptr(mnt->mnt_writers, smp_processor_id()))++;
223 #else
224         mnt->mnt_writers++;
225 #endif
226 }
227
228 static inline void dec_mnt_writers(struct vfsmount *mnt)
229 {
230 #ifdef CONFIG_SMP
231         (*per_cpu_ptr(mnt->mnt_writers, smp_processor_id()))--;
232 #else
233         mnt->mnt_writers--;
234 #endif
235 }
236
237 static unsigned int count_mnt_writers(struct vfsmount *mnt)
238 {
239 #ifdef CONFIG_SMP
240         unsigned int count = 0;
241         int cpu;
242
243         for_each_possible_cpu(cpu) {
244                 count += *per_cpu_ptr(mnt->mnt_writers, cpu);
245         }
246
247         return count;
248 #else
249         return mnt->mnt_writers;
250 #endif
251 }
252
253 /*
254  * Most r/o checks on a fs are for operations that take
255  * discrete amounts of time, like a write() or unlink().
256  * We must keep track of when those operations start
257  * (for permission checks) and when they end, so that
258  * we can determine when writes are able to occur to
259  * a filesystem.
260  */
261 /**
262  * mnt_want_write - get write access to a mount
263  * @mnt: the mount on which to take a write
264  *
265  * This tells the low-level filesystem that a write is
266  * about to be performed to it, and makes sure that
267  * writes are allowed before returning success.  When
268  * the write operation is finished, mnt_drop_write()
269  * must be called.  This is effectively a refcount.
270  */
271 int mnt_want_write(struct vfsmount *mnt)
272 {
273         int ret = 0;
274
275         preempt_disable();
276         inc_mnt_writers(mnt);
277         /*
278          * The store to inc_mnt_writers must be visible before we pass
279          * MNT_WRITE_HOLD loop below, so that the slowpath can see our
280          * incremented count after it has set MNT_WRITE_HOLD.
281          */
282         smp_mb();
283         while (mnt->mnt_flags & MNT_WRITE_HOLD)
284                 cpu_relax();
285         /*
286          * After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will
287          * be set to match its requirements. So we must not load that until
288          * MNT_WRITE_HOLD is cleared.
289          */
290         smp_rmb();
291         if (__mnt_is_readonly(mnt)) {
292                 dec_mnt_writers(mnt);
293                 ret = -EROFS;
294                 goto out;
295         }
296 out:
297         preempt_enable();
298         return ret;
299 }
300 EXPORT_SYMBOL_GPL(mnt_want_write);
301
302 /**
303  * mnt_clone_write - get write access to a mount
304  * @mnt: the mount on which to take a write
305  *
306  * This is effectively like mnt_want_write, except
307  * it must only be used to take an extra write reference
308  * on a mountpoint that we already know has a write reference
309  * on it. This allows some optimisation.
310  *
311  * After finished, mnt_drop_write must be called as usual to
312  * drop the reference.
313  */
314 int mnt_clone_write(struct vfsmount *mnt)
315 {
316         /* superblock may be r/o */
317         if (__mnt_is_readonly(mnt))
318                 return -EROFS;
319         preempt_disable();
320         inc_mnt_writers(mnt);
321         preempt_enable();
322         return 0;
323 }
324 EXPORT_SYMBOL_GPL(mnt_clone_write);
325
326 /**
327  * mnt_want_write_file - get write access to a file's mount
328  * @file: the file who's mount on which to take a write
329  *
330  * This is like mnt_want_write, but it takes a file and can
331  * do some optimisations if the file is open for write already
332  */
333 int mnt_want_write_file(struct file *file)
334 {
335         struct inode *inode = file->f_dentry->d_inode;
336         if (!(file->f_mode & FMODE_WRITE) || special_file(inode->i_mode))
337                 return mnt_want_write(file->f_path.mnt);
338         else
339                 return mnt_clone_write(file->f_path.mnt);
340 }
341 EXPORT_SYMBOL_GPL(mnt_want_write_file);
342
343 /**
344  * mnt_drop_write - give up write access to a mount
345  * @mnt: the mount on which to give up write access
346  *
347  * Tells the low-level filesystem that we are done
348  * performing writes to it.  Must be matched with
349  * mnt_want_write() call above.
350  */
351 void mnt_drop_write(struct vfsmount *mnt)
352 {
353         preempt_disable();
354         dec_mnt_writers(mnt);
355         preempt_enable();
356 }
357 EXPORT_SYMBOL_GPL(mnt_drop_write);
358
359 static int mnt_make_readonly(struct vfsmount *mnt)
360 {
361         int ret = 0;
362
363         br_write_lock(vfsmount_lock);
364         mnt->mnt_flags |= MNT_WRITE_HOLD;
365         /*
366          * After storing MNT_WRITE_HOLD, we'll read the counters. This store
367          * should be visible before we do.
368          */
369         smp_mb();
370
371         /*
372          * With writers on hold, if this value is zero, then there are
373          * definitely no active writers (although held writers may subsequently
374          * increment the count, they'll have to wait, and decrement it after
375          * seeing MNT_READONLY).
376          *
377          * It is OK to have counter incremented on one CPU and decremented on
378          * another: the sum will add up correctly. The danger would be when we
379          * sum up each counter, if we read a counter before it is incremented,
380          * but then read another CPU's count which it has been subsequently
381          * decremented from -- we would see more decrements than we should.
382          * MNT_WRITE_HOLD protects against this scenario, because
383          * mnt_want_write first increments count, then smp_mb, then spins on
384          * MNT_WRITE_HOLD, so it can't be decremented by another CPU while
385          * we're counting up here.
386          */
387         if (count_mnt_writers(mnt) > 0)
388                 ret = -EBUSY;
389         else
390                 mnt->mnt_flags |= MNT_READONLY;
391         /*
392          * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers
393          * that become unheld will see MNT_READONLY.
394          */
395         smp_wmb();
396         mnt->mnt_flags &= ~MNT_WRITE_HOLD;
397         br_write_unlock(vfsmount_lock);
398         return ret;
399 }
400
401 static void __mnt_unmake_readonly(struct vfsmount *mnt)
402 {
403         br_write_lock(vfsmount_lock);
404         mnt->mnt_flags &= ~MNT_READONLY;
405         br_write_unlock(vfsmount_lock);
406 }
407
408 void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb)
409 {
410         mnt->mnt_sb = sb;
411         mnt->mnt_root = dget(sb->s_root);
412 }
413
414 EXPORT_SYMBOL(simple_set_mnt);
415
416 void free_vfsmnt(struct vfsmount *mnt)
417 {
418         kfree(mnt->mnt_devname);
419         mnt_free_id(mnt);
420 #ifdef CONFIG_SMP
421         free_percpu(mnt->mnt_writers);
422 #endif
423         kmem_cache_free(mnt_cache, mnt);
424 }
425
426 /*
427  * find the first or last mount at @dentry on vfsmount @mnt depending on
428  * @dir. If @dir is set return the first mount else return the last mount.
429  * vfsmount_lock must be held for read or write.
430  */
431 struct vfsmount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry,
432                               int dir)
433 {
434         struct list_head *head = mount_hashtable + hash(mnt, dentry);
435         struct list_head *tmp = head;
436         struct vfsmount *p, *found = NULL;
437
438         for (;;) {
439                 tmp = dir ? tmp->next : tmp->prev;
440                 p = NULL;
441                 if (tmp == head)
442                         break;
443                 p = list_entry(tmp, struct vfsmount, mnt_hash);
444                 if (p->mnt_parent == mnt && p->mnt_mountpoint == dentry) {
445                         found = p;
446                         break;
447                 }
448         }
449         return found;
450 }
451
452 /*
453  * lookup_mnt increments the ref count before returning
454  * the vfsmount struct.
455  */
456 struct vfsmount *lookup_mnt(struct path *path)
457 {
458         struct vfsmount *child_mnt;
459
460         br_read_lock(vfsmount_lock);
461         if ((child_mnt = __lookup_mnt(path->mnt, path->dentry, 1)))
462                 mntget(child_mnt);
463         br_read_unlock(vfsmount_lock);
464         return child_mnt;
465 }
466
467 static inline int check_mnt(struct vfsmount *mnt)
468 {
469         return mnt->mnt_ns == current->nsproxy->mnt_ns;
470 }
471
472 /*
473  * vfsmount lock must be held for write
474  */
475 static void touch_mnt_namespace(struct mnt_namespace *ns)
476 {
477         if (ns) {
478                 ns->event = ++event;
479                 wake_up_interruptible(&ns->poll);
480         }
481 }
482
483 /*
484  * vfsmount lock must be held for write
485  */
486 static void __touch_mnt_namespace(struct mnt_namespace *ns)
487 {
488         if (ns && ns->event != event) {
489                 ns->event = event;
490                 wake_up_interruptible(&ns->poll);
491         }
492 }
493
494 /*
495  * vfsmount lock must be held for write
496  */
497 static void detach_mnt(struct vfsmount *mnt, struct path *old_path)
498 {
499         old_path->dentry = mnt->mnt_mountpoint;
500         old_path->mnt = mnt->mnt_parent;
501         mnt->mnt_parent = mnt;
502         mnt->mnt_mountpoint = mnt->mnt_root;
503         list_del_init(&mnt->mnt_child);
504         list_del_init(&mnt->mnt_hash);
505         old_path->dentry->d_mounted--;
506 }
507
508 /*
509  * vfsmount lock must be held for write
510  */
511 void mnt_set_mountpoint(struct vfsmount *mnt, struct dentry *dentry,
512                         struct vfsmount *child_mnt)
513 {
514         child_mnt->mnt_parent = mntget(mnt);
515         child_mnt->mnt_mountpoint = dget(dentry);
516         dentry->d_mounted++;
517 }
518
519 /*
520  * vfsmount lock must be held for write
521  */
522 static void attach_mnt(struct vfsmount *mnt, struct path *path)
523 {
524         mnt_set_mountpoint(path->mnt, path->dentry, mnt);
525         list_add_tail(&mnt->mnt_hash, mount_hashtable +
526                         hash(path->mnt, path->dentry));
527         list_add_tail(&mnt->mnt_child, &path->mnt->mnt_mounts);
528 }
529
530 /*
531  * vfsmount lock must be held for write
532  */
533 static void commit_tree(struct vfsmount *mnt)
534 {
535         struct vfsmount *parent = mnt->mnt_parent;
536         struct vfsmount *m;
537         LIST_HEAD(head);
538         struct mnt_namespace *n = parent->mnt_ns;
539
540         BUG_ON(parent == mnt);
541
542         list_add_tail(&head, &mnt->mnt_list);
543         list_for_each_entry(m, &head, mnt_list)
544                 m->mnt_ns = n;
545         list_splice(&head, n->list.prev);
546
547         list_add_tail(&mnt->mnt_hash, mount_hashtable +
548                                 hash(parent, mnt->mnt_mountpoint));
549         list_add_tail(&mnt->mnt_child, &parent->mnt_mounts);
550         touch_mnt_namespace(n);
551 }
552
553 static struct vfsmount *next_mnt(struct vfsmount *p, struct vfsmount *root)
554 {
555         struct list_head *next = p->mnt_mounts.next;
556         if (next == &p->mnt_mounts) {
557                 while (1) {
558                         if (p == root)
559                                 return NULL;
560                         next = p->mnt_child.next;
561                         if (next != &p->mnt_parent->mnt_mounts)
562                                 break;
563                         p = p->mnt_parent;
564                 }
565         }
566         return list_entry(next, struct vfsmount, mnt_child);
567 }
568
569 static struct vfsmount *skip_mnt_tree(struct vfsmount *p)
570 {
571         struct list_head *prev = p->mnt_mounts.prev;
572         while (prev != &p->mnt_mounts) {
573                 p = list_entry(prev, struct vfsmount, mnt_child);
574                 prev = p->mnt_mounts.prev;
575         }
576         return p;
577 }
578
579 static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root,
580                                         int flag)
581 {
582         struct super_block *sb = old->mnt_sb;
583         struct vfsmount *mnt = alloc_vfsmnt(old->mnt_devname);
584
585         if (mnt) {
586                 if (flag & (CL_SLAVE | CL_PRIVATE))
587                         mnt->mnt_group_id = 0; /* not a peer of original */
588                 else
589                         mnt->mnt_group_id = old->mnt_group_id;
590
591                 if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) {
592                         int err = mnt_alloc_group_id(mnt);
593                         if (err)
594                                 goto out_free;
595                 }
596
597                 mnt->mnt_flags = old->mnt_flags & ~MNT_WRITE_HOLD;
598                 atomic_inc(&sb->s_active);
599                 mnt->mnt_sb = sb;
600                 mnt->mnt_root = dget(root);
601                 mnt->mnt_mountpoint = mnt->mnt_root;
602                 mnt->mnt_parent = mnt;
603
604                 if (flag & CL_SLAVE) {
605                         list_add(&mnt->mnt_slave, &old->mnt_slave_list);
606                         mnt->mnt_master = old;
607                         CLEAR_MNT_SHARED(mnt);
608                 } else if (!(flag & CL_PRIVATE)) {
609                         if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(old))
610                                 list_add(&mnt->mnt_share, &old->mnt_share);
611                         if (IS_MNT_SLAVE(old))
612                                 list_add(&mnt->mnt_slave, &old->mnt_slave);
613                         mnt->mnt_master = old->mnt_master;
614                 }
615                 if (flag & CL_MAKE_SHARED)
616                         set_mnt_shared(mnt);
617
618                 /* stick the duplicate mount on the same expiry list
619                  * as the original if that was on one */
620                 if (flag & CL_EXPIRE) {
621                         if (!list_empty(&old->mnt_expire))
622                                 list_add(&mnt->mnt_expire, &old->mnt_expire);
623                 }
624         }
625         return mnt;
626
627  out_free:
628         free_vfsmnt(mnt);
629         return NULL;
630 }
631
632 static inline void __mntput(struct vfsmount *mnt)
633 {
634         struct super_block *sb = mnt->mnt_sb;
635         /*
636          * This probably indicates that somebody messed
637          * up a mnt_want/drop_write() pair.  If this
638          * happens, the filesystem was probably unable
639          * to make r/w->r/o transitions.
640          */
641         /*
642          * atomic_dec_and_lock() used to deal with ->mnt_count decrements
643          * provides barriers, so count_mnt_writers() below is safe.  AV
644          */
645         WARN_ON(count_mnt_writers(mnt));
646         fsnotify_vfsmount_delete(mnt);
647         dput(mnt->mnt_root);
648         free_vfsmnt(mnt);
649         deactivate_super(sb);
650 }
651
652 void mntput_no_expire(struct vfsmount *mnt)
653 {
654 repeat:
655         if (atomic_add_unless(&mnt->mnt_count, -1, 1))
656                 return;
657         br_write_lock(vfsmount_lock);
658         if (!atomic_dec_and_test(&mnt->mnt_count)) {
659                 br_write_unlock(vfsmount_lock);
660                 return;
661         }
662         if (likely(!mnt->mnt_pinned)) {
663                 br_write_unlock(vfsmount_lock);
664                 __mntput(mnt);
665                 return;
666         }
667         atomic_add(mnt->mnt_pinned + 1, &mnt->mnt_count);
668         mnt->mnt_pinned = 0;
669         br_write_unlock(vfsmount_lock);
670         acct_auto_close_mnt(mnt);
671         goto repeat;
672 }
673 EXPORT_SYMBOL(mntput_no_expire);
674
675 void mnt_pin(struct vfsmount *mnt)
676 {
677         br_write_lock(vfsmount_lock);
678         mnt->mnt_pinned++;
679         br_write_unlock(vfsmount_lock);
680 }
681
682 EXPORT_SYMBOL(mnt_pin);
683
684 void mnt_unpin(struct vfsmount *mnt)
685 {
686         br_write_lock(vfsmount_lock);
687         if (mnt->mnt_pinned) {
688                 atomic_inc(&mnt->mnt_count);
689                 mnt->mnt_pinned--;
690         }
691         br_write_unlock(vfsmount_lock);
692 }
693
694 EXPORT_SYMBOL(mnt_unpin);
695
696 static inline void mangle(struct seq_file *m, const char *s)
697 {
698         seq_escape(m, s, " \t\n\\");
699 }
700
701 /*
702  * Simple .show_options callback for filesystems which don't want to
703  * implement more complex mount option showing.
704  *
705  * See also save_mount_options().
706  */
707 int generic_show_options(struct seq_file *m, struct vfsmount *mnt)
708 {
709         const char *options;
710
711         rcu_read_lock();
712         options = rcu_dereference(mnt->mnt_sb->s_options);
713
714         if (options != NULL && options[0]) {
715                 seq_putc(m, ',');
716                 mangle(m, options);
717         }
718         rcu_read_unlock();
719
720         return 0;
721 }
722 EXPORT_SYMBOL(generic_show_options);
723
724 /*
725  * If filesystem uses generic_show_options(), this function should be
726  * called from the fill_super() callback.
727  *
728  * The .remount_fs callback usually needs to be handled in a special
729  * way, to make sure, that previous options are not overwritten if the
730  * remount fails.
731  *
732  * Also note, that if the filesystem's .remount_fs function doesn't
733  * reset all options to their default value, but changes only newly
734  * given options, then the displayed options will not reflect reality
735  * any more.
736  */
737 void save_mount_options(struct super_block *sb, char *options)
738 {
739         BUG_ON(sb->s_options);
740         rcu_assign_pointer(sb->s_options, kstrdup(options, GFP_KERNEL));
741 }
742 EXPORT_SYMBOL(save_mount_options);
743
744 void replace_mount_options(struct super_block *sb, char *options)
745 {
746         char *old = sb->s_options;
747         rcu_assign_pointer(sb->s_options, options);
748         if (old) {
749                 synchronize_rcu();
750                 kfree(old);
751         }
752 }
753 EXPORT_SYMBOL(replace_mount_options);
754
755 #ifdef CONFIG_PROC_FS
756 /* iterator */
757 static void *m_start(struct seq_file *m, loff_t *pos)
758 {
759         struct proc_mounts *p = m->private;
760
761         down_read(&namespace_sem);
762         return seq_list_start(&p->ns->list, *pos);
763 }
764
765 static void *m_next(struct seq_file *m, void *v, loff_t *pos)
766 {
767         struct proc_mounts *p = m->private;
768
769         return seq_list_next(v, &p->ns->list, pos);
770 }
771
772 static void m_stop(struct seq_file *m, void *v)
773 {
774         up_read(&namespace_sem);
775 }
776
777 int mnt_had_events(struct proc_mounts *p)
778 {
779         struct mnt_namespace *ns = p->ns;
780         int res = 0;
781
782         br_read_lock(vfsmount_lock);
783         if (p->event != ns->event) {
784                 p->event = ns->event;
785                 res = 1;
786         }
787         br_read_unlock(vfsmount_lock);
788
789         return res;
790 }
791
792 struct proc_fs_info {
793         int flag;
794         const char *str;
795 };
796
797 static int show_sb_opts(struct seq_file *m, struct super_block *sb)
798 {
799         static const struct proc_fs_info fs_info[] = {
800                 { MS_SYNCHRONOUS, ",sync" },
801                 { MS_DIRSYNC, ",dirsync" },
802                 { MS_MANDLOCK, ",mand" },
803                 { 0, NULL }
804         };
805         const struct proc_fs_info *fs_infop;
806
807         for (fs_infop = fs_info; fs_infop->flag; fs_infop++) {
808                 if (sb->s_flags & fs_infop->flag)
809                         seq_puts(m, fs_infop->str);
810         }
811
812         return security_sb_show_options(m, sb);
813 }
814
815 static void show_mnt_opts(struct seq_file *m, struct vfsmount *mnt)
816 {
817         static const struct proc_fs_info mnt_info[] = {
818                 { MNT_NOSUID, ",nosuid" },
819                 { MNT_NODEV, ",nodev" },
820                 { MNT_NOEXEC, ",noexec" },
821                 { MNT_NOATIME, ",noatime" },
822                 { MNT_NODIRATIME, ",nodiratime" },
823                 { MNT_RELATIME, ",relatime" },
824                 { 0, NULL }
825         };
826         const struct proc_fs_info *fs_infop;
827
828         for (fs_infop = mnt_info; fs_infop->flag; fs_infop++) {
829                 if (mnt->mnt_flags & fs_infop->flag)
830                         seq_puts(m, fs_infop->str);
831         }
832 }
833
834 static void show_type(struct seq_file *m, struct super_block *sb)
835 {
836         mangle(m, sb->s_type->name);
837         if (sb->s_subtype && sb->s_subtype[0]) {
838                 seq_putc(m, '.');
839                 mangle(m, sb->s_subtype);
840         }
841 }
842
843 static int show_vfsmnt(struct seq_file *m, void *v)
844 {
845         struct vfsmount *mnt = list_entry(v, struct vfsmount, mnt_list);
846         int err = 0;
847         struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
848
849         mangle(m, mnt->mnt_devname ? mnt->mnt_devname : "none");
850         seq_putc(m, ' ');
851         seq_path(m, &mnt_path, " \t\n\\");
852         seq_putc(m, ' ');
853         show_type(m, mnt->mnt_sb);
854         seq_puts(m, __mnt_is_readonly(mnt) ? " ro" : " rw");
855         err = show_sb_opts(m, mnt->mnt_sb);
856         if (err)
857                 goto out;
858         show_mnt_opts(m, mnt);
859         if (mnt->mnt_sb->s_op->show_options)
860                 err = mnt->mnt_sb->s_op->show_options(m, mnt);
861         seq_puts(m, " 0 0\n");
862 out:
863         return err;
864 }
865
866 const struct seq_operations mounts_op = {
867         .start  = m_start,
868         .next   = m_next,
869         .stop   = m_stop,
870         .show   = show_vfsmnt
871 };
872
873 static int show_mountinfo(struct seq_file *m, void *v)
874 {
875         struct proc_mounts *p = m->private;
876         struct vfsmount *mnt = list_entry(v, struct vfsmount, mnt_list);
877         struct super_block *sb = mnt->mnt_sb;
878         struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
879         struct path root = p->root;
880         int err = 0;
881
882         seq_printf(m, "%i %i %u:%u ", mnt->mnt_id, mnt->mnt_parent->mnt_id,
883                    MAJOR(sb->s_dev), MINOR(sb->s_dev));
884         seq_dentry(m, mnt->mnt_root, " \t\n\\");
885         seq_putc(m, ' ');
886         seq_path_root(m, &mnt_path, &root, " \t\n\\");
887         if (root.mnt != p->root.mnt || root.dentry != p->root.dentry) {
888                 /*
889                  * Mountpoint is outside root, discard that one.  Ugly,
890                  * but less so than trying to do that in iterator in a
891                  * race-free way (due to renames).
892                  */
893                 return SEQ_SKIP;
894         }
895         seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw");
896         show_mnt_opts(m, mnt);
897
898         /* Tagged fields ("foo:X" or "bar") */
899         if (IS_MNT_SHARED(mnt))
900                 seq_printf(m, " shared:%i", mnt->mnt_group_id);
901         if (IS_MNT_SLAVE(mnt)) {
902                 int master = mnt->mnt_master->mnt_group_id;
903                 int dom = get_dominating_id(mnt, &p->root);
904                 seq_printf(m, " master:%i", master);
905                 if (dom && dom != master)
906                         seq_printf(m, " propagate_from:%i", dom);
907         }
908         if (IS_MNT_UNBINDABLE(mnt))
909                 seq_puts(m, " unbindable");
910
911         /* Filesystem specific data */
912         seq_puts(m, " - ");
913         show_type(m, sb);
914         seq_putc(m, ' ');
915         mangle(m, mnt->mnt_devname ? mnt->mnt_devname : "none");
916         seq_puts(m, sb->s_flags & MS_RDONLY ? " ro" : " rw");
917         err = show_sb_opts(m, sb);
918         if (err)
919                 goto out;
920         if (sb->s_op->show_options)
921                 err = sb->s_op->show_options(m, mnt);
922         seq_putc(m, '\n');
923 out:
924         return err;
925 }
926
927 const struct seq_operations mountinfo_op = {
928         .start  = m_start,
929         .next   = m_next,
930         .stop   = m_stop,
931         .show   = show_mountinfo,
932 };
933
934 static int show_vfsstat(struct seq_file *m, void *v)
935 {
936         struct vfsmount *mnt = list_entry(v, struct vfsmount, mnt_list);
937         struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
938         int err = 0;
939
940         /* device */
941         if (mnt->mnt_devname) {
942                 seq_puts(m, "device ");
943                 mangle(m, mnt->mnt_devname);
944         } else
945                 seq_puts(m, "no device");
946
947         /* mount point */
948         seq_puts(m, " mounted on ");
949         seq_path(m, &mnt_path, " \t\n\\");
950         seq_putc(m, ' ');
951
952         /* file system type */
953         seq_puts(m, "with fstype ");
954         show_type(m, mnt->mnt_sb);
955
956         /* optional statistics */
957         if (mnt->mnt_sb->s_op->show_stats) {
958                 seq_putc(m, ' ');
959                 err = mnt->mnt_sb->s_op->show_stats(m, mnt);
960         }
961
962         seq_putc(m, '\n');
963         return err;
964 }
965
966 const struct seq_operations mountstats_op = {
967         .start  = m_start,
968         .next   = m_next,
969         .stop   = m_stop,
970         .show   = show_vfsstat,
971 };
972 #endif  /* CONFIG_PROC_FS */
973
974 /**
975  * may_umount_tree - check if a mount tree is busy
976  * @mnt: root of mount tree
977  *
978  * This is called to check if a tree of mounts has any
979  * open files, pwds, chroots or sub mounts that are
980  * busy.
981  */
982 int may_umount_tree(struct vfsmount *mnt)
983 {
984         int actual_refs = 0;
985         int minimum_refs = 0;
986         struct vfsmount *p;
987
988         br_read_lock(vfsmount_lock);
989         for (p = mnt; p; p = next_mnt(p, mnt)) {
990                 actual_refs += atomic_read(&p->mnt_count);
991                 minimum_refs += 2;
992         }
993         br_read_unlock(vfsmount_lock);
994
995         if (actual_refs > minimum_refs)
996                 return 0;
997
998         return 1;
999 }
1000
1001 EXPORT_SYMBOL(may_umount_tree);
1002
1003 /**
1004  * may_umount - check if a mount point is busy
1005  * @mnt: root of mount
1006  *
1007  * This is called to check if a mount point has any
1008  * open files, pwds, chroots or sub mounts. If the
1009  * mount has sub mounts this will return busy
1010  * regardless of whether the sub mounts are busy.
1011  *
1012  * Doesn't take quota and stuff into account. IOW, in some cases it will
1013  * give false negatives. The main reason why it's here is that we need
1014  * a non-destructive way to look for easily umountable filesystems.
1015  */
1016 int may_umount(struct vfsmount *mnt)
1017 {
1018         int ret = 1;
1019         down_read(&namespace_sem);
1020         br_read_lock(vfsmount_lock);
1021         if (propagate_mount_busy(mnt, 2))
1022                 ret = 0;
1023         br_read_unlock(vfsmount_lock);
1024         up_read(&namespace_sem);
1025         return ret;
1026 }
1027
1028 EXPORT_SYMBOL(may_umount);
1029
1030 void release_mounts(struct list_head *head)
1031 {
1032         struct vfsmount *mnt;
1033         while (!list_empty(head)) {
1034                 mnt = list_first_entry(head, struct vfsmount, mnt_hash);
1035                 list_del_init(&mnt->mnt_hash);
1036                 if (mnt->mnt_parent != mnt) {
1037                         struct dentry *dentry;
1038                         struct vfsmount *m;
1039
1040                         br_write_lock(vfsmount_lock);
1041                         dentry = mnt->mnt_mountpoint;
1042                         m = mnt->mnt_parent;
1043                         mnt->mnt_mountpoint = mnt->mnt_root;
1044                         mnt->mnt_parent = mnt;
1045                         m->mnt_ghosts--;
1046                         br_write_unlock(vfsmount_lock);
1047                         dput(dentry);
1048                         mntput(m);
1049                 }
1050                 mntput(mnt);
1051         }
1052 }
1053
1054 /*
1055  * vfsmount lock must be held for write
1056  * namespace_sem must be held for write
1057  */
1058 void umount_tree(struct vfsmount *mnt, int propagate, struct list_head *kill)
1059 {
1060         struct vfsmount *p;
1061
1062         for (p = mnt; p; p = next_mnt(p, mnt))
1063                 list_move(&p->mnt_hash, kill);
1064
1065         if (propagate)
1066                 propagate_umount(kill);
1067
1068         list_for_each_entry(p, kill, mnt_hash) {
1069                 list_del_init(&p->mnt_expire);
1070                 list_del_init(&p->mnt_list);
1071                 __touch_mnt_namespace(p->mnt_ns);
1072                 p->mnt_ns = NULL;
1073                 list_del_init(&p->mnt_child);
1074                 if (p->mnt_parent != p) {
1075                         p->mnt_parent->mnt_ghosts++;
1076                         p->mnt_mountpoint->d_mounted--;
1077                 }
1078                 change_mnt_propagation(p, MS_PRIVATE);
1079         }
1080 }
1081
1082 static void shrink_submounts(struct vfsmount *mnt, struct list_head *umounts);
1083
1084 static int do_umount(struct vfsmount *mnt, int flags)
1085 {
1086         struct super_block *sb = mnt->mnt_sb;
1087         int retval;
1088         LIST_HEAD(umount_list);
1089
1090         retval = security_sb_umount(mnt, flags);
1091         if (retval)
1092                 return retval;
1093
1094         /*
1095          * Allow userspace to request a mountpoint be expired rather than
1096          * unmounting unconditionally. Unmount only happens if:
1097          *  (1) the mark is already set (the mark is cleared by mntput())
1098          *  (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount]
1099          */
1100         if (flags & MNT_EXPIRE) {
1101                 if (mnt == current->fs->root.mnt ||
1102                     flags & (MNT_FORCE | MNT_DETACH))
1103                         return -EINVAL;
1104
1105                 if (atomic_read(&mnt->mnt_count) != 2)
1106                         return -EBUSY;
1107
1108                 if (!xchg(&mnt->mnt_expiry_mark, 1))
1109                         return -EAGAIN;
1110         }
1111
1112         /*
1113          * If we may have to abort operations to get out of this
1114          * mount, and they will themselves hold resources we must
1115          * allow the fs to do things. In the Unix tradition of
1116          * 'Gee thats tricky lets do it in userspace' the umount_begin
1117          * might fail to complete on the first run through as other tasks
1118          * must return, and the like. Thats for the mount program to worry
1119          * about for the moment.
1120          */
1121
1122         if (flags & MNT_FORCE && sb->s_op->umount_begin) {
1123                 sb->s_op->umount_begin(sb);
1124         }
1125
1126         /*
1127          * No sense to grab the lock for this test, but test itself looks
1128          * somewhat bogus. Suggestions for better replacement?
1129          * Ho-hum... In principle, we might treat that as umount + switch
1130          * to rootfs. GC would eventually take care of the old vfsmount.
1131          * Actually it makes sense, especially if rootfs would contain a
1132          * /reboot - static binary that would close all descriptors and
1133          * call reboot(9). Then init(8) could umount root and exec /reboot.
1134          */
1135         if (mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) {
1136                 /*
1137                  * Special case for "unmounting" root ...
1138                  * we just try to remount it readonly.
1139                  */
1140                 down_write(&sb->s_umount);
1141                 if (!(sb->s_flags & MS_RDONLY))
1142                         retval = do_remount_sb(sb, MS_RDONLY, NULL, 0);
1143                 up_write(&sb->s_umount);
1144                 return retval;
1145         }
1146
1147         down_write(&namespace_sem);
1148         br_write_lock(vfsmount_lock);
1149         event++;
1150
1151         if (!(flags & MNT_DETACH))
1152                 shrink_submounts(mnt, &umount_list);
1153
1154         retval = -EBUSY;
1155         if (flags & MNT_DETACH || !propagate_mount_busy(mnt, 2)) {
1156                 if (!list_empty(&mnt->mnt_list))
1157                         umount_tree(mnt, 1, &umount_list);
1158                 retval = 0;
1159         }
1160         br_write_unlock(vfsmount_lock);
1161         up_write(&namespace_sem);
1162         release_mounts(&umount_list);
1163         return retval;
1164 }
1165
1166 /*
1167  * Now umount can handle mount points as well as block devices.
1168  * This is important for filesystems which use unnamed block devices.
1169  *
1170  * We now support a flag for forced unmount like the other 'big iron'
1171  * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD
1172  */
1173
1174 SYSCALL_DEFINE2(umount, char __user *, name, int, flags)
1175 {
1176         struct path path;
1177         int retval;
1178         int lookup_flags = 0;
1179
1180         if (flags & ~(MNT_FORCE | MNT_DETACH | MNT_EXPIRE | UMOUNT_NOFOLLOW))
1181                 return -EINVAL;
1182
1183         if (!(flags & UMOUNT_NOFOLLOW))
1184                 lookup_flags |= LOOKUP_FOLLOW;
1185
1186         retval = user_path_at(AT_FDCWD, name, lookup_flags, &path);
1187         if (retval)
1188                 goto out;
1189         retval = -EINVAL;
1190         if (path.dentry != path.mnt->mnt_root)
1191                 goto dput_and_out;
1192         if (!check_mnt(path.mnt))
1193                 goto dput_and_out;
1194
1195         retval = -EPERM;
1196         if (!capable(CAP_SYS_ADMIN))
1197                 goto dput_and_out;
1198
1199         retval = do_umount(path.mnt, flags);
1200 dput_and_out:
1201         /* we mustn't call path_put() as that would clear mnt_expiry_mark */
1202         dput(path.dentry);
1203         mntput_no_expire(path.mnt);
1204 out:
1205         return retval;
1206 }
1207
1208 #ifdef __ARCH_WANT_SYS_OLDUMOUNT
1209
1210 /*
1211  *      The 2.0 compatible umount. No flags.
1212  */
1213 SYSCALL_DEFINE1(oldumount, char __user *, name)
1214 {
1215         return sys_umount(name, 0);
1216 }
1217
1218 #endif
1219
1220 static int mount_is_safe(struct path *path)
1221 {
1222         if (capable(CAP_SYS_ADMIN))
1223                 return 0;
1224         return -EPERM;
1225 #ifdef notyet
1226         if (S_ISLNK(path->dentry->d_inode->i_mode))
1227                 return -EPERM;
1228         if (path->dentry->d_inode->i_mode & S_ISVTX) {
1229                 if (current_uid() != path->dentry->d_inode->i_uid)
1230                         return -EPERM;
1231         }
1232         if (inode_permission(path->dentry->d_inode, MAY_WRITE))
1233                 return -EPERM;
1234         return 0;
1235 #endif
1236 }
1237
1238 struct vfsmount *copy_tree(struct vfsmount *mnt, struct dentry *dentry,
1239                                         int flag)
1240 {
1241         struct vfsmount *res, *p, *q, *r, *s;
1242         struct path path;
1243
1244         if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(mnt))
1245                 return NULL;
1246
1247         res = q = clone_mnt(mnt, dentry, flag);
1248         if (!q)
1249                 goto Enomem;
1250         q->mnt_mountpoint = mnt->mnt_mountpoint;
1251
1252         p = mnt;
1253         list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) {
1254                 if (!is_subdir(r->mnt_mountpoint, dentry))
1255                         continue;
1256
1257                 for (s = r; s; s = next_mnt(s, r)) {
1258                         if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(s)) {
1259                                 s = skip_mnt_tree(s);
1260                                 continue;
1261                         }
1262                         while (p != s->mnt_parent) {
1263                                 p = p->mnt_parent;
1264                                 q = q->mnt_parent;
1265                         }
1266                         p = s;
1267                         path.mnt = q;
1268                         path.dentry = p->mnt_mountpoint;
1269                         q = clone_mnt(p, p->mnt_root, flag);
1270                         if (!q)
1271                                 goto Enomem;
1272                         br_write_lock(vfsmount_lock);
1273                         list_add_tail(&q->mnt_list, &res->mnt_list);
1274                         attach_mnt(q, &path);
1275                         br_write_unlock(vfsmount_lock);
1276                 }
1277         }
1278         return res;
1279 Enomem:
1280         if (res) {
1281                 LIST_HEAD(umount_list);
1282                 br_write_lock(vfsmount_lock);
1283                 umount_tree(res, 0, &umount_list);
1284                 br_write_unlock(vfsmount_lock);
1285                 release_mounts(&umount_list);
1286         }
1287         return NULL;
1288 }
1289
1290 struct vfsmount *collect_mounts(struct path *path)
1291 {
1292         struct vfsmount *tree;
1293         down_write(&namespace_sem);
1294         tree = copy_tree(path->mnt, path->dentry, CL_COPY_ALL | CL_PRIVATE);
1295         up_write(&namespace_sem);
1296         return tree;
1297 }
1298
1299 void drop_collected_mounts(struct vfsmount *mnt)
1300 {
1301         LIST_HEAD(umount_list);
1302         down_write(&namespace_sem);
1303         br_write_lock(vfsmount_lock);
1304         umount_tree(mnt, 0, &umount_list);
1305         br_write_unlock(vfsmount_lock);
1306         up_write(&namespace_sem);
1307         release_mounts(&umount_list);
1308 }
1309
1310 int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg,
1311                    struct vfsmount *root)
1312 {
1313         struct vfsmount *mnt;
1314         int res = f(root, arg);
1315         if (res)
1316                 return res;
1317         list_for_each_entry(mnt, &root->mnt_list, mnt_list) {
1318                 res = f(mnt, arg);
1319                 if (res)
1320                         return res;
1321         }
1322         return 0;
1323 }
1324
1325 static void cleanup_group_ids(struct vfsmount *mnt, struct vfsmount *end)
1326 {
1327         struct vfsmount *p;
1328
1329         for (p = mnt; p != end; p = next_mnt(p, mnt)) {
1330                 if (p->mnt_group_id && !IS_MNT_SHARED(p))
1331                         mnt_release_group_id(p);
1332         }
1333 }
1334
1335 static int invent_group_ids(struct vfsmount *mnt, bool recurse)
1336 {
1337         struct vfsmount *p;
1338
1339         for (p = mnt; p; p = recurse ? next_mnt(p, mnt) : NULL) {
1340                 if (!p->mnt_group_id && !IS_MNT_SHARED(p)) {
1341                         int err = mnt_alloc_group_id(p);
1342                         if (err) {
1343                                 cleanup_group_ids(mnt, p);
1344                                 return err;
1345                         }
1346                 }
1347         }
1348
1349         return 0;
1350 }
1351
1352 /*
1353  *  @source_mnt : mount tree to be attached
1354  *  @nd         : place the mount tree @source_mnt is attached
1355  *  @parent_nd  : if non-null, detach the source_mnt from its parent and
1356  *                 store the parent mount and mountpoint dentry.
1357  *                 (done when source_mnt is moved)
1358  *
1359  *  NOTE: in the table below explains the semantics when a source mount
1360  *  of a given type is attached to a destination mount of a given type.
1361  * ---------------------------------------------------------------------------
1362  * |         BIND MOUNT OPERATION                                            |
1363  * |**************************************************************************
1364  * | source-->| shared        |       private  |       slave    | unbindable |
1365  * | dest     |               |                |                |            |
1366  * |   |      |               |                |                |            |
1367  * |   v      |               |                |                |            |
1368  * |**************************************************************************
1369  * |  shared  | shared (++)   |     shared (+) |     shared(+++)|  invalid   |
1370  * |          |               |                |                |            |
1371  * |non-shared| shared (+)    |      private   |      slave (*) |  invalid   |
1372  * ***************************************************************************
1373  * A bind operation clones the source mount and mounts the clone on the
1374  * destination mount.
1375  *
1376  * (++)  the cloned mount is propagated to all the mounts in the propagation
1377  *       tree of the destination mount and the cloned mount is added to
1378  *       the peer group of the source mount.
1379  * (+)   the cloned mount is created under the destination mount and is marked
1380  *       as shared. The cloned mount is added to the peer group of the source
1381  *       mount.
1382  * (+++) the mount is propagated to all the mounts in the propagation tree
1383  *       of the destination mount and the cloned mount is made slave
1384  *       of the same master as that of the source mount. The cloned mount
1385  *       is marked as 'shared and slave'.
1386  * (*)   the cloned mount is made a slave of the same master as that of the
1387  *       source mount.
1388  *
1389  * ---------------------------------------------------------------------------
1390  * |                    MOVE MOUNT OPERATION                                 |
1391  * |**************************************************************************
1392  * | source-->| shared        |       private  |       slave    | unbindable |
1393  * | dest     |               |                |                |            |
1394  * |   |      |               |                |                |            |
1395  * |   v      |               |                |                |            |
1396  * |**************************************************************************
1397  * |  shared  | shared (+)    |     shared (+) |    shared(+++) |  invalid   |
1398  * |          |               |                |                |            |
1399  * |non-shared| shared (+*)   |      private   |    slave (*)   | unbindable |
1400  * ***************************************************************************
1401  *
1402  * (+)  the mount is moved to the destination. And is then propagated to
1403  *      all the mounts in the propagation tree of the destination mount.
1404  * (+*)  the mount is moved to the destination.
1405  * (+++)  the mount is moved to the destination and is then propagated to
1406  *      all the mounts belonging to the destination mount's propagation tree.
1407  *      the mount is marked as 'shared and slave'.
1408  * (*)  the mount continues to be a slave at the new location.
1409  *
1410  * if the source mount is a tree, the operations explained above is
1411  * applied to each mount in the tree.
1412  * Must be called without spinlocks held, since this function can sleep
1413  * in allocations.
1414  */
1415 static int attach_recursive_mnt(struct vfsmount *source_mnt,
1416                         struct path *path, struct path *parent_path)
1417 {
1418         LIST_HEAD(tree_list);
1419         struct vfsmount *dest_mnt = path->mnt;
1420         struct dentry *dest_dentry = path->dentry;
1421         struct vfsmount *child, *p;
1422         int err;
1423
1424         if (IS_MNT_SHARED(dest_mnt)) {
1425                 err = invent_group_ids(source_mnt, true);
1426                 if (err)
1427                         goto out;
1428         }
1429         err = propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list);
1430         if (err)
1431                 goto out_cleanup_ids;
1432
1433         br_write_lock(vfsmount_lock);
1434
1435         if (IS_MNT_SHARED(dest_mnt)) {
1436                 for (p = source_mnt; p; p = next_mnt(p, source_mnt))
1437                         set_mnt_shared(p);
1438         }
1439         if (parent_path) {
1440                 detach_mnt(source_mnt, parent_path);
1441                 attach_mnt(source_mnt, path);
1442                 touch_mnt_namespace(parent_path->mnt->mnt_ns);
1443         } else {
1444                 mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt);
1445                 commit_tree(source_mnt);
1446         }
1447
1448         list_for_each_entry_safe(child, p, &tree_list, mnt_hash) {
1449                 list_del_init(&child->mnt_hash);
1450                 commit_tree(child);
1451         }
1452         br_write_unlock(vfsmount_lock);
1453
1454         return 0;
1455
1456  out_cleanup_ids:
1457         if (IS_MNT_SHARED(dest_mnt))
1458                 cleanup_group_ids(source_mnt, NULL);
1459  out:
1460         return err;
1461 }
1462
1463 static int graft_tree(struct vfsmount *mnt, struct path *path)
1464 {
1465         int err;
1466         if (mnt->mnt_sb->s_flags & MS_NOUSER)
1467                 return -EINVAL;
1468
1469         if (S_ISDIR(path->dentry->d_inode->i_mode) !=
1470               S_ISDIR(mnt->mnt_root->d_inode->i_mode))
1471                 return -ENOTDIR;
1472
1473         err = -ENOENT;
1474         mutex_lock(&path->dentry->d_inode->i_mutex);
1475         if (cant_mount(path->dentry))
1476                 goto out_unlock;
1477
1478         if (!d_unlinked(path->dentry))
1479                 err = attach_recursive_mnt(mnt, path, NULL);
1480 out_unlock:
1481         mutex_unlock(&path->dentry->d_inode->i_mutex);
1482         return err;
1483 }
1484
1485 /*
1486  * Sanity check the flags to change_mnt_propagation.
1487  */
1488
1489 static int flags_to_propagation_type(int flags)
1490 {
1491         int type = flags & ~MS_REC;
1492
1493         /* Fail if any non-propagation flags are set */
1494         if (type & ~(MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
1495                 return 0;
1496         /* Only one propagation flag should be set */
1497         if (!is_power_of_2(type))
1498                 return 0;
1499         return type;
1500 }
1501
1502 /*
1503  * recursively change the type of the mountpoint.
1504  */
1505 static int do_change_type(struct path *path, int flag)
1506 {
1507         struct vfsmount *m, *mnt = path->mnt;
1508         int recurse = flag & MS_REC;
1509         int type;
1510         int err = 0;
1511
1512         if (!capable(CAP_SYS_ADMIN))
1513                 return -EPERM;
1514
1515         if (path->dentry != path->mnt->mnt_root)
1516                 return -EINVAL;
1517
1518         type = flags_to_propagation_type(flag);
1519         if (!type)
1520                 return -EINVAL;
1521
1522         down_write(&namespace_sem);
1523         if (type == MS_SHARED) {
1524                 err = invent_group_ids(mnt, recurse);
1525                 if (err)
1526                         goto out_unlock;
1527         }
1528
1529         br_write_lock(vfsmount_lock);
1530         for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL))
1531                 change_mnt_propagation(m, type);
1532         br_write_unlock(vfsmount_lock);
1533
1534  out_unlock:
1535         up_write(&namespace_sem);
1536         return err;
1537 }
1538
1539 /*
1540  * do loopback mount.
1541  */
1542 static int do_loopback(struct path *path, char *old_name,
1543                                 int recurse)
1544 {
1545         struct path old_path;
1546         struct vfsmount *mnt = NULL;
1547         int err = mount_is_safe(path);
1548         if (err)
1549                 return err;
1550         if (!old_name || !*old_name)
1551                 return -EINVAL;
1552         err = kern_path(old_name, LOOKUP_FOLLOW, &old_path);
1553         if (err)
1554                 return err;
1555
1556         down_write(&namespace_sem);
1557         err = -EINVAL;
1558         if (IS_MNT_UNBINDABLE(old_path.mnt))
1559                 goto out;
1560
1561         if (!check_mnt(path->mnt) || !check_mnt(old_path.mnt))
1562                 goto out;
1563
1564         err = -ENOMEM;
1565         if (recurse)
1566                 mnt = copy_tree(old_path.mnt, old_path.dentry, 0);
1567         else
1568                 mnt = clone_mnt(old_path.mnt, old_path.dentry, 0);
1569
1570         if (!mnt)
1571                 goto out;
1572
1573         err = graft_tree(mnt, path);
1574         if (err) {
1575                 LIST_HEAD(umount_list);
1576
1577                 br_write_lock(vfsmount_lock);
1578                 umount_tree(mnt, 0, &umount_list);
1579                 br_write_unlock(vfsmount_lock);
1580                 release_mounts(&umount_list);
1581         }
1582
1583 out:
1584         up_write(&namespace_sem);
1585         path_put(&old_path);
1586         return err;
1587 }
1588
1589 static int change_mount_flags(struct vfsmount *mnt, int ms_flags)
1590 {
1591         int error = 0;
1592         int readonly_request = 0;
1593
1594         if (ms_flags & MS_RDONLY)
1595                 readonly_request = 1;
1596         if (readonly_request == __mnt_is_readonly(mnt))
1597                 return 0;
1598
1599         if (readonly_request)
1600                 error = mnt_make_readonly(mnt);
1601         else
1602                 __mnt_unmake_readonly(mnt);
1603         return error;
1604 }
1605
1606 /*
1607  * change filesystem flags. dir should be a physical root of filesystem.
1608  * If you've mounted a non-root directory somewhere and want to do remount
1609  * on it - tough luck.
1610  */
1611 static int do_remount(struct path *path, int flags, int mnt_flags,
1612                       void *data)
1613 {
1614         int err;
1615         struct super_block *sb = path->mnt->mnt_sb;
1616
1617         if (!capable(CAP_SYS_ADMIN))
1618                 return -EPERM;
1619
1620         if (!check_mnt(path->mnt))
1621                 return -EINVAL;
1622
1623         if (path->dentry != path->mnt->mnt_root)
1624                 return -EINVAL;
1625
1626         down_write(&sb->s_umount);
1627         if (flags & MS_BIND)
1628                 err = change_mount_flags(path->mnt, flags);
1629         else
1630                 err = do_remount_sb(sb, flags, data, 0);
1631         if (!err) {
1632                 br_write_lock(vfsmount_lock);
1633                 mnt_flags |= path->mnt->mnt_flags & MNT_PROPAGATION_MASK;
1634                 path->mnt->mnt_flags = mnt_flags;
1635                 br_write_unlock(vfsmount_lock);
1636         }
1637         up_write(&sb->s_umount);
1638         if (!err) {
1639                 br_write_lock(vfsmount_lock);
1640                 touch_mnt_namespace(path->mnt->mnt_ns);
1641                 br_write_unlock(vfsmount_lock);
1642         }
1643         return err;
1644 }
1645
1646 static inline int tree_contains_unbindable(struct vfsmount *mnt)
1647 {
1648         struct vfsmount *p;
1649         for (p = mnt; p; p = next_mnt(p, mnt)) {
1650                 if (IS_MNT_UNBINDABLE(p))
1651                         return 1;
1652         }
1653         return 0;
1654 }
1655
1656 static int do_move_mount(struct path *path, char *old_name)
1657 {
1658         struct path old_path, parent_path;
1659         struct vfsmount *p;
1660         int err = 0;
1661         if (!capable(CAP_SYS_ADMIN))
1662                 return -EPERM;
1663         if (!old_name || !*old_name)
1664                 return -EINVAL;
1665         err = kern_path(old_name, LOOKUP_FOLLOW, &old_path);
1666         if (err)
1667                 return err;
1668
1669         down_write(&namespace_sem);
1670         while (d_mountpoint(path->dentry) &&
1671                follow_down(path))
1672                 ;
1673         err = -EINVAL;
1674         if (!check_mnt(path->mnt) || !check_mnt(old_path.mnt))
1675                 goto out;
1676
1677         err = -ENOENT;
1678         mutex_lock(&path->dentry->d_inode->i_mutex);
1679         if (cant_mount(path->dentry))
1680                 goto out1;
1681
1682         if (d_unlinked(path->dentry))
1683                 goto out1;
1684
1685         err = -EINVAL;
1686         if (old_path.dentry != old_path.mnt->mnt_root)
1687                 goto out1;
1688
1689         if (old_path.mnt == old_path.mnt->mnt_parent)
1690                 goto out1;
1691
1692         if (S_ISDIR(path->dentry->d_inode->i_mode) !=
1693               S_ISDIR(old_path.dentry->d_inode->i_mode))
1694                 goto out1;
1695         /*
1696          * Don't move a mount residing in a shared parent.
1697          */
1698         if (old_path.mnt->mnt_parent &&
1699             IS_MNT_SHARED(old_path.mnt->mnt_parent))
1700                 goto out1;
1701         /*
1702          * Don't move a mount tree containing unbindable mounts to a destination
1703          * mount which is shared.
1704          */
1705         if (IS_MNT_SHARED(path->mnt) &&
1706             tree_contains_unbindable(old_path.mnt))
1707                 goto out1;
1708         err = -ELOOP;
1709         for (p = path->mnt; p->mnt_parent != p; p = p->mnt_parent)
1710                 if (p == old_path.mnt)
1711                         goto out1;
1712
1713         err = attach_recursive_mnt(old_path.mnt, path, &parent_path);
1714         if (err)
1715                 goto out1;
1716
1717         /* if the mount is moved, it should no longer be expire
1718          * automatically */
1719         list_del_init(&old_path.mnt->mnt_expire);
1720 out1:
1721         mutex_unlock(&path->dentry->d_inode->i_mutex);
1722 out:
1723         up_write(&namespace_sem);
1724         if (!err)
1725                 path_put(&parent_path);
1726         path_put(&old_path);
1727         return err;
1728 }
1729
1730 /*
1731  * create a new mount for userspace and request it to be added into the
1732  * namespace's tree
1733  */
1734 static int do_new_mount(struct path *path, char *type, int flags,
1735                         int mnt_flags, char *name, void *data)
1736 {
1737         struct vfsmount *mnt;
1738
1739         if (!type)
1740                 return -EINVAL;
1741
1742         /* we need capabilities... */
1743         if (!capable(CAP_SYS_ADMIN))
1744                 return -EPERM;
1745
1746         mnt = do_kern_mount(type, flags, name, data);
1747         if (IS_ERR(mnt))
1748                 return PTR_ERR(mnt);
1749
1750         return do_add_mount(mnt, path, mnt_flags, NULL);
1751 }
1752
1753 /*
1754  * add a mount into a namespace's mount tree
1755  * - provide the option of adding the new mount to an expiration list
1756  */
1757 int do_add_mount(struct vfsmount *newmnt, struct path *path,
1758                  int mnt_flags, struct list_head *fslist)
1759 {
1760         int err;
1761
1762         mnt_flags &= ~(MNT_SHARED | MNT_WRITE_HOLD | MNT_INTERNAL);
1763
1764         down_write(&namespace_sem);
1765         /* Something was mounted here while we slept */
1766         while (d_mountpoint(path->dentry) &&
1767                follow_down(path))
1768                 ;
1769         err = -EINVAL;
1770         if (!(mnt_flags & MNT_SHRINKABLE) && !check_mnt(path->mnt))
1771                 goto unlock;
1772
1773         /* Refuse the same filesystem on the same mount point */
1774         err = -EBUSY;
1775         if (path->mnt->mnt_sb == newmnt->mnt_sb &&
1776             path->mnt->mnt_root == path->dentry)
1777                 goto unlock;
1778
1779         err = -EINVAL;
1780         if (S_ISLNK(newmnt->mnt_root->d_inode->i_mode))
1781                 goto unlock;
1782
1783         newmnt->mnt_flags = mnt_flags;
1784         if ((err = graft_tree(newmnt, path)))
1785                 goto unlock;
1786
1787         if (fslist) /* add to the specified expiration list */
1788                 list_add_tail(&newmnt->mnt_expire, fslist);
1789
1790         up_write(&namespace_sem);
1791         return 0;
1792
1793 unlock:
1794         up_write(&namespace_sem);
1795         mntput(newmnt);
1796         return err;
1797 }
1798
1799 EXPORT_SYMBOL_GPL(do_add_mount);
1800
1801 /*
1802  * process a list of expirable mountpoints with the intent of discarding any
1803  * mountpoints that aren't in use and haven't been touched since last we came
1804  * here
1805  */
1806 void mark_mounts_for_expiry(struct list_head *mounts)
1807 {
1808         struct vfsmount *mnt, *next;
1809         LIST_HEAD(graveyard);
1810         LIST_HEAD(umounts);
1811
1812         if (list_empty(mounts))
1813                 return;
1814
1815         down_write(&namespace_sem);
1816         br_write_lock(vfsmount_lock);
1817
1818         /* extract from the expiration list every vfsmount that matches the
1819          * following criteria:
1820          * - only referenced by its parent vfsmount
1821          * - still marked for expiry (marked on the last call here; marks are
1822          *   cleared by mntput())
1823          */
1824         list_for_each_entry_safe(mnt, next, mounts, mnt_expire) {
1825                 if (!xchg(&mnt->mnt_expiry_mark, 1) ||
1826                         propagate_mount_busy(mnt, 1))
1827                         continue;
1828                 list_move(&mnt->mnt_expire, &graveyard);
1829         }
1830         while (!list_empty(&graveyard)) {
1831                 mnt = list_first_entry(&graveyard, struct vfsmount, mnt_expire);
1832                 touch_mnt_namespace(mnt->mnt_ns);
1833                 umount_tree(mnt, 1, &umounts);
1834         }
1835         br_write_unlock(vfsmount_lock);
1836         up_write(&namespace_sem);
1837
1838         release_mounts(&umounts);
1839 }
1840
1841 EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);
1842
1843 /*
1844  * Ripoff of 'select_parent()'
1845  *
1846  * search the list of submounts for a given mountpoint, and move any
1847  * shrinkable submounts to the 'graveyard' list.
1848  */
1849 static int select_submounts(struct vfsmount *parent, struct list_head *graveyard)
1850 {
1851         struct vfsmount *this_parent = parent;
1852         struct list_head *next;
1853         int found = 0;
1854
1855 repeat:
1856         next = this_parent->mnt_mounts.next;
1857 resume:
1858         while (next != &this_parent->mnt_mounts) {
1859                 struct list_head *tmp = next;
1860                 struct vfsmount *mnt = list_entry(tmp, struct vfsmount, mnt_child);
1861
1862                 next = tmp->next;
1863                 if (!(mnt->mnt_flags & MNT_SHRINKABLE))
1864                         continue;
1865                 /*
1866                  * Descend a level if the d_mounts list is non-empty.
1867                  */
1868                 if (!list_empty(&mnt->mnt_mounts)) {
1869                         this_parent = mnt;
1870                         goto repeat;
1871                 }
1872
1873                 if (!propagate_mount_busy(mnt, 1)) {
1874                         list_move_tail(&mnt->mnt_expire, graveyard);
1875                         found++;
1876                 }
1877         }
1878         /*
1879          * All done at this level ... ascend and resume the search
1880          */
1881         if (this_parent != parent) {
1882                 next = this_parent->mnt_child.next;
1883                 this_parent = this_parent->mnt_parent;
1884                 goto resume;
1885         }
1886         return found;
1887 }
1888
1889 /*
1890  * process a list of expirable mountpoints with the intent of discarding any
1891  * submounts of a specific parent mountpoint
1892  *
1893  * vfsmount_lock must be held for write
1894  */
1895 static void shrink_submounts(struct vfsmount *mnt, struct list_head *umounts)
1896 {
1897         LIST_HEAD(graveyard);
1898         struct vfsmount *m;
1899
1900         /* extract submounts of 'mountpoint' from the expiration list */
1901         while (select_submounts(mnt, &graveyard)) {
1902                 while (!list_empty(&graveyard)) {
1903                         m = list_first_entry(&graveyard, struct vfsmount,
1904                                                 mnt_expire);
1905                         touch_mnt_namespace(m->mnt_ns);
1906                         umount_tree(m, 1, umounts);
1907                 }
1908         }
1909 }
1910
1911 /*
1912  * Some copy_from_user() implementations do not return the exact number of
1913  * bytes remaining to copy on a fault.  But copy_mount_options() requires that.
1914  * Note that this function differs from copy_from_user() in that it will oops
1915  * on bad values of `to', rather than returning a short copy.
1916  */
1917 static long exact_copy_from_user(void *to, const void __user * from,
1918                                  unsigned long n)
1919 {
1920         char *t = to;
1921         const char __user *f = from;
1922         char c;
1923
1924         if (!access_ok(VERIFY_READ, from, n))
1925                 return n;
1926
1927         while (n) {
1928                 if (__get_user(c, f)) {
1929                         memset(t, 0, n);
1930                         break;
1931                 }
1932                 *t++ = c;
1933                 f++;
1934                 n--;
1935         }
1936         return n;
1937 }
1938
1939 int copy_mount_options(const void __user * data, unsigned long *where)
1940 {
1941         int i;
1942         unsigned long page;
1943         unsigned long size;
1944
1945         *where = 0;
1946         if (!data)
1947                 return 0;
1948
1949         if (!(page = __get_free_page(GFP_KERNEL)))
1950                 return -ENOMEM;
1951
1952         /* We only care that *some* data at the address the user
1953          * gave us is valid.  Just in case, we'll zero
1954          * the remainder of the page.
1955          */
1956         /* copy_from_user cannot cross TASK_SIZE ! */
1957         size = TASK_SIZE - (unsigned long)data;
1958         if (size > PAGE_SIZE)
1959                 size = PAGE_SIZE;
1960
1961         i = size - exact_copy_from_user((void *)page, data, size);
1962         if (!i) {
1963                 free_page(page);
1964                 return -EFAULT;
1965         }
1966         if (i != PAGE_SIZE)
1967                 memset((char *)page + i, 0, PAGE_SIZE - i);
1968         *where = page;
1969         return 0;
1970 }
1971
1972 int copy_mount_string(const void __user *data, char **where)
1973 {
1974         char *tmp;
1975
1976         if (!data) {
1977                 *where = NULL;
1978                 return 0;
1979         }
1980
1981         tmp = strndup_user(data, PAGE_SIZE);
1982         if (IS_ERR(tmp))
1983                 return PTR_ERR(tmp);
1984
1985         *where = tmp;
1986         return 0;
1987 }
1988
1989 /*
1990  * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to
1991  * be given to the mount() call (ie: read-only, no-dev, no-suid etc).
1992  *
1993  * data is a (void *) that can point to any structure up to
1994  * PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent
1995  * information (or be NULL).
1996  *
1997  * Pre-0.97 versions of mount() didn't have a flags word.
1998  * When the flags word was introduced its top half was required
1999  * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9.
2000  * Therefore, if this magic number is present, it carries no information
2001  * and must be discarded.
2002  */
2003 long do_mount(char *dev_name, char *dir_name, char *type_page,
2004                   unsigned long flags, void *data_page)
2005 {
2006         struct path path;
2007         int retval = 0;
2008         int mnt_flags = 0;
2009
2010         /* Discard magic */
2011         if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
2012                 flags &= ~MS_MGC_MSK;
2013
2014         /* Basic sanity checks */
2015
2016         if (!dir_name || !*dir_name || !memchr(dir_name, 0, PAGE_SIZE))
2017                 return -EINVAL;
2018
2019         if (data_page)
2020                 ((char *)data_page)[PAGE_SIZE - 1] = 0;
2021
2022         /* ... and get the mountpoint */
2023         retval = kern_path(dir_name, LOOKUP_FOLLOW, &path);
2024         if (retval)
2025                 return retval;
2026
2027         retval = security_sb_mount(dev_name, &path,
2028                                    type_page, flags, data_page);
2029         if (retval)
2030                 goto dput_out;
2031
2032         /* Default to relatime unless overriden */
2033         if (!(flags & MS_NOATIME))
2034                 mnt_flags |= MNT_RELATIME;
2035
2036         /* Separate the per-mountpoint flags */
2037         if (flags & MS_NOSUID)
2038                 mnt_flags |= MNT_NOSUID;
2039         if (flags & MS_NODEV)
2040                 mnt_flags |= MNT_NODEV;
2041         if (flags & MS_NOEXEC)
2042                 mnt_flags |= MNT_NOEXEC;
2043         if (flags & MS_NOATIME)
2044                 mnt_flags |= MNT_NOATIME;
2045         if (flags & MS_NODIRATIME)
2046                 mnt_flags |= MNT_NODIRATIME;
2047         if (flags & MS_STRICTATIME)
2048                 mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);
2049         if (flags & MS_RDONLY)
2050                 mnt_flags |= MNT_READONLY;
2051
2052         flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE | MS_BORN |
2053                    MS_NOATIME | MS_NODIRATIME | MS_RELATIME| MS_KERNMOUNT |
2054                    MS_STRICTATIME);
2055
2056         if (flags & MS_REMOUNT)
2057                 retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags,
2058                                     data_page);
2059         else if (flags & MS_BIND)
2060                 retval = do_loopback(&path, dev_name, flags & MS_REC);
2061         else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
2062                 retval = do_change_type(&path, flags);
2063         else if (flags & MS_MOVE)
2064                 retval = do_move_mount(&path, dev_name);
2065         else
2066                 retval = do_new_mount(&path, type_page, flags, mnt_flags,
2067                                       dev_name, data_page);
2068 dput_out:
2069         path_put(&path);
2070         return retval;
2071 }
2072
2073 static struct mnt_namespace *alloc_mnt_ns(void)
2074 {
2075         struct mnt_namespace *new_ns;
2076
2077         new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL);
2078         if (!new_ns)
2079                 return ERR_PTR(-ENOMEM);
2080         atomic_set(&new_ns->count, 1);
2081         new_ns->root = NULL;
2082         INIT_LIST_HEAD(&new_ns->list);
2083         init_waitqueue_head(&new_ns->poll);
2084         new_ns->event = 0;
2085         return new_ns;
2086 }
2087
2088 /*
2089  * Allocate a new namespace structure and populate it with contents
2090  * copied from the namespace of the passed in task structure.
2091  */
2092 static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns,
2093                 struct fs_struct *fs)
2094 {
2095         struct mnt_namespace *new_ns;
2096         struct vfsmount *rootmnt = NULL, *pwdmnt = NULL;
2097         struct vfsmount *p, *q;
2098
2099         new_ns = alloc_mnt_ns();
2100         if (IS_ERR(new_ns))
2101                 return new_ns;
2102
2103         down_write(&namespace_sem);
2104         /* First pass: copy the tree topology */
2105         new_ns->root = copy_tree(mnt_ns->root, mnt_ns->root->mnt_root,
2106                                         CL_COPY_ALL | CL_EXPIRE);
2107         if (!new_ns->root) {
2108                 up_write(&namespace_sem);
2109                 kfree(new_ns);
2110                 return ERR_PTR(-ENOMEM);
2111         }
2112         br_write_lock(vfsmount_lock);
2113         list_add_tail(&new_ns->list, &new_ns->root->mnt_list);
2114         br_write_unlock(vfsmount_lock);
2115
2116         /*
2117          * Second pass: switch the tsk->fs->* elements and mark new vfsmounts
2118          * as belonging to new namespace.  We have already acquired a private
2119          * fs_struct, so tsk->fs->lock is not needed.
2120          */
2121         p = mnt_ns->root;
2122         q = new_ns->root;
2123         while (p) {
2124                 q->mnt_ns = new_ns;
2125                 if (fs) {
2126                         if (p == fs->root.mnt) {
2127                                 rootmnt = p;
2128                                 fs->root.mnt = mntget(q);
2129                         }
2130                         if (p == fs->pwd.mnt) {
2131                                 pwdmnt = p;
2132                                 fs->pwd.mnt = mntget(q);
2133                         }
2134                 }
2135                 p = next_mnt(p, mnt_ns->root);
2136                 q = next_mnt(q, new_ns->root);
2137         }
2138         up_write(&namespace_sem);
2139
2140         if (rootmnt)
2141                 mntput(rootmnt);
2142         if (pwdmnt)
2143                 mntput(pwdmnt);
2144
2145         return new_ns;
2146 }
2147
2148 struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns,
2149                 struct fs_struct *new_fs)
2150 {
2151         struct mnt_namespace *new_ns;
2152
2153         BUG_ON(!ns);
2154         get_mnt_ns(ns);
2155
2156         if (!(flags & CLONE_NEWNS))
2157                 return ns;
2158
2159         new_ns = dup_mnt_ns(ns, new_fs);
2160
2161         put_mnt_ns(ns);
2162         return new_ns;
2163 }
2164
2165 /**
2166  * create_mnt_ns - creates a private namespace and adds a root filesystem
2167  * @mnt: pointer to the new root filesystem mountpoint
2168  */
2169 struct mnt_namespace *create_mnt_ns(struct vfsmount *mnt)
2170 {
2171         struct mnt_namespace *new_ns;
2172
2173         new_ns = alloc_mnt_ns();
2174         if (!IS_ERR(new_ns)) {
2175                 mnt->mnt_ns = new_ns;
2176                 new_ns->root = mnt;
2177                 list_add(&new_ns->list, &new_ns->root->mnt_list);
2178         }
2179         return new_ns;
2180 }
2181 EXPORT_SYMBOL(create_mnt_ns);
2182
2183 SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
2184                 char __user *, type, unsigned long, flags, void __user *, data)
2185 {
2186         int ret;
2187         char *kernel_type;
2188         char *kernel_dir;
2189         char *kernel_dev;
2190         unsigned long data_page;
2191
2192         ret = copy_mount_string(type, &kernel_type);
2193         if (ret < 0)
2194                 goto out_type;
2195
2196         kernel_dir = getname(dir_name);
2197         if (IS_ERR(kernel_dir)) {
2198                 ret = PTR_ERR(kernel_dir);
2199                 goto out_dir;
2200         }
2201
2202         ret = copy_mount_string(dev_name, &kernel_dev);
2203         if (ret < 0)
2204                 goto out_dev;
2205
2206         ret = copy_mount_options(data, &data_page);
2207         if (ret < 0)
2208                 goto out_data;
2209
2210         ret = do_mount(kernel_dev, kernel_dir, kernel_type, flags,
2211                 (void *) data_page);
2212
2213         free_page(data_page);
2214 out_data:
2215         kfree(kernel_dev);
2216 out_dev:
2217         putname(kernel_dir);
2218 out_dir:
2219         kfree(kernel_type);
2220 out_type:
2221         return ret;
2222 }
2223
2224 /*
2225  * pivot_root Semantics:
2226  * Moves the root file system of the current process to the directory put_old,
2227  * makes new_root as the new root file system of the current process, and sets
2228  * root/cwd of all processes which had them on the current root to new_root.
2229  *
2230  * Restrictions:
2231  * The new_root and put_old must be directories, and  must not be on the
2232  * same file  system as the current process root. The put_old  must  be
2233  * underneath new_root,  i.e. adding a non-zero number of /.. to the string
2234  * pointed to by put_old must yield the same directory as new_root. No other
2235  * file system may be mounted on put_old. After all, new_root is a mountpoint.
2236  *
2237  * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem.
2238  * See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives
2239  * in this situation.
2240  *
2241  * Notes:
2242  *  - we don't move root/cwd if they are not at the root (reason: if something
2243  *    cared enough to change them, it's probably wrong to force them elsewhere)
2244  *  - it's okay to pick a root that isn't the root of a file system, e.g.
2245  *    /nfs/my_root where /nfs is the mount point. It must be a mountpoint,
2246  *    though, so you may need to say mount --bind /nfs/my_root /nfs/my_root
2247  *    first.
2248  */
2249 SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,
2250                 const char __user *, put_old)
2251 {
2252         struct vfsmount *tmp;
2253         struct path new, old, parent_path, root_parent, root;
2254         int error;
2255
2256         if (!capable(CAP_SYS_ADMIN))
2257                 return -EPERM;
2258
2259         error = user_path_dir(new_root, &new);
2260         if (error)
2261                 goto out0;
2262         error = -EINVAL;
2263         if (!check_mnt(new.mnt))
2264                 goto out1;
2265
2266         error = user_path_dir(put_old, &old);
2267         if (error)
2268                 goto out1;
2269
2270         error = security_sb_pivotroot(&old, &new);
2271         if (error) {
2272                 path_put(&old);
2273                 goto out1;
2274         }
2275
2276         get_fs_root(current->fs, &root);
2277         down_write(&namespace_sem);
2278         mutex_lock(&old.dentry->d_inode->i_mutex);
2279         error = -EINVAL;
2280         if (IS_MNT_SHARED(old.mnt) ||
2281                 IS_MNT_SHARED(new.mnt->mnt_parent) ||
2282                 IS_MNT_SHARED(root.mnt->mnt_parent))
2283                 goto out2;
2284         if (!check_mnt(root.mnt))
2285                 goto out2;
2286         error = -ENOENT;
2287         if (cant_mount(old.dentry))
2288                 goto out2;
2289         if (d_unlinked(new.dentry))
2290                 goto out2;
2291         if (d_unlinked(old.dentry))
2292                 goto out2;
2293         error = -EBUSY;
2294         if (new.mnt == root.mnt ||
2295             old.mnt == root.mnt)
2296                 goto out2; /* loop, on the same file system  */
2297         error = -EINVAL;
2298         if (root.mnt->mnt_root != root.dentry)
2299                 goto out2; /* not a mountpoint */
2300         if (root.mnt->mnt_parent == root.mnt)
2301                 goto out2; /* not attached */
2302         if (new.mnt->mnt_root != new.dentry)
2303                 goto out2; /* not a mountpoint */
2304         if (new.mnt->mnt_parent == new.mnt)
2305                 goto out2; /* not attached */
2306         /* make sure we can reach put_old from new_root */
2307         tmp = old.mnt;
2308         br_write_lock(vfsmount_lock);
2309         if (tmp != new.mnt) {
2310                 for (;;) {
2311                         if (tmp->mnt_parent == tmp)
2312                                 goto out3; /* already mounted on put_old */
2313                         if (tmp->mnt_parent == new.mnt)
2314                                 break;
2315                         tmp = tmp->mnt_parent;
2316                 }
2317                 if (!is_subdir(tmp->mnt_mountpoint, new.dentry))
2318                         goto out3;
2319         } else if (!is_subdir(old.dentry, new.dentry))
2320                 goto out3;
2321         detach_mnt(new.mnt, &parent_path);
2322         detach_mnt(root.mnt, &root_parent);
2323         /* mount old root on put_old */
2324         attach_mnt(root.mnt, &old);
2325         /* mount new_root on / */
2326         attach_mnt(new.mnt, &root_parent);
2327         touch_mnt_namespace(current->nsproxy->mnt_ns);
2328         br_write_unlock(vfsmount_lock);
2329         chroot_fs_refs(&root, &new);
2330         error = 0;
2331         path_put(&root_parent);
2332         path_put(&parent_path);
2333 out2:
2334         mutex_unlock(&old.dentry->d_inode->i_mutex);
2335         up_write(&namespace_sem);
2336         path_put(&root);
2337         path_put(&old);
2338 out1:
2339         path_put(&new);
2340 out0:
2341         return error;
2342 out3:
2343         br_write_unlock(vfsmount_lock);
2344         goto out2;
2345 }
2346
2347 static void __init init_mount_tree(void)
2348 {
2349         struct vfsmount *mnt;
2350         struct mnt_namespace *ns;
2351         struct path root;
2352
2353         mnt = do_kern_mount("rootfs", 0, "rootfs", NULL);
2354         if (IS_ERR(mnt))
2355                 panic("Can't create rootfs");
2356         ns = create_mnt_ns(mnt);
2357         if (IS_ERR(ns))
2358                 panic("Can't allocate initial namespace");
2359
2360         init_task.nsproxy->mnt_ns = ns;
2361         get_mnt_ns(ns);
2362
2363         root.mnt = ns->root;
2364         root.dentry = ns->root->mnt_root;
2365
2366         set_fs_pwd(current->fs, &root);
2367         set_fs_root(current->fs, &root);
2368 }
2369
2370 void __init mnt_init(void)
2371 {
2372         unsigned u;
2373         int err;
2374
2375         init_rwsem(&namespace_sem);
2376
2377         mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct vfsmount),
2378                         0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
2379
2380         mount_hashtable = (struct list_head *)__get_free_page(GFP_ATOMIC);
2381
2382         if (!mount_hashtable)
2383                 panic("Failed to allocate mount hash table\n");
2384
2385         printk("Mount-cache hash table entries: %lu\n", HASH_SIZE);
2386
2387         for (u = 0; u < HASH_SIZE; u++)
2388                 INIT_LIST_HEAD(&mount_hashtable[u]);
2389
2390         br_lock_init(vfsmount_lock);
2391
2392         err = sysfs_init();
2393         if (err)
2394                 printk(KERN_WARNING "%s: sysfs_init error: %d\n",
2395                         __func__, err);
2396         fs_kobj = kobject_create_and_add("fs", NULL);
2397         if (!fs_kobj)
2398                 printk(KERN_WARNING "%s: kobj create error\n", __func__);
2399         init_rootfs();
2400         init_mount_tree();
2401 }
2402
2403 void put_mnt_ns(struct mnt_namespace *ns)
2404 {
2405         LIST_HEAD(umount_list);
2406
2407         if (!atomic_dec_and_test(&ns->count))
2408                 return;
2409         down_write(&namespace_sem);
2410         br_write_lock(vfsmount_lock);
2411         umount_tree(ns->root, 0, &umount_list);
2412         br_write_unlock(vfsmount_lock);
2413         up_write(&namespace_sem);
2414         release_mounts(&umount_list);
2415         kfree(ns);
2416 }
2417 EXPORT_SYMBOL(put_mnt_ns);