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