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