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