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