1 /* 2 * linux/fs/namespace.c 3 * 4 * (C) Copyright Al Viro 2000, 2001 5 * Released under GPL v2. 6 * 7 * Based on code from fs/super.c, copyright Linus Torvalds and others. 8 * Heavily rewritten. 9 */ 10 11 #include <linux/syscalls.h> 12 #include <linux/slab.h> 13 #include <linux/sched.h> 14 #include <linux/smp_lock.h> 15 #include <linux/init.h> 16 #include <linux/kernel.h> 17 #include <linux/quotaops.h> 18 #include <linux/acct.h> 19 #include <linux/capability.h> 20 #include <linux/module.h> 21 #include <linux/sysfs.h> 22 #include <linux/seq_file.h> 23 #include <linux/mnt_namespace.h> 24 #include <linux/namei.h> 25 #include <linux/security.h> 26 #include <linux/mount.h> 27 #include <linux/ramfs.h> 28 #include <asm/uaccess.h> 29 #include <asm/unistd.h> 30 #include "pnode.h" 31 32 /* spinlock for vfsmount related operations, inplace of dcache_lock */ 33 __cacheline_aligned_in_smp DEFINE_SPINLOCK(vfsmount_lock); 34 35 static int event; 36 37 static struct list_head *mount_hashtable __read_mostly; 38 static int hash_mask __read_mostly, hash_bits __read_mostly; 39 static struct kmem_cache *mnt_cache __read_mostly; 40 static struct rw_semaphore namespace_sem; 41 42 /* /sys/fs */ 43 decl_subsys(fs, NULL, NULL); 44 EXPORT_SYMBOL_GPL(fs_subsys); 45 46 static inline unsigned long hash(struct vfsmount *mnt, struct dentry *dentry) 47 { 48 unsigned long tmp = ((unsigned long)mnt / L1_CACHE_BYTES); 49 tmp += ((unsigned long)dentry / L1_CACHE_BYTES); 50 tmp = tmp + (tmp >> hash_bits); 51 return tmp & hash_mask; 52 } 53 54 struct vfsmount *alloc_vfsmnt(const char *name) 55 { 56 struct vfsmount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL); 57 if (mnt) { 58 atomic_set(&mnt->mnt_count, 1); 59 INIT_LIST_HEAD(&mnt->mnt_hash); 60 INIT_LIST_HEAD(&mnt->mnt_child); 61 INIT_LIST_HEAD(&mnt->mnt_mounts); 62 INIT_LIST_HEAD(&mnt->mnt_list); 63 INIT_LIST_HEAD(&mnt->mnt_expire); 64 INIT_LIST_HEAD(&mnt->mnt_share); 65 INIT_LIST_HEAD(&mnt->mnt_slave_list); 66 INIT_LIST_HEAD(&mnt->mnt_slave); 67 if (name) { 68 int size = strlen(name) + 1; 69 char *newname = kmalloc(size, GFP_KERNEL); 70 if (newname) { 71 memcpy(newname, name, size); 72 mnt->mnt_devname = newname; 73 } 74 } 75 } 76 return mnt; 77 } 78 79 int simple_set_mnt(struct vfsmount *mnt, struct super_block *sb) 80 { 81 mnt->mnt_sb = sb; 82 mnt->mnt_root = dget(sb->s_root); 83 return 0; 84 } 85 86 EXPORT_SYMBOL(simple_set_mnt); 87 88 void free_vfsmnt(struct vfsmount *mnt) 89 { 90 kfree(mnt->mnt_devname); 91 kmem_cache_free(mnt_cache, mnt); 92 } 93 94 /* 95 * find the first or last mount at @dentry on vfsmount @mnt depending on 96 * @dir. If @dir is set return the first mount else return the last mount. 97 */ 98 struct vfsmount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry, 99 int dir) 100 { 101 struct list_head *head = mount_hashtable + hash(mnt, dentry); 102 struct list_head *tmp = head; 103 struct vfsmount *p, *found = NULL; 104 105 for (;;) { 106 tmp = dir ? tmp->next : tmp->prev; 107 p = NULL; 108 if (tmp == head) 109 break; 110 p = list_entry(tmp, struct vfsmount, mnt_hash); 111 if (p->mnt_parent == mnt && p->mnt_mountpoint == dentry) { 112 found = p; 113 break; 114 } 115 } 116 return found; 117 } 118 119 /* 120 * lookup_mnt increments the ref count before returning 121 * the vfsmount struct. 122 */ 123 struct vfsmount *lookup_mnt(struct vfsmount *mnt, struct dentry *dentry) 124 { 125 struct vfsmount *child_mnt; 126 spin_lock(&vfsmount_lock); 127 if ((child_mnt = __lookup_mnt(mnt, dentry, 1))) 128 mntget(child_mnt); 129 spin_unlock(&vfsmount_lock); 130 return child_mnt; 131 } 132 133 static inline int check_mnt(struct vfsmount *mnt) 134 { 135 return mnt->mnt_ns == current->nsproxy->mnt_ns; 136 } 137 138 static void touch_mnt_namespace(struct mnt_namespace *ns) 139 { 140 if (ns) { 141 ns->event = ++event; 142 wake_up_interruptible(&ns->poll); 143 } 144 } 145 146 static void __touch_mnt_namespace(struct mnt_namespace *ns) 147 { 148 if (ns && ns->event != event) { 149 ns->event = event; 150 wake_up_interruptible(&ns->poll); 151 } 152 } 153 154 static void detach_mnt(struct vfsmount *mnt, struct nameidata *old_nd) 155 { 156 old_nd->dentry = mnt->mnt_mountpoint; 157 old_nd->mnt = mnt->mnt_parent; 158 mnt->mnt_parent = mnt; 159 mnt->mnt_mountpoint = mnt->mnt_root; 160 list_del_init(&mnt->mnt_child); 161 list_del_init(&mnt->mnt_hash); 162 old_nd->dentry->d_mounted--; 163 } 164 165 void mnt_set_mountpoint(struct vfsmount *mnt, struct dentry *dentry, 166 struct vfsmount *child_mnt) 167 { 168 child_mnt->mnt_parent = mntget(mnt); 169 child_mnt->mnt_mountpoint = dget(dentry); 170 dentry->d_mounted++; 171 } 172 173 static void attach_mnt(struct vfsmount *mnt, struct nameidata *nd) 174 { 175 mnt_set_mountpoint(nd->mnt, nd->dentry, mnt); 176 list_add_tail(&mnt->mnt_hash, mount_hashtable + 177 hash(nd->mnt, nd->dentry)); 178 list_add_tail(&mnt->mnt_child, &nd->mnt->mnt_mounts); 179 } 180 181 /* 182 * the caller must hold vfsmount_lock 183 */ 184 static void commit_tree(struct vfsmount *mnt) 185 { 186 struct vfsmount *parent = mnt->mnt_parent; 187 struct vfsmount *m; 188 LIST_HEAD(head); 189 struct mnt_namespace *n = parent->mnt_ns; 190 191 BUG_ON(parent == mnt); 192 193 list_add_tail(&head, &mnt->mnt_list); 194 list_for_each_entry(m, &head, mnt_list) 195 m->mnt_ns = n; 196 list_splice(&head, n->list.prev); 197 198 list_add_tail(&mnt->mnt_hash, mount_hashtable + 199 hash(parent, mnt->mnt_mountpoint)); 200 list_add_tail(&mnt->mnt_child, &parent->mnt_mounts); 201 touch_mnt_namespace(n); 202 } 203 204 static struct vfsmount *next_mnt(struct vfsmount *p, struct vfsmount *root) 205 { 206 struct list_head *next = p->mnt_mounts.next; 207 if (next == &p->mnt_mounts) { 208 while (1) { 209 if (p == root) 210 return NULL; 211 next = p->mnt_child.next; 212 if (next != &p->mnt_parent->mnt_mounts) 213 break; 214 p = p->mnt_parent; 215 } 216 } 217 return list_entry(next, struct vfsmount, mnt_child); 218 } 219 220 static struct vfsmount *skip_mnt_tree(struct vfsmount *p) 221 { 222 struct list_head *prev = p->mnt_mounts.prev; 223 while (prev != &p->mnt_mounts) { 224 p = list_entry(prev, struct vfsmount, mnt_child); 225 prev = p->mnt_mounts.prev; 226 } 227 return p; 228 } 229 230 static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root, 231 int flag) 232 { 233 struct super_block *sb = old->mnt_sb; 234 struct vfsmount *mnt = alloc_vfsmnt(old->mnt_devname); 235 236 if (mnt) { 237 mnt->mnt_flags = old->mnt_flags; 238 atomic_inc(&sb->s_active); 239 mnt->mnt_sb = sb; 240 mnt->mnt_root = dget(root); 241 mnt->mnt_mountpoint = mnt->mnt_root; 242 mnt->mnt_parent = mnt; 243 244 if (flag & CL_SLAVE) { 245 list_add(&mnt->mnt_slave, &old->mnt_slave_list); 246 mnt->mnt_master = old; 247 CLEAR_MNT_SHARED(mnt); 248 } else { 249 if ((flag & CL_PROPAGATION) || IS_MNT_SHARED(old)) 250 list_add(&mnt->mnt_share, &old->mnt_share); 251 if (IS_MNT_SLAVE(old)) 252 list_add(&mnt->mnt_slave, &old->mnt_slave); 253 mnt->mnt_master = old->mnt_master; 254 } 255 if (flag & CL_MAKE_SHARED) 256 set_mnt_shared(mnt); 257 258 /* stick the duplicate mount on the same expiry list 259 * as the original if that was on one */ 260 if (flag & CL_EXPIRE) { 261 spin_lock(&vfsmount_lock); 262 if (!list_empty(&old->mnt_expire)) 263 list_add(&mnt->mnt_expire, &old->mnt_expire); 264 spin_unlock(&vfsmount_lock); 265 } 266 } 267 return mnt; 268 } 269 270 static inline void __mntput(struct vfsmount *mnt) 271 { 272 struct super_block *sb = mnt->mnt_sb; 273 dput(mnt->mnt_root); 274 free_vfsmnt(mnt); 275 deactivate_super(sb); 276 } 277 278 void mntput_no_expire(struct vfsmount *mnt) 279 { 280 repeat: 281 if (atomic_dec_and_lock(&mnt->mnt_count, &vfsmount_lock)) { 282 if (likely(!mnt->mnt_pinned)) { 283 spin_unlock(&vfsmount_lock); 284 __mntput(mnt); 285 return; 286 } 287 atomic_add(mnt->mnt_pinned + 1, &mnt->mnt_count); 288 mnt->mnt_pinned = 0; 289 spin_unlock(&vfsmount_lock); 290 acct_auto_close_mnt(mnt); 291 security_sb_umount_close(mnt); 292 goto repeat; 293 } 294 } 295 296 EXPORT_SYMBOL(mntput_no_expire); 297 298 void mnt_pin(struct vfsmount *mnt) 299 { 300 spin_lock(&vfsmount_lock); 301 mnt->mnt_pinned++; 302 spin_unlock(&vfsmount_lock); 303 } 304 305 EXPORT_SYMBOL(mnt_pin); 306 307 void mnt_unpin(struct vfsmount *mnt) 308 { 309 spin_lock(&vfsmount_lock); 310 if (mnt->mnt_pinned) { 311 atomic_inc(&mnt->mnt_count); 312 mnt->mnt_pinned--; 313 } 314 spin_unlock(&vfsmount_lock); 315 } 316 317 EXPORT_SYMBOL(mnt_unpin); 318 319 /* iterator */ 320 static void *m_start(struct seq_file *m, loff_t *pos) 321 { 322 struct mnt_namespace *n = m->private; 323 struct list_head *p; 324 loff_t l = *pos; 325 326 down_read(&namespace_sem); 327 list_for_each(p, &n->list) 328 if (!l--) 329 return list_entry(p, struct vfsmount, mnt_list); 330 return NULL; 331 } 332 333 static void *m_next(struct seq_file *m, void *v, loff_t *pos) 334 { 335 struct mnt_namespace *n = m->private; 336 struct list_head *p = ((struct vfsmount *)v)->mnt_list.next; 337 (*pos)++; 338 return p == &n->list ? NULL : list_entry(p, struct vfsmount, mnt_list); 339 } 340 341 static void m_stop(struct seq_file *m, void *v) 342 { 343 up_read(&namespace_sem); 344 } 345 346 static inline void mangle(struct seq_file *m, const char *s) 347 { 348 seq_escape(m, s, " \t\n\\"); 349 } 350 351 static int show_vfsmnt(struct seq_file *m, void *v) 352 { 353 struct vfsmount *mnt = v; 354 int err = 0; 355 static struct proc_fs_info { 356 int flag; 357 char *str; 358 } fs_info[] = { 359 { MS_SYNCHRONOUS, ",sync" }, 360 { MS_DIRSYNC, ",dirsync" }, 361 { MS_MANDLOCK, ",mand" }, 362 { 0, NULL } 363 }; 364 static struct proc_fs_info mnt_info[] = { 365 { MNT_NOSUID, ",nosuid" }, 366 { MNT_NODEV, ",nodev" }, 367 { MNT_NOEXEC, ",noexec" }, 368 { MNT_NOATIME, ",noatime" }, 369 { MNT_NODIRATIME, ",nodiratime" }, 370 { MNT_RELATIME, ",relatime" }, 371 { 0, NULL } 372 }; 373 struct proc_fs_info *fs_infop; 374 375 mangle(m, mnt->mnt_devname ? mnt->mnt_devname : "none"); 376 seq_putc(m, ' '); 377 seq_path(m, mnt, mnt->mnt_root, " \t\n\\"); 378 seq_putc(m, ' '); 379 mangle(m, mnt->mnt_sb->s_type->name); 380 if (mnt->mnt_sb->s_subtype && mnt->mnt_sb->s_subtype[0]) { 381 seq_putc(m, '.'); 382 mangle(m, mnt->mnt_sb->s_subtype); 383 } 384 seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? " ro" : " rw"); 385 for (fs_infop = fs_info; fs_infop->flag; fs_infop++) { 386 if (mnt->mnt_sb->s_flags & fs_infop->flag) 387 seq_puts(m, fs_infop->str); 388 } 389 for (fs_infop = mnt_info; fs_infop->flag; fs_infop++) { 390 if (mnt->mnt_flags & fs_infop->flag) 391 seq_puts(m, fs_infop->str); 392 } 393 if (mnt->mnt_sb->s_op->show_options) 394 err = mnt->mnt_sb->s_op->show_options(m, mnt); 395 seq_puts(m, " 0 0\n"); 396 return err; 397 } 398 399 struct seq_operations mounts_op = { 400 .start = m_start, 401 .next = m_next, 402 .stop = m_stop, 403 .show = show_vfsmnt 404 }; 405 406 static int show_vfsstat(struct seq_file *m, void *v) 407 { 408 struct vfsmount *mnt = v; 409 int err = 0; 410 411 /* device */ 412 if (mnt->mnt_devname) { 413 seq_puts(m, "device "); 414 mangle(m, mnt->mnt_devname); 415 } else 416 seq_puts(m, "no device"); 417 418 /* mount point */ 419 seq_puts(m, " mounted on "); 420 seq_path(m, mnt, mnt->mnt_root, " \t\n\\"); 421 seq_putc(m, ' '); 422 423 /* file system type */ 424 seq_puts(m, "with fstype "); 425 mangle(m, mnt->mnt_sb->s_type->name); 426 427 /* optional statistics */ 428 if (mnt->mnt_sb->s_op->show_stats) { 429 seq_putc(m, ' '); 430 err = mnt->mnt_sb->s_op->show_stats(m, mnt); 431 } 432 433 seq_putc(m, '\n'); 434 return err; 435 } 436 437 struct seq_operations mountstats_op = { 438 .start = m_start, 439 .next = m_next, 440 .stop = m_stop, 441 .show = show_vfsstat, 442 }; 443 444 /** 445 * may_umount_tree - check if a mount tree is busy 446 * @mnt: root of mount tree 447 * 448 * This is called to check if a tree of mounts has any 449 * open files, pwds, chroots or sub mounts that are 450 * busy. 451 */ 452 int may_umount_tree(struct vfsmount *mnt) 453 { 454 int actual_refs = 0; 455 int minimum_refs = 0; 456 struct vfsmount *p; 457 458 spin_lock(&vfsmount_lock); 459 for (p = mnt; p; p = next_mnt(p, mnt)) { 460 actual_refs += atomic_read(&p->mnt_count); 461 minimum_refs += 2; 462 } 463 spin_unlock(&vfsmount_lock); 464 465 if (actual_refs > minimum_refs) 466 return 0; 467 468 return 1; 469 } 470 471 EXPORT_SYMBOL(may_umount_tree); 472 473 /** 474 * may_umount - check if a mount point is busy 475 * @mnt: root of mount 476 * 477 * This is called to check if a mount point has any 478 * open files, pwds, chroots or sub mounts. If the 479 * mount has sub mounts this will return busy 480 * regardless of whether the sub mounts are busy. 481 * 482 * Doesn't take quota and stuff into account. IOW, in some cases it will 483 * give false negatives. The main reason why it's here is that we need 484 * a non-destructive way to look for easily umountable filesystems. 485 */ 486 int may_umount(struct vfsmount *mnt) 487 { 488 int ret = 1; 489 spin_lock(&vfsmount_lock); 490 if (propagate_mount_busy(mnt, 2)) 491 ret = 0; 492 spin_unlock(&vfsmount_lock); 493 return ret; 494 } 495 496 EXPORT_SYMBOL(may_umount); 497 498 void release_mounts(struct list_head *head) 499 { 500 struct vfsmount *mnt; 501 while (!list_empty(head)) { 502 mnt = list_entry(head->next, struct vfsmount, mnt_hash); 503 list_del_init(&mnt->mnt_hash); 504 if (mnt->mnt_parent != mnt) { 505 struct dentry *dentry; 506 struct vfsmount *m; 507 spin_lock(&vfsmount_lock); 508 dentry = mnt->mnt_mountpoint; 509 m = mnt->mnt_parent; 510 mnt->mnt_mountpoint = mnt->mnt_root; 511 mnt->mnt_parent = mnt; 512 spin_unlock(&vfsmount_lock); 513 dput(dentry); 514 mntput(m); 515 } 516 mntput(mnt); 517 } 518 } 519 520 void umount_tree(struct vfsmount *mnt, int propagate, struct list_head *kill) 521 { 522 struct vfsmount *p; 523 524 for (p = mnt; p; p = next_mnt(p, mnt)) 525 list_move(&p->mnt_hash, kill); 526 527 if (propagate) 528 propagate_umount(kill); 529 530 list_for_each_entry(p, kill, mnt_hash) { 531 list_del_init(&p->mnt_expire); 532 list_del_init(&p->mnt_list); 533 __touch_mnt_namespace(p->mnt_ns); 534 p->mnt_ns = NULL; 535 list_del_init(&p->mnt_child); 536 if (p->mnt_parent != p) 537 p->mnt_mountpoint->d_mounted--; 538 change_mnt_propagation(p, MS_PRIVATE); 539 } 540 } 541 542 static int do_umount(struct vfsmount *mnt, int flags) 543 { 544 struct super_block *sb = mnt->mnt_sb; 545 int retval; 546 LIST_HEAD(umount_list); 547 548 retval = security_sb_umount(mnt, flags); 549 if (retval) 550 return retval; 551 552 /* 553 * Allow userspace to request a mountpoint be expired rather than 554 * unmounting unconditionally. Unmount only happens if: 555 * (1) the mark is already set (the mark is cleared by mntput()) 556 * (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount] 557 */ 558 if (flags & MNT_EXPIRE) { 559 if (mnt == current->fs->rootmnt || 560 flags & (MNT_FORCE | MNT_DETACH)) 561 return -EINVAL; 562 563 if (atomic_read(&mnt->mnt_count) != 2) 564 return -EBUSY; 565 566 if (!xchg(&mnt->mnt_expiry_mark, 1)) 567 return -EAGAIN; 568 } 569 570 /* 571 * If we may have to abort operations to get out of this 572 * mount, and they will themselves hold resources we must 573 * allow the fs to do things. In the Unix tradition of 574 * 'Gee thats tricky lets do it in userspace' the umount_begin 575 * might fail to complete on the first run through as other tasks 576 * must return, and the like. Thats for the mount program to worry 577 * about for the moment. 578 */ 579 580 lock_kernel(); 581 if (sb->s_op->umount_begin) 582 sb->s_op->umount_begin(mnt, flags); 583 unlock_kernel(); 584 585 /* 586 * No sense to grab the lock for this test, but test itself looks 587 * somewhat bogus. Suggestions for better replacement? 588 * Ho-hum... In principle, we might treat that as umount + switch 589 * to rootfs. GC would eventually take care of the old vfsmount. 590 * Actually it makes sense, especially if rootfs would contain a 591 * /reboot - static binary that would close all descriptors and 592 * call reboot(9). Then init(8) could umount root and exec /reboot. 593 */ 594 if (mnt == current->fs->rootmnt && !(flags & MNT_DETACH)) { 595 /* 596 * Special case for "unmounting" root ... 597 * we just try to remount it readonly. 598 */ 599 down_write(&sb->s_umount); 600 if (!(sb->s_flags & MS_RDONLY)) { 601 lock_kernel(); 602 DQUOT_OFF(sb); 603 retval = do_remount_sb(sb, MS_RDONLY, NULL, 0); 604 unlock_kernel(); 605 } 606 up_write(&sb->s_umount); 607 return retval; 608 } 609 610 down_write(&namespace_sem); 611 spin_lock(&vfsmount_lock); 612 event++; 613 614 retval = -EBUSY; 615 if (flags & MNT_DETACH || !propagate_mount_busy(mnt, 2)) { 616 if (!list_empty(&mnt->mnt_list)) 617 umount_tree(mnt, 1, &umount_list); 618 retval = 0; 619 } 620 spin_unlock(&vfsmount_lock); 621 if (retval) 622 security_sb_umount_busy(mnt); 623 up_write(&namespace_sem); 624 release_mounts(&umount_list); 625 return retval; 626 } 627 628 /* 629 * Now umount can handle mount points as well as block devices. 630 * This is important for filesystems which use unnamed block devices. 631 * 632 * We now support a flag for forced unmount like the other 'big iron' 633 * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD 634 */ 635 636 asmlinkage long sys_umount(char __user * name, int flags) 637 { 638 struct nameidata nd; 639 int retval; 640 641 retval = __user_walk(name, LOOKUP_FOLLOW, &nd); 642 if (retval) 643 goto out; 644 retval = -EINVAL; 645 if (nd.dentry != nd.mnt->mnt_root) 646 goto dput_and_out; 647 if (!check_mnt(nd.mnt)) 648 goto dput_and_out; 649 650 retval = -EPERM; 651 if (!capable(CAP_SYS_ADMIN)) 652 goto dput_and_out; 653 654 retval = do_umount(nd.mnt, flags); 655 dput_and_out: 656 path_release_on_umount(&nd); 657 out: 658 return retval; 659 } 660 661 #ifdef __ARCH_WANT_SYS_OLDUMOUNT 662 663 /* 664 * The 2.0 compatible umount. No flags. 665 */ 666 asmlinkage long sys_oldumount(char __user * name) 667 { 668 return sys_umount(name, 0); 669 } 670 671 #endif 672 673 static int mount_is_safe(struct nameidata *nd) 674 { 675 if (capable(CAP_SYS_ADMIN)) 676 return 0; 677 return -EPERM; 678 #ifdef notyet 679 if (S_ISLNK(nd->dentry->d_inode->i_mode)) 680 return -EPERM; 681 if (nd->dentry->d_inode->i_mode & S_ISVTX) { 682 if (current->uid != nd->dentry->d_inode->i_uid) 683 return -EPERM; 684 } 685 if (vfs_permission(nd, MAY_WRITE)) 686 return -EPERM; 687 return 0; 688 #endif 689 } 690 691 static int lives_below_in_same_fs(struct dentry *d, struct dentry *dentry) 692 { 693 while (1) { 694 if (d == dentry) 695 return 1; 696 if (d == NULL || d == d->d_parent) 697 return 0; 698 d = d->d_parent; 699 } 700 } 701 702 struct vfsmount *copy_tree(struct vfsmount *mnt, struct dentry *dentry, 703 int flag) 704 { 705 struct vfsmount *res, *p, *q, *r, *s; 706 struct nameidata nd; 707 708 if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(mnt)) 709 return NULL; 710 711 res = q = clone_mnt(mnt, dentry, flag); 712 if (!q) 713 goto Enomem; 714 q->mnt_mountpoint = mnt->mnt_mountpoint; 715 716 p = mnt; 717 list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) { 718 if (!lives_below_in_same_fs(r->mnt_mountpoint, dentry)) 719 continue; 720 721 for (s = r; s; s = next_mnt(s, r)) { 722 if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(s)) { 723 s = skip_mnt_tree(s); 724 continue; 725 } 726 while (p != s->mnt_parent) { 727 p = p->mnt_parent; 728 q = q->mnt_parent; 729 } 730 p = s; 731 nd.mnt = q; 732 nd.dentry = p->mnt_mountpoint; 733 q = clone_mnt(p, p->mnt_root, flag); 734 if (!q) 735 goto Enomem; 736 spin_lock(&vfsmount_lock); 737 list_add_tail(&q->mnt_list, &res->mnt_list); 738 attach_mnt(q, &nd); 739 spin_unlock(&vfsmount_lock); 740 } 741 } 742 return res; 743 Enomem: 744 if (res) { 745 LIST_HEAD(umount_list); 746 spin_lock(&vfsmount_lock); 747 umount_tree(res, 0, &umount_list); 748 spin_unlock(&vfsmount_lock); 749 release_mounts(&umount_list); 750 } 751 return NULL; 752 } 753 754 /* 755 * @source_mnt : mount tree to be attached 756 * @nd : place the mount tree @source_mnt is attached 757 * @parent_nd : if non-null, detach the source_mnt from its parent and 758 * store the parent mount and mountpoint dentry. 759 * (done when source_mnt is moved) 760 * 761 * NOTE: in the table below explains the semantics when a source mount 762 * of a given type is attached to a destination mount of a given type. 763 * --------------------------------------------------------------------------- 764 * | BIND MOUNT OPERATION | 765 * |************************************************************************** 766 * | source-->| shared | private | slave | unbindable | 767 * | dest | | | | | 768 * | | | | | | | 769 * | v | | | | | 770 * |************************************************************************** 771 * | shared | shared (++) | shared (+) | shared(+++)| invalid | 772 * | | | | | | 773 * |non-shared| shared (+) | private | slave (*) | invalid | 774 * *************************************************************************** 775 * A bind operation clones the source mount and mounts the clone on the 776 * destination mount. 777 * 778 * (++) the cloned mount is propagated to all the mounts in the propagation 779 * tree of the destination mount and the cloned mount is added to 780 * the peer group of the source mount. 781 * (+) the cloned mount is created under the destination mount and is marked 782 * as shared. The cloned mount is added to the peer group of the source 783 * mount. 784 * (+++) the mount is propagated to all the mounts in the propagation tree 785 * of the destination mount and the cloned mount is made slave 786 * of the same master as that of the source mount. The cloned mount 787 * is marked as 'shared and slave'. 788 * (*) the cloned mount is made a slave of the same master as that of the 789 * source mount. 790 * 791 * --------------------------------------------------------------------------- 792 * | MOVE MOUNT OPERATION | 793 * |************************************************************************** 794 * | source-->| shared | private | slave | unbindable | 795 * | dest | | | | | 796 * | | | | | | | 797 * | v | | | | | 798 * |************************************************************************** 799 * | shared | shared (+) | shared (+) | shared(+++) | invalid | 800 * | | | | | | 801 * |non-shared| shared (+*) | private | slave (*) | unbindable | 802 * *************************************************************************** 803 * 804 * (+) the mount is moved to the destination. And is then propagated to 805 * all the mounts in the propagation tree of the destination mount. 806 * (+*) the mount is moved to the destination. 807 * (+++) the mount is moved to the destination and is then propagated to 808 * all the mounts belonging to the destination mount's propagation tree. 809 * the mount is marked as 'shared and slave'. 810 * (*) the mount continues to be a slave at the new location. 811 * 812 * if the source mount is a tree, the operations explained above is 813 * applied to each mount in the tree. 814 * Must be called without spinlocks held, since this function can sleep 815 * in allocations. 816 */ 817 static int attach_recursive_mnt(struct vfsmount *source_mnt, 818 struct nameidata *nd, struct nameidata *parent_nd) 819 { 820 LIST_HEAD(tree_list); 821 struct vfsmount *dest_mnt = nd->mnt; 822 struct dentry *dest_dentry = nd->dentry; 823 struct vfsmount *child, *p; 824 825 if (propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list)) 826 return -EINVAL; 827 828 if (IS_MNT_SHARED(dest_mnt)) { 829 for (p = source_mnt; p; p = next_mnt(p, source_mnt)) 830 set_mnt_shared(p); 831 } 832 833 spin_lock(&vfsmount_lock); 834 if (parent_nd) { 835 detach_mnt(source_mnt, parent_nd); 836 attach_mnt(source_mnt, nd); 837 touch_mnt_namespace(current->nsproxy->mnt_ns); 838 } else { 839 mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt); 840 commit_tree(source_mnt); 841 } 842 843 list_for_each_entry_safe(child, p, &tree_list, mnt_hash) { 844 list_del_init(&child->mnt_hash); 845 commit_tree(child); 846 } 847 spin_unlock(&vfsmount_lock); 848 return 0; 849 } 850 851 static int graft_tree(struct vfsmount *mnt, struct nameidata *nd) 852 { 853 int err; 854 if (mnt->mnt_sb->s_flags & MS_NOUSER) 855 return -EINVAL; 856 857 if (S_ISDIR(nd->dentry->d_inode->i_mode) != 858 S_ISDIR(mnt->mnt_root->d_inode->i_mode)) 859 return -ENOTDIR; 860 861 err = -ENOENT; 862 mutex_lock(&nd->dentry->d_inode->i_mutex); 863 if (IS_DEADDIR(nd->dentry->d_inode)) 864 goto out_unlock; 865 866 err = security_sb_check_sb(mnt, nd); 867 if (err) 868 goto out_unlock; 869 870 err = -ENOENT; 871 if (IS_ROOT(nd->dentry) || !d_unhashed(nd->dentry)) 872 err = attach_recursive_mnt(mnt, nd, NULL); 873 out_unlock: 874 mutex_unlock(&nd->dentry->d_inode->i_mutex); 875 if (!err) 876 security_sb_post_addmount(mnt, nd); 877 return err; 878 } 879 880 /* 881 * recursively change the type of the mountpoint. 882 */ 883 static int do_change_type(struct nameidata *nd, int flag) 884 { 885 struct vfsmount *m, *mnt = nd->mnt; 886 int recurse = flag & MS_REC; 887 int type = flag & ~MS_REC; 888 889 if (nd->dentry != nd->mnt->mnt_root) 890 return -EINVAL; 891 892 down_write(&namespace_sem); 893 spin_lock(&vfsmount_lock); 894 for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL)) 895 change_mnt_propagation(m, type); 896 spin_unlock(&vfsmount_lock); 897 up_write(&namespace_sem); 898 return 0; 899 } 900 901 /* 902 * do loopback mount. 903 */ 904 static int do_loopback(struct nameidata *nd, char *old_name, int recurse) 905 { 906 struct nameidata old_nd; 907 struct vfsmount *mnt = NULL; 908 int err = mount_is_safe(nd); 909 if (err) 910 return err; 911 if (!old_name || !*old_name) 912 return -EINVAL; 913 err = path_lookup(old_name, LOOKUP_FOLLOW, &old_nd); 914 if (err) 915 return err; 916 917 down_write(&namespace_sem); 918 err = -EINVAL; 919 if (IS_MNT_UNBINDABLE(old_nd.mnt)) 920 goto out; 921 922 if (!check_mnt(nd->mnt) || !check_mnt(old_nd.mnt)) 923 goto out; 924 925 err = -ENOMEM; 926 if (recurse) 927 mnt = copy_tree(old_nd.mnt, old_nd.dentry, 0); 928 else 929 mnt = clone_mnt(old_nd.mnt, old_nd.dentry, 0); 930 931 if (!mnt) 932 goto out; 933 934 err = graft_tree(mnt, nd); 935 if (err) { 936 LIST_HEAD(umount_list); 937 spin_lock(&vfsmount_lock); 938 umount_tree(mnt, 0, &umount_list); 939 spin_unlock(&vfsmount_lock); 940 release_mounts(&umount_list); 941 } 942 943 out: 944 up_write(&namespace_sem); 945 path_release(&old_nd); 946 return err; 947 } 948 949 /* 950 * change filesystem flags. dir should be a physical root of filesystem. 951 * If you've mounted a non-root directory somewhere and want to do remount 952 * on it - tough luck. 953 */ 954 static int do_remount(struct nameidata *nd, int flags, int mnt_flags, 955 void *data) 956 { 957 int err; 958 struct super_block *sb = nd->mnt->mnt_sb; 959 960 if (!capable(CAP_SYS_ADMIN)) 961 return -EPERM; 962 963 if (!check_mnt(nd->mnt)) 964 return -EINVAL; 965 966 if (nd->dentry != nd->mnt->mnt_root) 967 return -EINVAL; 968 969 down_write(&sb->s_umount); 970 err = do_remount_sb(sb, flags, data, 0); 971 if (!err) 972 nd->mnt->mnt_flags = mnt_flags; 973 up_write(&sb->s_umount); 974 if (!err) 975 security_sb_post_remount(nd->mnt, flags, data); 976 return err; 977 } 978 979 static inline int tree_contains_unbindable(struct vfsmount *mnt) 980 { 981 struct vfsmount *p; 982 for (p = mnt; p; p = next_mnt(p, mnt)) { 983 if (IS_MNT_UNBINDABLE(p)) 984 return 1; 985 } 986 return 0; 987 } 988 989 static int do_move_mount(struct nameidata *nd, char *old_name) 990 { 991 struct nameidata old_nd, parent_nd; 992 struct vfsmount *p; 993 int err = 0; 994 if (!capable(CAP_SYS_ADMIN)) 995 return -EPERM; 996 if (!old_name || !*old_name) 997 return -EINVAL; 998 err = path_lookup(old_name, LOOKUP_FOLLOW, &old_nd); 999 if (err) 1000 return err; 1001 1002 down_write(&namespace_sem); 1003 while (d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry)) 1004 ; 1005 err = -EINVAL; 1006 if (!check_mnt(nd->mnt) || !check_mnt(old_nd.mnt)) 1007 goto out; 1008 1009 err = -ENOENT; 1010 mutex_lock(&nd->dentry->d_inode->i_mutex); 1011 if (IS_DEADDIR(nd->dentry->d_inode)) 1012 goto out1; 1013 1014 if (!IS_ROOT(nd->dentry) && d_unhashed(nd->dentry)) 1015 goto out1; 1016 1017 err = -EINVAL; 1018 if (old_nd.dentry != old_nd.mnt->mnt_root) 1019 goto out1; 1020 1021 if (old_nd.mnt == old_nd.mnt->mnt_parent) 1022 goto out1; 1023 1024 if (S_ISDIR(nd->dentry->d_inode->i_mode) != 1025 S_ISDIR(old_nd.dentry->d_inode->i_mode)) 1026 goto out1; 1027 /* 1028 * Don't move a mount residing in a shared parent. 1029 */ 1030 if (old_nd.mnt->mnt_parent && IS_MNT_SHARED(old_nd.mnt->mnt_parent)) 1031 goto out1; 1032 /* 1033 * Don't move a mount tree containing unbindable mounts to a destination 1034 * mount which is shared. 1035 */ 1036 if (IS_MNT_SHARED(nd->mnt) && tree_contains_unbindable(old_nd.mnt)) 1037 goto out1; 1038 err = -ELOOP; 1039 for (p = nd->mnt; p->mnt_parent != p; p = p->mnt_parent) 1040 if (p == old_nd.mnt) 1041 goto out1; 1042 1043 if ((err = attach_recursive_mnt(old_nd.mnt, nd, &parent_nd))) 1044 goto out1; 1045 1046 spin_lock(&vfsmount_lock); 1047 /* if the mount is moved, it should no longer be expire 1048 * automatically */ 1049 list_del_init(&old_nd.mnt->mnt_expire); 1050 spin_unlock(&vfsmount_lock); 1051 out1: 1052 mutex_unlock(&nd->dentry->d_inode->i_mutex); 1053 out: 1054 up_write(&namespace_sem); 1055 if (!err) 1056 path_release(&parent_nd); 1057 path_release(&old_nd); 1058 return err; 1059 } 1060 1061 /* 1062 * create a new mount for userspace and request it to be added into the 1063 * namespace's tree 1064 */ 1065 static int do_new_mount(struct nameidata *nd, char *type, int flags, 1066 int mnt_flags, char *name, void *data) 1067 { 1068 struct vfsmount *mnt; 1069 1070 if (!type || !memchr(type, 0, PAGE_SIZE)) 1071 return -EINVAL; 1072 1073 /* we need capabilities... */ 1074 if (!capable(CAP_SYS_ADMIN)) 1075 return -EPERM; 1076 1077 mnt = do_kern_mount(type, flags, name, data); 1078 if (IS_ERR(mnt)) 1079 return PTR_ERR(mnt); 1080 1081 return do_add_mount(mnt, nd, mnt_flags, NULL); 1082 } 1083 1084 /* 1085 * add a mount into a namespace's mount tree 1086 * - provide the option of adding the new mount to an expiration list 1087 */ 1088 int do_add_mount(struct vfsmount *newmnt, struct nameidata *nd, 1089 int mnt_flags, struct list_head *fslist) 1090 { 1091 int err; 1092 1093 down_write(&namespace_sem); 1094 /* Something was mounted here while we slept */ 1095 while (d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry)) 1096 ; 1097 err = -EINVAL; 1098 if (!check_mnt(nd->mnt)) 1099 goto unlock; 1100 1101 /* Refuse the same filesystem on the same mount point */ 1102 err = -EBUSY; 1103 if (nd->mnt->mnt_sb == newmnt->mnt_sb && 1104 nd->mnt->mnt_root == nd->dentry) 1105 goto unlock; 1106 1107 err = -EINVAL; 1108 if (S_ISLNK(newmnt->mnt_root->d_inode->i_mode)) 1109 goto unlock; 1110 1111 newmnt->mnt_flags = mnt_flags; 1112 if ((err = graft_tree(newmnt, nd))) 1113 goto unlock; 1114 1115 if (fslist) { 1116 /* add to the specified expiration list */ 1117 spin_lock(&vfsmount_lock); 1118 list_add_tail(&newmnt->mnt_expire, fslist); 1119 spin_unlock(&vfsmount_lock); 1120 } 1121 up_write(&namespace_sem); 1122 return 0; 1123 1124 unlock: 1125 up_write(&namespace_sem); 1126 mntput(newmnt); 1127 return err; 1128 } 1129 1130 EXPORT_SYMBOL_GPL(do_add_mount); 1131 1132 static void expire_mount(struct vfsmount *mnt, struct list_head *mounts, 1133 struct list_head *umounts) 1134 { 1135 spin_lock(&vfsmount_lock); 1136 1137 /* 1138 * Check if mount is still attached, if not, let whoever holds it deal 1139 * with the sucker 1140 */ 1141 if (mnt->mnt_parent == mnt) { 1142 spin_unlock(&vfsmount_lock); 1143 return; 1144 } 1145 1146 /* 1147 * Check that it is still dead: the count should now be 2 - as 1148 * contributed by the vfsmount parent and the mntget above 1149 */ 1150 if (!propagate_mount_busy(mnt, 2)) { 1151 /* delete from the namespace */ 1152 touch_mnt_namespace(mnt->mnt_ns); 1153 list_del_init(&mnt->mnt_list); 1154 mnt->mnt_ns = NULL; 1155 umount_tree(mnt, 1, umounts); 1156 spin_unlock(&vfsmount_lock); 1157 } else { 1158 /* 1159 * Someone brought it back to life whilst we didn't have any 1160 * locks held so return it to the expiration list 1161 */ 1162 list_add_tail(&mnt->mnt_expire, mounts); 1163 spin_unlock(&vfsmount_lock); 1164 } 1165 } 1166 1167 /* 1168 * go through the vfsmounts we've just consigned to the graveyard to 1169 * - check that they're still dead 1170 * - delete the vfsmount from the appropriate namespace under lock 1171 * - dispose of the corpse 1172 */ 1173 static void expire_mount_list(struct list_head *graveyard, struct list_head *mounts) 1174 { 1175 struct mnt_namespace *ns; 1176 struct vfsmount *mnt; 1177 1178 while (!list_empty(graveyard)) { 1179 LIST_HEAD(umounts); 1180 mnt = list_entry(graveyard->next, struct vfsmount, mnt_expire); 1181 list_del_init(&mnt->mnt_expire); 1182 1183 /* don't do anything if the namespace is dead - all the 1184 * vfsmounts from it are going away anyway */ 1185 ns = mnt->mnt_ns; 1186 if (!ns || !ns->root) 1187 continue; 1188 get_mnt_ns(ns); 1189 1190 spin_unlock(&vfsmount_lock); 1191 down_write(&namespace_sem); 1192 expire_mount(mnt, mounts, &umounts); 1193 up_write(&namespace_sem); 1194 release_mounts(&umounts); 1195 mntput(mnt); 1196 put_mnt_ns(ns); 1197 spin_lock(&vfsmount_lock); 1198 } 1199 } 1200 1201 /* 1202 * process a list of expirable mountpoints with the intent of discarding any 1203 * mountpoints that aren't in use and haven't been touched since last we came 1204 * here 1205 */ 1206 void mark_mounts_for_expiry(struct list_head *mounts) 1207 { 1208 struct vfsmount *mnt, *next; 1209 LIST_HEAD(graveyard); 1210 1211 if (list_empty(mounts)) 1212 return; 1213 1214 spin_lock(&vfsmount_lock); 1215 1216 /* extract from the expiration list every vfsmount that matches the 1217 * following criteria: 1218 * - only referenced by its parent vfsmount 1219 * - still marked for expiry (marked on the last call here; marks are 1220 * cleared by mntput()) 1221 */ 1222 list_for_each_entry_safe(mnt, next, mounts, mnt_expire) { 1223 if (!xchg(&mnt->mnt_expiry_mark, 1) || 1224 atomic_read(&mnt->mnt_count) != 1) 1225 continue; 1226 1227 mntget(mnt); 1228 list_move(&mnt->mnt_expire, &graveyard); 1229 } 1230 1231 expire_mount_list(&graveyard, mounts); 1232 1233 spin_unlock(&vfsmount_lock); 1234 } 1235 1236 EXPORT_SYMBOL_GPL(mark_mounts_for_expiry); 1237 1238 /* 1239 * Ripoff of 'select_parent()' 1240 * 1241 * search the list of submounts for a given mountpoint, and move any 1242 * shrinkable submounts to the 'graveyard' list. 1243 */ 1244 static int select_submounts(struct vfsmount *parent, struct list_head *graveyard) 1245 { 1246 struct vfsmount *this_parent = parent; 1247 struct list_head *next; 1248 int found = 0; 1249 1250 repeat: 1251 next = this_parent->mnt_mounts.next; 1252 resume: 1253 while (next != &this_parent->mnt_mounts) { 1254 struct list_head *tmp = next; 1255 struct vfsmount *mnt = list_entry(tmp, struct vfsmount, mnt_child); 1256 1257 next = tmp->next; 1258 if (!(mnt->mnt_flags & MNT_SHRINKABLE)) 1259 continue; 1260 /* 1261 * Descend a level if the d_mounts list is non-empty. 1262 */ 1263 if (!list_empty(&mnt->mnt_mounts)) { 1264 this_parent = mnt; 1265 goto repeat; 1266 } 1267 1268 if (!propagate_mount_busy(mnt, 1)) { 1269 mntget(mnt); 1270 list_move_tail(&mnt->mnt_expire, graveyard); 1271 found++; 1272 } 1273 } 1274 /* 1275 * All done at this level ... ascend and resume the search 1276 */ 1277 if (this_parent != parent) { 1278 next = this_parent->mnt_child.next; 1279 this_parent = this_parent->mnt_parent; 1280 goto resume; 1281 } 1282 return found; 1283 } 1284 1285 /* 1286 * process a list of expirable mountpoints with the intent of discarding any 1287 * submounts of a specific parent mountpoint 1288 */ 1289 void shrink_submounts(struct vfsmount *mountpoint, struct list_head *mounts) 1290 { 1291 LIST_HEAD(graveyard); 1292 int found; 1293 1294 spin_lock(&vfsmount_lock); 1295 1296 /* extract submounts of 'mountpoint' from the expiration list */ 1297 while ((found = select_submounts(mountpoint, &graveyard)) != 0) 1298 expire_mount_list(&graveyard, mounts); 1299 1300 spin_unlock(&vfsmount_lock); 1301 } 1302 1303 EXPORT_SYMBOL_GPL(shrink_submounts); 1304 1305 /* 1306 * Some copy_from_user() implementations do not return the exact number of 1307 * bytes remaining to copy on a fault. But copy_mount_options() requires that. 1308 * Note that this function differs from copy_from_user() in that it will oops 1309 * on bad values of `to', rather than returning a short copy. 1310 */ 1311 static long exact_copy_from_user(void *to, const void __user * from, 1312 unsigned long n) 1313 { 1314 char *t = to; 1315 const char __user *f = from; 1316 char c; 1317 1318 if (!access_ok(VERIFY_READ, from, n)) 1319 return n; 1320 1321 while (n) { 1322 if (__get_user(c, f)) { 1323 memset(t, 0, n); 1324 break; 1325 } 1326 *t++ = c; 1327 f++; 1328 n--; 1329 } 1330 return n; 1331 } 1332 1333 int copy_mount_options(const void __user * data, unsigned long *where) 1334 { 1335 int i; 1336 unsigned long page; 1337 unsigned long size; 1338 1339 *where = 0; 1340 if (!data) 1341 return 0; 1342 1343 if (!(page = __get_free_page(GFP_KERNEL))) 1344 return -ENOMEM; 1345 1346 /* We only care that *some* data at the address the user 1347 * gave us is valid. Just in case, we'll zero 1348 * the remainder of the page. 1349 */ 1350 /* copy_from_user cannot cross TASK_SIZE ! */ 1351 size = TASK_SIZE - (unsigned long)data; 1352 if (size > PAGE_SIZE) 1353 size = PAGE_SIZE; 1354 1355 i = size - exact_copy_from_user((void *)page, data, size); 1356 if (!i) { 1357 free_page(page); 1358 return -EFAULT; 1359 } 1360 if (i != PAGE_SIZE) 1361 memset((char *)page + i, 0, PAGE_SIZE - i); 1362 *where = page; 1363 return 0; 1364 } 1365 1366 /* 1367 * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to 1368 * be given to the mount() call (ie: read-only, no-dev, no-suid etc). 1369 * 1370 * data is a (void *) that can point to any structure up to 1371 * PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent 1372 * information (or be NULL). 1373 * 1374 * Pre-0.97 versions of mount() didn't have a flags word. 1375 * When the flags word was introduced its top half was required 1376 * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9. 1377 * Therefore, if this magic number is present, it carries no information 1378 * and must be discarded. 1379 */ 1380 long do_mount(char *dev_name, char *dir_name, char *type_page, 1381 unsigned long flags, void *data_page) 1382 { 1383 struct nameidata nd; 1384 int retval = 0; 1385 int mnt_flags = 0; 1386 1387 /* Discard magic */ 1388 if ((flags & MS_MGC_MSK) == MS_MGC_VAL) 1389 flags &= ~MS_MGC_MSK; 1390 1391 /* Basic sanity checks */ 1392 1393 if (!dir_name || !*dir_name || !memchr(dir_name, 0, PAGE_SIZE)) 1394 return -EINVAL; 1395 if (dev_name && !memchr(dev_name, 0, PAGE_SIZE)) 1396 return -EINVAL; 1397 1398 if (data_page) 1399 ((char *)data_page)[PAGE_SIZE - 1] = 0; 1400 1401 /* Separate the per-mountpoint flags */ 1402 if (flags & MS_NOSUID) 1403 mnt_flags |= MNT_NOSUID; 1404 if (flags & MS_NODEV) 1405 mnt_flags |= MNT_NODEV; 1406 if (flags & MS_NOEXEC) 1407 mnt_flags |= MNT_NOEXEC; 1408 if (flags & MS_NOATIME) 1409 mnt_flags |= MNT_NOATIME; 1410 if (flags & MS_NODIRATIME) 1411 mnt_flags |= MNT_NODIRATIME; 1412 if (flags & MS_RELATIME) 1413 mnt_flags |= MNT_RELATIME; 1414 1415 flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE | 1416 MS_NOATIME | MS_NODIRATIME | MS_RELATIME); 1417 1418 /* ... and get the mountpoint */ 1419 retval = path_lookup(dir_name, LOOKUP_FOLLOW, &nd); 1420 if (retval) 1421 return retval; 1422 1423 retval = security_sb_mount(dev_name, &nd, type_page, flags, data_page); 1424 if (retval) 1425 goto dput_out; 1426 1427 if (flags & MS_REMOUNT) 1428 retval = do_remount(&nd, flags & ~MS_REMOUNT, mnt_flags, 1429 data_page); 1430 else if (flags & MS_BIND) 1431 retval = do_loopback(&nd, dev_name, flags & MS_REC); 1432 else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE)) 1433 retval = do_change_type(&nd, flags); 1434 else if (flags & MS_MOVE) 1435 retval = do_move_mount(&nd, dev_name); 1436 else 1437 retval = do_new_mount(&nd, type_page, flags, mnt_flags, 1438 dev_name, data_page); 1439 dput_out: 1440 path_release(&nd); 1441 return retval; 1442 } 1443 1444 /* 1445 * Allocate a new namespace structure and populate it with contents 1446 * copied from the namespace of the passed in task structure. 1447 */ 1448 static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns, 1449 struct fs_struct *fs) 1450 { 1451 struct mnt_namespace *new_ns; 1452 struct vfsmount *rootmnt = NULL, *pwdmnt = NULL, *altrootmnt = NULL; 1453 struct vfsmount *p, *q; 1454 1455 new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL); 1456 if (!new_ns) 1457 return NULL; 1458 1459 atomic_set(&new_ns->count, 1); 1460 INIT_LIST_HEAD(&new_ns->list); 1461 init_waitqueue_head(&new_ns->poll); 1462 new_ns->event = 0; 1463 1464 down_write(&namespace_sem); 1465 /* First pass: copy the tree topology */ 1466 new_ns->root = copy_tree(mnt_ns->root, mnt_ns->root->mnt_root, 1467 CL_COPY_ALL | CL_EXPIRE); 1468 if (!new_ns->root) { 1469 up_write(&namespace_sem); 1470 kfree(new_ns); 1471 return NULL; 1472 } 1473 spin_lock(&vfsmount_lock); 1474 list_add_tail(&new_ns->list, &new_ns->root->mnt_list); 1475 spin_unlock(&vfsmount_lock); 1476 1477 /* 1478 * Second pass: switch the tsk->fs->* elements and mark new vfsmounts 1479 * as belonging to new namespace. We have already acquired a private 1480 * fs_struct, so tsk->fs->lock is not needed. 1481 */ 1482 p = mnt_ns->root; 1483 q = new_ns->root; 1484 while (p) { 1485 q->mnt_ns = new_ns; 1486 if (fs) { 1487 if (p == fs->rootmnt) { 1488 rootmnt = p; 1489 fs->rootmnt = mntget(q); 1490 } 1491 if (p == fs->pwdmnt) { 1492 pwdmnt = p; 1493 fs->pwdmnt = mntget(q); 1494 } 1495 if (p == fs->altrootmnt) { 1496 altrootmnt = p; 1497 fs->altrootmnt = mntget(q); 1498 } 1499 } 1500 p = next_mnt(p, mnt_ns->root); 1501 q = next_mnt(q, new_ns->root); 1502 } 1503 up_write(&namespace_sem); 1504 1505 if (rootmnt) 1506 mntput(rootmnt); 1507 if (pwdmnt) 1508 mntput(pwdmnt); 1509 if (altrootmnt) 1510 mntput(altrootmnt); 1511 1512 return new_ns; 1513 } 1514 1515 struct mnt_namespace *copy_mnt_ns(int flags, struct mnt_namespace *ns, 1516 struct fs_struct *new_fs) 1517 { 1518 struct mnt_namespace *new_ns; 1519 1520 BUG_ON(!ns); 1521 get_mnt_ns(ns); 1522 1523 if (!(flags & CLONE_NEWNS)) 1524 return ns; 1525 1526 new_ns = dup_mnt_ns(ns, new_fs); 1527 1528 put_mnt_ns(ns); 1529 return new_ns; 1530 } 1531 1532 asmlinkage long sys_mount(char __user * dev_name, char __user * dir_name, 1533 char __user * type, unsigned long flags, 1534 void __user * data) 1535 { 1536 int retval; 1537 unsigned long data_page; 1538 unsigned long type_page; 1539 unsigned long dev_page; 1540 char *dir_page; 1541 1542 retval = copy_mount_options(type, &type_page); 1543 if (retval < 0) 1544 return retval; 1545 1546 dir_page = getname(dir_name); 1547 retval = PTR_ERR(dir_page); 1548 if (IS_ERR(dir_page)) 1549 goto out1; 1550 1551 retval = copy_mount_options(dev_name, &dev_page); 1552 if (retval < 0) 1553 goto out2; 1554 1555 retval = copy_mount_options(data, &data_page); 1556 if (retval < 0) 1557 goto out3; 1558 1559 lock_kernel(); 1560 retval = do_mount((char *)dev_page, dir_page, (char *)type_page, 1561 flags, (void *)data_page); 1562 unlock_kernel(); 1563 free_page(data_page); 1564 1565 out3: 1566 free_page(dev_page); 1567 out2: 1568 putname(dir_page); 1569 out1: 1570 free_page(type_page); 1571 return retval; 1572 } 1573 1574 /* 1575 * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values. 1576 * It can block. Requires the big lock held. 1577 */ 1578 void set_fs_root(struct fs_struct *fs, struct vfsmount *mnt, 1579 struct dentry *dentry) 1580 { 1581 struct dentry *old_root; 1582 struct vfsmount *old_rootmnt; 1583 write_lock(&fs->lock); 1584 old_root = fs->root; 1585 old_rootmnt = fs->rootmnt; 1586 fs->rootmnt = mntget(mnt); 1587 fs->root = dget(dentry); 1588 write_unlock(&fs->lock); 1589 if (old_root) { 1590 dput(old_root); 1591 mntput(old_rootmnt); 1592 } 1593 } 1594 1595 /* 1596 * Replace the fs->{pwdmnt,pwd} with {mnt,dentry}. Put the old values. 1597 * It can block. Requires the big lock held. 1598 */ 1599 void set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt, 1600 struct dentry *dentry) 1601 { 1602 struct dentry *old_pwd; 1603 struct vfsmount *old_pwdmnt; 1604 1605 write_lock(&fs->lock); 1606 old_pwd = fs->pwd; 1607 old_pwdmnt = fs->pwdmnt; 1608 fs->pwdmnt = mntget(mnt); 1609 fs->pwd = dget(dentry); 1610 write_unlock(&fs->lock); 1611 1612 if (old_pwd) { 1613 dput(old_pwd); 1614 mntput(old_pwdmnt); 1615 } 1616 } 1617 1618 static void chroot_fs_refs(struct nameidata *old_nd, struct nameidata *new_nd) 1619 { 1620 struct task_struct *g, *p; 1621 struct fs_struct *fs; 1622 1623 read_lock(&tasklist_lock); 1624 do_each_thread(g, p) { 1625 task_lock(p); 1626 fs = p->fs; 1627 if (fs) { 1628 atomic_inc(&fs->count); 1629 task_unlock(p); 1630 if (fs->root == old_nd->dentry 1631 && fs->rootmnt == old_nd->mnt) 1632 set_fs_root(fs, new_nd->mnt, new_nd->dentry); 1633 if (fs->pwd == old_nd->dentry 1634 && fs->pwdmnt == old_nd->mnt) 1635 set_fs_pwd(fs, new_nd->mnt, new_nd->dentry); 1636 put_fs_struct(fs); 1637 } else 1638 task_unlock(p); 1639 } while_each_thread(g, p); 1640 read_unlock(&tasklist_lock); 1641 } 1642 1643 /* 1644 * pivot_root Semantics: 1645 * Moves the root file system of the current process to the directory put_old, 1646 * makes new_root as the new root file system of the current process, and sets 1647 * root/cwd of all processes which had them on the current root to new_root. 1648 * 1649 * Restrictions: 1650 * The new_root and put_old must be directories, and must not be on the 1651 * same file system as the current process root. The put_old must be 1652 * underneath new_root, i.e. adding a non-zero number of /.. to the string 1653 * pointed to by put_old must yield the same directory as new_root. No other 1654 * file system may be mounted on put_old. After all, new_root is a mountpoint. 1655 * 1656 * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem. 1657 * See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives 1658 * in this situation. 1659 * 1660 * Notes: 1661 * - we don't move root/cwd if they are not at the root (reason: if something 1662 * cared enough to change them, it's probably wrong to force them elsewhere) 1663 * - it's okay to pick a root that isn't the root of a file system, e.g. 1664 * /nfs/my_root where /nfs is the mount point. It must be a mountpoint, 1665 * though, so you may need to say mount --bind /nfs/my_root /nfs/my_root 1666 * first. 1667 */ 1668 asmlinkage long sys_pivot_root(const char __user * new_root, 1669 const char __user * put_old) 1670 { 1671 struct vfsmount *tmp; 1672 struct nameidata new_nd, old_nd, parent_nd, root_parent, user_nd; 1673 int error; 1674 1675 if (!capable(CAP_SYS_ADMIN)) 1676 return -EPERM; 1677 1678 lock_kernel(); 1679 1680 error = __user_walk(new_root, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, 1681 &new_nd); 1682 if (error) 1683 goto out0; 1684 error = -EINVAL; 1685 if (!check_mnt(new_nd.mnt)) 1686 goto out1; 1687 1688 error = __user_walk(put_old, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &old_nd); 1689 if (error) 1690 goto out1; 1691 1692 error = security_sb_pivotroot(&old_nd, &new_nd); 1693 if (error) { 1694 path_release(&old_nd); 1695 goto out1; 1696 } 1697 1698 read_lock(¤t->fs->lock); 1699 user_nd.mnt = mntget(current->fs->rootmnt); 1700 user_nd.dentry = dget(current->fs->root); 1701 read_unlock(¤t->fs->lock); 1702 down_write(&namespace_sem); 1703 mutex_lock(&old_nd.dentry->d_inode->i_mutex); 1704 error = -EINVAL; 1705 if (IS_MNT_SHARED(old_nd.mnt) || 1706 IS_MNT_SHARED(new_nd.mnt->mnt_parent) || 1707 IS_MNT_SHARED(user_nd.mnt->mnt_parent)) 1708 goto out2; 1709 if (!check_mnt(user_nd.mnt)) 1710 goto out2; 1711 error = -ENOENT; 1712 if (IS_DEADDIR(new_nd.dentry->d_inode)) 1713 goto out2; 1714 if (d_unhashed(new_nd.dentry) && !IS_ROOT(new_nd.dentry)) 1715 goto out2; 1716 if (d_unhashed(old_nd.dentry) && !IS_ROOT(old_nd.dentry)) 1717 goto out2; 1718 error = -EBUSY; 1719 if (new_nd.mnt == user_nd.mnt || old_nd.mnt == user_nd.mnt) 1720 goto out2; /* loop, on the same file system */ 1721 error = -EINVAL; 1722 if (user_nd.mnt->mnt_root != user_nd.dentry) 1723 goto out2; /* not a mountpoint */ 1724 if (user_nd.mnt->mnt_parent == user_nd.mnt) 1725 goto out2; /* not attached */ 1726 if (new_nd.mnt->mnt_root != new_nd.dentry) 1727 goto out2; /* not a mountpoint */ 1728 if (new_nd.mnt->mnt_parent == new_nd.mnt) 1729 goto out2; /* not attached */ 1730 tmp = old_nd.mnt; /* make sure we can reach put_old from new_root */ 1731 spin_lock(&vfsmount_lock); 1732 if (tmp != new_nd.mnt) { 1733 for (;;) { 1734 if (tmp->mnt_parent == tmp) 1735 goto out3; /* already mounted on put_old */ 1736 if (tmp->mnt_parent == new_nd.mnt) 1737 break; 1738 tmp = tmp->mnt_parent; 1739 } 1740 if (!is_subdir(tmp->mnt_mountpoint, new_nd.dentry)) 1741 goto out3; 1742 } else if (!is_subdir(old_nd.dentry, new_nd.dentry)) 1743 goto out3; 1744 detach_mnt(new_nd.mnt, &parent_nd); 1745 detach_mnt(user_nd.mnt, &root_parent); 1746 attach_mnt(user_nd.mnt, &old_nd); /* mount old root on put_old */ 1747 attach_mnt(new_nd.mnt, &root_parent); /* mount new_root on / */ 1748 touch_mnt_namespace(current->nsproxy->mnt_ns); 1749 spin_unlock(&vfsmount_lock); 1750 chroot_fs_refs(&user_nd, &new_nd); 1751 security_sb_post_pivotroot(&user_nd, &new_nd); 1752 error = 0; 1753 path_release(&root_parent); 1754 path_release(&parent_nd); 1755 out2: 1756 mutex_unlock(&old_nd.dentry->d_inode->i_mutex); 1757 up_write(&namespace_sem); 1758 path_release(&user_nd); 1759 path_release(&old_nd); 1760 out1: 1761 path_release(&new_nd); 1762 out0: 1763 unlock_kernel(); 1764 return error; 1765 out3: 1766 spin_unlock(&vfsmount_lock); 1767 goto out2; 1768 } 1769 1770 static void __init init_mount_tree(void) 1771 { 1772 struct vfsmount *mnt; 1773 struct mnt_namespace *ns; 1774 1775 mnt = do_kern_mount("rootfs", 0, "rootfs", NULL); 1776 if (IS_ERR(mnt)) 1777 panic("Can't create rootfs"); 1778 ns = kmalloc(sizeof(*ns), GFP_KERNEL); 1779 if (!ns) 1780 panic("Can't allocate initial namespace"); 1781 atomic_set(&ns->count, 1); 1782 INIT_LIST_HEAD(&ns->list); 1783 init_waitqueue_head(&ns->poll); 1784 ns->event = 0; 1785 list_add(&mnt->mnt_list, &ns->list); 1786 ns->root = mnt; 1787 mnt->mnt_ns = ns; 1788 1789 init_task.nsproxy->mnt_ns = ns; 1790 get_mnt_ns(ns); 1791 1792 set_fs_pwd(current->fs, ns->root, ns->root->mnt_root); 1793 set_fs_root(current->fs, ns->root, ns->root->mnt_root); 1794 } 1795 1796 void __init mnt_init(unsigned long mempages) 1797 { 1798 struct list_head *d; 1799 unsigned int nr_hash; 1800 int i; 1801 int err; 1802 1803 init_rwsem(&namespace_sem); 1804 1805 mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct vfsmount), 1806 0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL, NULL); 1807 1808 mount_hashtable = (struct list_head *)__get_free_page(GFP_ATOMIC); 1809 1810 if (!mount_hashtable) 1811 panic("Failed to allocate mount hash table\n"); 1812 1813 /* 1814 * Find the power-of-two list-heads that can fit into the allocation.. 1815 * We don't guarantee that "sizeof(struct list_head)" is necessarily 1816 * a power-of-two. 1817 */ 1818 nr_hash = PAGE_SIZE / sizeof(struct list_head); 1819 hash_bits = 0; 1820 do { 1821 hash_bits++; 1822 } while ((nr_hash >> hash_bits) != 0); 1823 hash_bits--; 1824 1825 /* 1826 * Re-calculate the actual number of entries and the mask 1827 * from the number of bits we can fit. 1828 */ 1829 nr_hash = 1UL << hash_bits; 1830 hash_mask = nr_hash - 1; 1831 1832 printk("Mount-cache hash table entries: %d\n", nr_hash); 1833 1834 /* And initialize the newly allocated array */ 1835 d = mount_hashtable; 1836 i = nr_hash; 1837 do { 1838 INIT_LIST_HEAD(d); 1839 d++; 1840 i--; 1841 } while (i); 1842 err = sysfs_init(); 1843 if (err) 1844 printk(KERN_WARNING "%s: sysfs_init error: %d\n", 1845 __FUNCTION__, err); 1846 err = subsystem_register(&fs_subsys); 1847 if (err) 1848 printk(KERN_WARNING "%s: subsystem_register error: %d\n", 1849 __FUNCTION__, err); 1850 init_rootfs(); 1851 init_mount_tree(); 1852 } 1853 1854 void __put_mnt_ns(struct mnt_namespace *ns) 1855 { 1856 struct vfsmount *root = ns->root; 1857 LIST_HEAD(umount_list); 1858 ns->root = NULL; 1859 spin_unlock(&vfsmount_lock); 1860 down_write(&namespace_sem); 1861 spin_lock(&vfsmount_lock); 1862 umount_tree(root, 0, &umount_list); 1863 spin_unlock(&vfsmount_lock); 1864 up_write(&namespace_sem); 1865 release_mounts(&umount_list); 1866 kfree(ns); 1867 } 1868