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