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 35static int event; 36 37static struct list_head *mount_hashtable __read_mostly; 38static int hash_mask __read_mostly, hash_bits __read_mostly; 39static struct kmem_cache *mnt_cache __read_mostly; 40static struct rw_semaphore namespace_sem; 41 42/* /sys/fs */ 43decl_subsys(fs, NULL, NULL); 44EXPORT_SYMBOL_GPL(fs_subsys); 45 46static 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 54struct 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 79int 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 86EXPORT_SYMBOL(simple_set_mnt); 87 88void 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 */ 98struct 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 */ 123struct 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 133static inline int check_mnt(struct vfsmount *mnt) 134{ 135 return mnt->mnt_ns == current->nsproxy->mnt_ns; 136} 137 138static 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 146static 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 154static 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 165void 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 173static 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 */ 184static 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 204static 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 220static 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 230static 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 270static 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 278void mntput_no_expire(struct vfsmount *mnt) 279{ 280repeat: 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 296EXPORT_SYMBOL(mntput_no_expire); 297 298void mnt_pin(struct vfsmount *mnt) 299{ 300 spin_lock(&vfsmount_lock); 301 mnt->mnt_pinned++; 302 spin_unlock(&vfsmount_lock); 303} 304 305EXPORT_SYMBOL(mnt_pin); 306 307void 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 317EXPORT_SYMBOL(mnt_unpin); 318 319/* iterator */ 320static 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 333static 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 341static void m_stop(struct seq_file *m, void *v) 342{ 343 up_read(&namespace_sem); 344} 345 346static inline void mangle(struct seq_file *m, const char *s) 347{ 348 seq_escape(m, s, " \t\n\\"); 349} 350 351static 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 399struct seq_operations mounts_op = { 400 .start = m_start, 401 .next = m_next, 402 .stop = m_stop, 403 .show = show_vfsmnt 404}; 405 406static 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 437struct 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 */ 452int 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 471EXPORT_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 */ 486int 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 496EXPORT_SYMBOL(may_umount); 497 498void release_mounts(struct list_head *head) 499{ 500 struct vfsmount *mnt; 501 while (!list_empty(head)) { 502 mnt = list_first_entry(head, 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 520void 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 542static 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 636asmlinkage 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); 655dput_and_out: 656 path_release_on_umount(&nd); 657out: 658 return retval; 659} 660 661#ifdef __ARCH_WANT_SYS_OLDUMOUNT 662 663/* 664 * The 2.0 compatible umount. No flags. 665 */ 666asmlinkage long sys_oldumount(char __user * name) 667{ 668 return sys_umount(name, 0); 669} 670 671#endif 672 673static 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 691static 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 702struct 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; 743Enomem: 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 */ 817static 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 851static 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); 873out_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 */ 883static 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 (!capable(CAP_SYS_ADMIN)) 890 return -EPERM; 891 892 if (nd->dentry != nd->mnt->mnt_root) 893 return -EINVAL; 894 895 down_write(&namespace_sem); 896 spin_lock(&vfsmount_lock); 897 for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL)) 898 change_mnt_propagation(m, type); 899 spin_unlock(&vfsmount_lock); 900 up_write(&namespace_sem); 901 return 0; 902} 903 904/* 905 * do loopback mount. 906 */ 907static int do_loopback(struct nameidata *nd, char *old_name, int recurse) 908{ 909 struct nameidata old_nd; 910 struct vfsmount *mnt = NULL; 911 int err = mount_is_safe(nd); 912 if (err) 913 return err; 914 if (!old_name || !*old_name) 915 return -EINVAL; 916 err = path_lookup(old_name, LOOKUP_FOLLOW, &old_nd); 917 if (err) 918 return err; 919 920 down_write(&namespace_sem); 921 err = -EINVAL; 922 if (IS_MNT_UNBINDABLE(old_nd.mnt)) 923 goto out; 924 925 if (!check_mnt(nd->mnt) || !check_mnt(old_nd.mnt)) 926 goto out; 927 928 err = -ENOMEM; 929 if (recurse) 930 mnt = copy_tree(old_nd.mnt, old_nd.dentry, 0); 931 else 932 mnt = clone_mnt(old_nd.mnt, old_nd.dentry, 0); 933 934 if (!mnt) 935 goto out; 936 937 err = graft_tree(mnt, nd); 938 if (err) { 939 LIST_HEAD(umount_list); 940 spin_lock(&vfsmount_lock); 941 umount_tree(mnt, 0, &umount_list); 942 spin_unlock(&vfsmount_lock); 943 release_mounts(&umount_list); 944 } 945 946out: 947 up_write(&namespace_sem); 948 path_release(&old_nd); 949 return err; 950} 951 952/* 953 * change filesystem flags. dir should be a physical root of filesystem. 954 * If you've mounted a non-root directory somewhere and want to do remount 955 * on it - tough luck. 956 */ 957static int do_remount(struct nameidata *nd, int flags, int mnt_flags, 958 void *data) 959{ 960 int err; 961 struct super_block *sb = nd->mnt->mnt_sb; 962 963 if (!capable(CAP_SYS_ADMIN)) 964 return -EPERM; 965 966 if (!check_mnt(nd->mnt)) 967 return -EINVAL; 968 969 if (nd->dentry != nd->mnt->mnt_root) 970 return -EINVAL; 971 972 down_write(&sb->s_umount); 973 err = do_remount_sb(sb, flags, data, 0); 974 if (!err) 975 nd->mnt->mnt_flags = mnt_flags; 976 up_write(&sb->s_umount); 977 if (!err) 978 security_sb_post_remount(nd->mnt, flags, data); 979 return err; 980} 981 982static inline int tree_contains_unbindable(struct vfsmount *mnt) 983{ 984 struct vfsmount *p; 985 for (p = mnt; p; p = next_mnt(p, mnt)) { 986 if (IS_MNT_UNBINDABLE(p)) 987 return 1; 988 } 989 return 0; 990} 991 992static int do_move_mount(struct nameidata *nd, char *old_name) 993{ 994 struct nameidata old_nd, parent_nd; 995 struct vfsmount *p; 996 int err = 0; 997 if (!capable(CAP_SYS_ADMIN)) 998 return -EPERM; 999 if (!old_name || !*old_name) 1000 return -EINVAL; 1001 err = path_lookup(old_name, LOOKUP_FOLLOW, &old_nd); 1002 if (err) 1003 return err; 1004 1005 down_write(&namespace_sem); 1006 while (d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry)) 1007 ; 1008 err = -EINVAL; 1009 if (!check_mnt(nd->mnt) || !check_mnt(old_nd.mnt)) 1010 goto out; 1011 1012 err = -ENOENT; 1013 mutex_lock(&nd->dentry->d_inode->i_mutex); 1014 if (IS_DEADDIR(nd->dentry->d_inode)) 1015 goto out1; 1016 1017 if (!IS_ROOT(nd->dentry) && d_unhashed(nd->dentry)) 1018 goto out1; 1019 1020 err = -EINVAL; 1021 if (old_nd.dentry != old_nd.mnt->mnt_root) 1022 goto out1; 1023 1024 if (old_nd.mnt == old_nd.mnt->mnt_parent) 1025 goto out1; 1026 1027 if (S_ISDIR(nd->dentry->d_inode->i_mode) != 1028 S_ISDIR(old_nd.dentry->d_inode->i_mode)) 1029 goto out1; 1030 /* 1031 * Don't move a mount residing in a shared parent. 1032 */ 1033 if (old_nd.mnt->mnt_parent && IS_MNT_SHARED(old_nd.mnt->mnt_parent)) 1034 goto out1; 1035 /* 1036 * Don't move a mount tree containing unbindable mounts to a destination 1037 * mount which is shared. 1038 */ 1039 if (IS_MNT_SHARED(nd->mnt) && tree_contains_unbindable(old_nd.mnt)) 1040 goto out1; 1041 err = -ELOOP; 1042 for (p = nd->mnt; p->mnt_parent != p; p = p->mnt_parent) 1043 if (p == old_nd.mnt) 1044 goto out1; 1045 1046 if ((err = attach_recursive_mnt(old_nd.mnt, nd, &parent_nd))) 1047 goto out1; 1048 1049 spin_lock(&vfsmount_lock); 1050 /* if the mount is moved, it should no longer be expire 1051 * automatically */ 1052 list_del_init(&old_nd.mnt->mnt_expire); 1053 spin_unlock(&vfsmount_lock); 1054out1: 1055 mutex_unlock(&nd->dentry->d_inode->i_mutex); 1056out: 1057 up_write(&namespace_sem); 1058 if (!err) 1059 path_release(&parent_nd); 1060 path_release(&old_nd); 1061 return err; 1062} 1063 1064/* 1065 * create a new mount for userspace and request it to be added into the 1066 * namespace's tree 1067 */ 1068static int do_new_mount(struct nameidata *nd, char *type, int flags, 1069 int mnt_flags, char *name, void *data) 1070{ 1071 struct vfsmount *mnt; 1072 1073 if (!type || !memchr(type, 0, PAGE_SIZE)) 1074 return -EINVAL; 1075 1076 /* we need capabilities... */ 1077 if (!capable(CAP_SYS_ADMIN)) 1078 return -EPERM; 1079 1080 mnt = do_kern_mount(type, flags, name, data); 1081 if (IS_ERR(mnt)) 1082 return PTR_ERR(mnt); 1083 1084 return do_add_mount(mnt, nd, mnt_flags, NULL); 1085} 1086 1087/* 1088 * add a mount into a namespace's mount tree 1089 * - provide the option of adding the new mount to an expiration list 1090 */ 1091int do_add_mount(struct vfsmount *newmnt, struct nameidata *nd, 1092 int mnt_flags, struct list_head *fslist) 1093{ 1094 int err; 1095 1096 down_write(&namespace_sem); 1097 /* Something was mounted here while we slept */ 1098 while (d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry)) 1099 ; 1100 err = -EINVAL; 1101 if (!check_mnt(nd->mnt)) 1102 goto unlock; 1103 1104 /* Refuse the same filesystem on the same mount point */ 1105 err = -EBUSY; 1106 if (nd->mnt->mnt_sb == newmnt->mnt_sb && 1107 nd->mnt->mnt_root == nd->dentry) 1108 goto unlock; 1109 1110 err = -EINVAL; 1111 if (S_ISLNK(newmnt->mnt_root->d_inode->i_mode)) 1112 goto unlock; 1113 1114 newmnt->mnt_flags = mnt_flags; 1115 if ((err = graft_tree(newmnt, nd))) 1116 goto unlock; 1117 1118 if (fslist) { 1119 /* add to the specified expiration list */ 1120 spin_lock(&vfsmount_lock); 1121 list_add_tail(&newmnt->mnt_expire, fslist); 1122 spin_unlock(&vfsmount_lock); 1123 } 1124 up_write(&namespace_sem); 1125 return 0; 1126 1127unlock: 1128 up_write(&namespace_sem); 1129 mntput(newmnt); 1130 return err; 1131} 1132 1133EXPORT_SYMBOL_GPL(do_add_mount); 1134 1135static void expire_mount(struct vfsmount *mnt, struct list_head *mounts, 1136 struct list_head *umounts) 1137{ 1138 spin_lock(&vfsmount_lock); 1139 1140 /* 1141 * Check if mount is still attached, if not, let whoever holds it deal 1142 * with the sucker 1143 */ 1144 if (mnt->mnt_parent == mnt) { 1145 spin_unlock(&vfsmount_lock); 1146 return; 1147 } 1148 1149 /* 1150 * Check that it is still dead: the count should now be 2 - as 1151 * contributed by the vfsmount parent and the mntget above 1152 */ 1153 if (!propagate_mount_busy(mnt, 2)) { 1154 /* delete from the namespace */ 1155 touch_mnt_namespace(mnt->mnt_ns); 1156 list_del_init(&mnt->mnt_list); 1157 mnt->mnt_ns = NULL; 1158 umount_tree(mnt, 1, umounts); 1159 spin_unlock(&vfsmount_lock); 1160 } else { 1161 /* 1162 * Someone brought it back to life whilst we didn't have any 1163 * locks held so return it to the expiration list 1164 */ 1165 list_add_tail(&mnt->mnt_expire, mounts); 1166 spin_unlock(&vfsmount_lock); 1167 } 1168} 1169 1170/* 1171 * go through the vfsmounts we've just consigned to the graveyard to 1172 * - check that they're still dead 1173 * - delete the vfsmount from the appropriate namespace under lock 1174 * - dispose of the corpse 1175 */ 1176static void expire_mount_list(struct list_head *graveyard, struct list_head *mounts) 1177{ 1178 struct mnt_namespace *ns; 1179 struct vfsmount *mnt; 1180 1181 while (!list_empty(graveyard)) { 1182 LIST_HEAD(umounts); 1183 mnt = list_first_entry(graveyard, struct vfsmount, mnt_expire); 1184 list_del_init(&mnt->mnt_expire); 1185 1186 /* don't do anything if the namespace is dead - all the 1187 * vfsmounts from it are going away anyway */ 1188 ns = mnt->mnt_ns; 1189 if (!ns || !ns->root) 1190 continue; 1191 get_mnt_ns(ns); 1192 1193 spin_unlock(&vfsmount_lock); 1194 down_write(&namespace_sem); 1195 expire_mount(mnt, mounts, &umounts); 1196 up_write(&namespace_sem); 1197 release_mounts(&umounts); 1198 mntput(mnt); 1199 put_mnt_ns(ns); 1200 spin_lock(&vfsmount_lock); 1201 } 1202} 1203 1204/* 1205 * process a list of expirable mountpoints with the intent of discarding any 1206 * mountpoints that aren't in use and haven't been touched since last we came 1207 * here 1208 */ 1209void mark_mounts_for_expiry(struct list_head *mounts) 1210{ 1211 struct vfsmount *mnt, *next; 1212 LIST_HEAD(graveyard); 1213 1214 if (list_empty(mounts)) 1215 return; 1216 1217 spin_lock(&vfsmount_lock); 1218 1219 /* extract from the expiration list every vfsmount that matches the 1220 * following criteria: 1221 * - only referenced by its parent vfsmount 1222 * - still marked for expiry (marked on the last call here; marks are 1223 * cleared by mntput()) 1224 */ 1225 list_for_each_entry_safe(mnt, next, mounts, mnt_expire) { 1226 if (!xchg(&mnt->mnt_expiry_mark, 1) || 1227 atomic_read(&mnt->mnt_count) != 1) 1228 continue; 1229 1230 mntget(mnt); 1231 list_move(&mnt->mnt_expire, &graveyard); 1232 } 1233 1234 expire_mount_list(&graveyard, mounts); 1235 1236 spin_unlock(&vfsmount_lock); 1237} 1238 1239EXPORT_SYMBOL_GPL(mark_mounts_for_expiry); 1240 1241/* 1242 * Ripoff of 'select_parent()' 1243 * 1244 * search the list of submounts for a given mountpoint, and move any 1245 * shrinkable submounts to the 'graveyard' list. 1246 */ 1247static int select_submounts(struct vfsmount *parent, struct list_head *graveyard) 1248{ 1249 struct vfsmount *this_parent = parent; 1250 struct list_head *next; 1251 int found = 0; 1252 1253repeat: 1254 next = this_parent->mnt_mounts.next; 1255resume: 1256 while (next != &this_parent->mnt_mounts) { 1257 struct list_head *tmp = next; 1258 struct vfsmount *mnt = list_entry(tmp, struct vfsmount, mnt_child); 1259 1260 next = tmp->next; 1261 if (!(mnt->mnt_flags & MNT_SHRINKABLE)) 1262 continue; 1263 /* 1264 * Descend a level if the d_mounts list is non-empty. 1265 */ 1266 if (!list_empty(&mnt->mnt_mounts)) { 1267 this_parent = mnt; 1268 goto repeat; 1269 } 1270 1271 if (!propagate_mount_busy(mnt, 1)) { 1272 mntget(mnt); 1273 list_move_tail(&mnt->mnt_expire, graveyard); 1274 found++; 1275 } 1276 } 1277 /* 1278 * All done at this level ... ascend and resume the search 1279 */ 1280 if (this_parent != parent) { 1281 next = this_parent->mnt_child.next; 1282 this_parent = this_parent->mnt_parent; 1283 goto resume; 1284 } 1285 return found; 1286} 1287 1288/* 1289 * process a list of expirable mountpoints with the intent of discarding any 1290 * submounts of a specific parent mountpoint 1291 */ 1292void shrink_submounts(struct vfsmount *mountpoint, struct list_head *mounts) 1293{ 1294 LIST_HEAD(graveyard); 1295 int found; 1296 1297 spin_lock(&vfsmount_lock); 1298 1299 /* extract submounts of 'mountpoint' from the expiration list */ 1300 while ((found = select_submounts(mountpoint, &graveyard)) != 0) 1301 expire_mount_list(&graveyard, mounts); 1302 1303 spin_unlock(&vfsmount_lock); 1304} 1305 1306EXPORT_SYMBOL_GPL(shrink_submounts); 1307 1308/* 1309 * Some copy_from_user() implementations do not return the exact number of 1310 * bytes remaining to copy on a fault. But copy_mount_options() requires that. 1311 * Note that this function differs from copy_from_user() in that it will oops 1312 * on bad values of `to', rather than returning a short copy. 1313 */ 1314static long exact_copy_from_user(void *to, const void __user * from, 1315 unsigned long n) 1316{ 1317 char *t = to; 1318 const char __user *f = from; 1319 char c; 1320 1321 if (!access_ok(VERIFY_READ, from, n)) 1322 return n; 1323 1324 while (n) { 1325 if (__get_user(c, f)) { 1326 memset(t, 0, n); 1327 break; 1328 } 1329 *t++ = c; 1330 f++; 1331 n--; 1332 } 1333 return n; 1334} 1335 1336int copy_mount_options(const void __user * data, unsigned long *where) 1337{ 1338 int i; 1339 unsigned long page; 1340 unsigned long size; 1341 1342 *where = 0; 1343 if (!data) 1344 return 0; 1345 1346 if (!(page = __get_free_page(GFP_KERNEL))) 1347 return -ENOMEM; 1348 1349 /* We only care that *some* data at the address the user 1350 * gave us is valid. Just in case, we'll zero 1351 * the remainder of the page. 1352 */ 1353 /* copy_from_user cannot cross TASK_SIZE ! */ 1354 size = TASK_SIZE - (unsigned long)data; 1355 if (size > PAGE_SIZE) 1356 size = PAGE_SIZE; 1357 1358 i = size - exact_copy_from_user((void *)page, data, size); 1359 if (!i) { 1360 free_page(page); 1361 return -EFAULT; 1362 } 1363 if (i != PAGE_SIZE) 1364 memset((char *)page + i, 0, PAGE_SIZE - i); 1365 *where = page; 1366 return 0; 1367} 1368 1369/* 1370 * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to 1371 * be given to the mount() call (ie: read-only, no-dev, no-suid etc). 1372 * 1373 * data is a (void *) that can point to any structure up to 1374 * PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent 1375 * information (or be NULL). 1376 * 1377 * Pre-0.97 versions of mount() didn't have a flags word. 1378 * When the flags word was introduced its top half was required 1379 * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9. 1380 * Therefore, if this magic number is present, it carries no information 1381 * and must be discarded. 1382 */ 1383long do_mount(char *dev_name, char *dir_name, char *type_page, 1384 unsigned long flags, void *data_page) 1385{ 1386 struct nameidata nd; 1387 int retval = 0; 1388 int mnt_flags = 0; 1389 1390 /* Discard magic */ 1391 if ((flags & MS_MGC_MSK) == MS_MGC_VAL) 1392 flags &= ~MS_MGC_MSK; 1393 1394 /* Basic sanity checks */ 1395 1396 if (!dir_name || !*dir_name || !memchr(dir_name, 0, PAGE_SIZE)) 1397 return -EINVAL; 1398 if (dev_name && !memchr(dev_name, 0, PAGE_SIZE)) 1399 return -EINVAL; 1400 1401 if (data_page) 1402 ((char *)data_page)[PAGE_SIZE - 1] = 0; 1403 1404 /* Separate the per-mountpoint flags */ 1405 if (flags & MS_NOSUID) 1406 mnt_flags |= MNT_NOSUID; 1407 if (flags & MS_NODEV) 1408 mnt_flags |= MNT_NODEV; 1409 if (flags & MS_NOEXEC) 1410 mnt_flags |= MNT_NOEXEC; 1411 if (flags & MS_NOATIME) 1412 mnt_flags |= MNT_NOATIME; 1413 if (flags & MS_NODIRATIME) 1414 mnt_flags |= MNT_NODIRATIME; 1415 if (flags & MS_RELATIME) 1416 mnt_flags |= MNT_RELATIME; 1417 1418 flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE | 1419 MS_NOATIME | MS_NODIRATIME | MS_RELATIME); 1420 1421 /* ... and get the mountpoint */ 1422 retval = path_lookup(dir_name, LOOKUP_FOLLOW, &nd); 1423 if (retval) 1424 return retval; 1425 1426 retval = security_sb_mount(dev_name, &nd, type_page, flags, data_page); 1427 if (retval) 1428 goto dput_out; 1429 1430 if (flags & MS_REMOUNT) 1431 retval = do_remount(&nd, flags & ~MS_REMOUNT, mnt_flags, 1432 data_page); 1433 else if (flags & MS_BIND) 1434 retval = do_loopback(&nd, dev_name, flags & MS_REC); 1435 else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE)) 1436 retval = do_change_type(&nd, flags); 1437 else if (flags & MS_MOVE) 1438 retval = do_move_mount(&nd, dev_name); 1439 else 1440 retval = do_new_mount(&nd, type_page, flags, mnt_flags, 1441 dev_name, data_page); 1442dput_out: 1443 path_release(&nd); 1444 return retval; 1445} 1446 1447/* 1448 * Allocate a new namespace structure and populate it with contents 1449 * copied from the namespace of the passed in task structure. 1450 */ 1451static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns, 1452 struct fs_struct *fs) 1453{ 1454 struct mnt_namespace *new_ns; 1455 struct vfsmount *rootmnt = NULL, *pwdmnt = NULL, *altrootmnt = NULL; 1456 struct vfsmount *p, *q; 1457 1458 new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL); 1459 if (!new_ns) 1460 return NULL; 1461 1462 atomic_set(&new_ns->count, 1); 1463 INIT_LIST_HEAD(&new_ns->list); 1464 init_waitqueue_head(&new_ns->poll); 1465 new_ns->event = 0; 1466 1467 down_write(&namespace_sem); 1468 /* First pass: copy the tree topology */ 1469 new_ns->root = copy_tree(mnt_ns->root, mnt_ns->root->mnt_root, 1470 CL_COPY_ALL | CL_EXPIRE); 1471 if (!new_ns->root) { 1472 up_write(&namespace_sem); 1473 kfree(new_ns); 1474 return NULL; 1475 } 1476 spin_lock(&vfsmount_lock); 1477 list_add_tail(&new_ns->list, &new_ns->root->mnt_list); 1478 spin_unlock(&vfsmount_lock); 1479 1480 /* 1481 * Second pass: switch the tsk->fs->* elements and mark new vfsmounts 1482 * as belonging to new namespace. We have already acquired a private 1483 * fs_struct, so tsk->fs->lock is not needed. 1484 */ 1485 p = mnt_ns->root; 1486 q = new_ns->root; 1487 while (p) { 1488 q->mnt_ns = new_ns; 1489 if (fs) { 1490 if (p == fs->rootmnt) { 1491 rootmnt = p; 1492 fs->rootmnt = mntget(q); 1493 } 1494 if (p == fs->pwdmnt) { 1495 pwdmnt = p; 1496 fs->pwdmnt = mntget(q); 1497 } 1498 if (p == fs->altrootmnt) { 1499 altrootmnt = p; 1500 fs->altrootmnt = mntget(q); 1501 } 1502 } 1503 p = next_mnt(p, mnt_ns->root); 1504 q = next_mnt(q, new_ns->root); 1505 } 1506 up_write(&namespace_sem); 1507 1508 if (rootmnt) 1509 mntput(rootmnt); 1510 if (pwdmnt) 1511 mntput(pwdmnt); 1512 if (altrootmnt) 1513 mntput(altrootmnt); 1514 1515 return new_ns; 1516} 1517 1518struct mnt_namespace *copy_mnt_ns(int flags, struct mnt_namespace *ns, 1519 struct fs_struct *new_fs) 1520{ 1521 struct mnt_namespace *new_ns; 1522 1523 BUG_ON(!ns); 1524 get_mnt_ns(ns); 1525 1526 if (!(flags & CLONE_NEWNS)) 1527 return ns; 1528 1529 new_ns = dup_mnt_ns(ns, new_fs); 1530 1531 put_mnt_ns(ns); 1532 return new_ns; 1533} 1534 1535asmlinkage long sys_mount(char __user * dev_name, char __user * dir_name, 1536 char __user * type, unsigned long flags, 1537 void __user * data) 1538{ 1539 int retval; 1540 unsigned long data_page; 1541 unsigned long type_page; 1542 unsigned long dev_page; 1543 char *dir_page; 1544 1545 retval = copy_mount_options(type, &type_page); 1546 if (retval < 0) 1547 return retval; 1548 1549 dir_page = getname(dir_name); 1550 retval = PTR_ERR(dir_page); 1551 if (IS_ERR(dir_page)) 1552 goto out1; 1553 1554 retval = copy_mount_options(dev_name, &dev_page); 1555 if (retval < 0) 1556 goto out2; 1557 1558 retval = copy_mount_options(data, &data_page); 1559 if (retval < 0) 1560 goto out3; 1561 1562 lock_kernel(); 1563 retval = do_mount((char *)dev_page, dir_page, (char *)type_page, 1564 flags, (void *)data_page); 1565 unlock_kernel(); 1566 free_page(data_page); 1567 1568out3: 1569 free_page(dev_page); 1570out2: 1571 putname(dir_page); 1572out1: 1573 free_page(type_page); 1574 return retval; 1575} 1576 1577/* 1578 * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values. 1579 * It can block. Requires the big lock held. 1580 */ 1581void set_fs_root(struct fs_struct *fs, struct vfsmount *mnt, 1582 struct dentry *dentry) 1583{ 1584 struct dentry *old_root; 1585 struct vfsmount *old_rootmnt; 1586 write_lock(&fs->lock); 1587 old_root = fs->root; 1588 old_rootmnt = fs->rootmnt; 1589 fs->rootmnt = mntget(mnt); 1590 fs->root = dget(dentry); 1591 write_unlock(&fs->lock); 1592 if (old_root) { 1593 dput(old_root); 1594 mntput(old_rootmnt); 1595 } 1596} 1597 1598/* 1599 * Replace the fs->{pwdmnt,pwd} with {mnt,dentry}. Put the old values. 1600 * It can block. Requires the big lock held. 1601 */ 1602void set_fs_pwd(struct fs_struct *fs, struct vfsmount *mnt, 1603 struct dentry *dentry) 1604{ 1605 struct dentry *old_pwd; 1606 struct vfsmount *old_pwdmnt; 1607 1608 write_lock(&fs->lock); 1609 old_pwd = fs->pwd; 1610 old_pwdmnt = fs->pwdmnt; 1611 fs->pwdmnt = mntget(mnt); 1612 fs->pwd = dget(dentry); 1613 write_unlock(&fs->lock); 1614 1615 if (old_pwd) { 1616 dput(old_pwd); 1617 mntput(old_pwdmnt); 1618 } 1619} 1620 1621static void chroot_fs_refs(struct nameidata *old_nd, struct nameidata *new_nd) 1622{ 1623 struct task_struct *g, *p; 1624 struct fs_struct *fs; 1625 1626 read_lock(&tasklist_lock); 1627 do_each_thread(g, p) { 1628 task_lock(p); 1629 fs = p->fs; 1630 if (fs) { 1631 atomic_inc(&fs->count); 1632 task_unlock(p); 1633 if (fs->root == old_nd->dentry 1634 && fs->rootmnt == old_nd->mnt) 1635 set_fs_root(fs, new_nd->mnt, new_nd->dentry); 1636 if (fs->pwd == old_nd->dentry 1637 && fs->pwdmnt == old_nd->mnt) 1638 set_fs_pwd(fs, new_nd->mnt, new_nd->dentry); 1639 put_fs_struct(fs); 1640 } else 1641 task_unlock(p); 1642 } while_each_thread(g, p); 1643 read_unlock(&tasklist_lock); 1644} 1645 1646/* 1647 * pivot_root Semantics: 1648 * Moves the root file system of the current process to the directory put_old, 1649 * makes new_root as the new root file system of the current process, and sets 1650 * root/cwd of all processes which had them on the current root to new_root. 1651 * 1652 * Restrictions: 1653 * The new_root and put_old must be directories, and must not be on the 1654 * same file system as the current process root. The put_old must be 1655 * underneath new_root, i.e. adding a non-zero number of /.. to the string 1656 * pointed to by put_old must yield the same directory as new_root. No other 1657 * file system may be mounted on put_old. After all, new_root is a mountpoint. 1658 * 1659 * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem. 1660 * See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives 1661 * in this situation. 1662 * 1663 * Notes: 1664 * - we don't move root/cwd if they are not at the root (reason: if something 1665 * cared enough to change them, it's probably wrong to force them elsewhere) 1666 * - it's okay to pick a root that isn't the root of a file system, e.g. 1667 * /nfs/my_root where /nfs is the mount point. It must be a mountpoint, 1668 * though, so you may need to say mount --bind /nfs/my_root /nfs/my_root 1669 * first. 1670 */ 1671asmlinkage long sys_pivot_root(const char __user * new_root, 1672 const char __user * put_old) 1673{ 1674 struct vfsmount *tmp; 1675 struct nameidata new_nd, old_nd, parent_nd, root_parent, user_nd; 1676 int error; 1677 1678 if (!capable(CAP_SYS_ADMIN)) 1679 return -EPERM; 1680 1681 lock_kernel(); 1682 1683 error = __user_walk(new_root, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, 1684 &new_nd); 1685 if (error) 1686 goto out0; 1687 error = -EINVAL; 1688 if (!check_mnt(new_nd.mnt)) 1689 goto out1; 1690 1691 error = __user_walk(put_old, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &old_nd); 1692 if (error) 1693 goto out1; 1694 1695 error = security_sb_pivotroot(&old_nd, &new_nd); 1696 if (error) { 1697 path_release(&old_nd); 1698 goto out1; 1699 } 1700 1701 read_lock(¤t->fs->lock); 1702 user_nd.mnt = mntget(current->fs->rootmnt); 1703 user_nd.dentry = dget(current->fs->root); 1704 read_unlock(¤t->fs->lock); 1705 down_write(&namespace_sem); 1706 mutex_lock(&old_nd.dentry->d_inode->i_mutex); 1707 error = -EINVAL; 1708 if (IS_MNT_SHARED(old_nd.mnt) || 1709 IS_MNT_SHARED(new_nd.mnt->mnt_parent) || 1710 IS_MNT_SHARED(user_nd.mnt->mnt_parent)) 1711 goto out2; 1712 if (!check_mnt(user_nd.mnt)) 1713 goto out2; 1714 error = -ENOENT; 1715 if (IS_DEADDIR(new_nd.dentry->d_inode)) 1716 goto out2; 1717 if (d_unhashed(new_nd.dentry) && !IS_ROOT(new_nd.dentry)) 1718 goto out2; 1719 if (d_unhashed(old_nd.dentry) && !IS_ROOT(old_nd.dentry)) 1720 goto out2; 1721 error = -EBUSY; 1722 if (new_nd.mnt == user_nd.mnt || old_nd.mnt == user_nd.mnt) 1723 goto out2; /* loop, on the same file system */ 1724 error = -EINVAL; 1725 if (user_nd.mnt->mnt_root != user_nd.dentry) 1726 goto out2; /* not a mountpoint */ 1727 if (user_nd.mnt->mnt_parent == user_nd.mnt) 1728 goto out2; /* not attached */ 1729 if (new_nd.mnt->mnt_root != new_nd.dentry) 1730 goto out2; /* not a mountpoint */ 1731 if (new_nd.mnt->mnt_parent == new_nd.mnt) 1732 goto out2; /* not attached */ 1733 tmp = old_nd.mnt; /* make sure we can reach put_old from new_root */ 1734 spin_lock(&vfsmount_lock); 1735 if (tmp != new_nd.mnt) { 1736 for (;;) { 1737 if (tmp->mnt_parent == tmp) 1738 goto out3; /* already mounted on put_old */ 1739 if (tmp->mnt_parent == new_nd.mnt) 1740 break; 1741 tmp = tmp->mnt_parent; 1742 } 1743 if (!is_subdir(tmp->mnt_mountpoint, new_nd.dentry)) 1744 goto out3; 1745 } else if (!is_subdir(old_nd.dentry, new_nd.dentry)) 1746 goto out3; 1747 detach_mnt(new_nd.mnt, &parent_nd); 1748 detach_mnt(user_nd.mnt, &root_parent); 1749 attach_mnt(user_nd.mnt, &old_nd); /* mount old root on put_old */ 1750 attach_mnt(new_nd.mnt, &root_parent); /* mount new_root on / */ 1751 touch_mnt_namespace(current->nsproxy->mnt_ns); 1752 spin_unlock(&vfsmount_lock); 1753 chroot_fs_refs(&user_nd, &new_nd); 1754 security_sb_post_pivotroot(&user_nd, &new_nd); 1755 error = 0; 1756 path_release(&root_parent); 1757 path_release(&parent_nd); 1758out2: 1759 mutex_unlock(&old_nd.dentry->d_inode->i_mutex); 1760 up_write(&namespace_sem); 1761 path_release(&user_nd); 1762 path_release(&old_nd); 1763out1: 1764 path_release(&new_nd); 1765out0: 1766 unlock_kernel(); 1767 return error; 1768out3: 1769 spin_unlock(&vfsmount_lock); 1770 goto out2; 1771} 1772 1773static void __init init_mount_tree(void) 1774{ 1775 struct vfsmount *mnt; 1776 struct mnt_namespace *ns; 1777 1778 mnt = do_kern_mount("rootfs", 0, "rootfs", NULL); 1779 if (IS_ERR(mnt)) 1780 panic("Can't create rootfs"); 1781 ns = kmalloc(sizeof(*ns), GFP_KERNEL); 1782 if (!ns) 1783 panic("Can't allocate initial namespace"); 1784 atomic_set(&ns->count, 1); 1785 INIT_LIST_HEAD(&ns->list); 1786 init_waitqueue_head(&ns->poll); 1787 ns->event = 0; 1788 list_add(&mnt->mnt_list, &ns->list); 1789 ns->root = mnt; 1790 mnt->mnt_ns = ns; 1791 1792 init_task.nsproxy->mnt_ns = ns; 1793 get_mnt_ns(ns); 1794 1795 set_fs_pwd(current->fs, ns->root, ns->root->mnt_root); 1796 set_fs_root(current->fs, ns->root, ns->root->mnt_root); 1797} 1798 1799void __init mnt_init(unsigned long mempages) 1800{ 1801 struct list_head *d; 1802 unsigned int nr_hash; 1803 int i; 1804 int err; 1805 1806 init_rwsem(&namespace_sem); 1807 1808 mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct vfsmount), 1809 0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL, NULL); 1810 1811 mount_hashtable = (struct list_head *)__get_free_page(GFP_ATOMIC); 1812 1813 if (!mount_hashtable) 1814 panic("Failed to allocate mount hash table\n"); 1815 1816 /* 1817 * Find the power-of-two list-heads that can fit into the allocation.. 1818 * We don't guarantee that "sizeof(struct list_head)" is necessarily 1819 * a power-of-two. 1820 */ 1821 nr_hash = PAGE_SIZE / sizeof(struct list_head); 1822 hash_bits = 0; 1823 do { 1824 hash_bits++; 1825 } while ((nr_hash >> hash_bits) != 0); 1826 hash_bits--; 1827 1828 /* 1829 * Re-calculate the actual number of entries and the mask 1830 * from the number of bits we can fit. 1831 */ 1832 nr_hash = 1UL << hash_bits; 1833 hash_mask = nr_hash - 1; 1834 1835 printk("Mount-cache hash table entries: %d\n", nr_hash); 1836 1837 /* And initialize the newly allocated array */ 1838 d = mount_hashtable; 1839 i = nr_hash; 1840 do { 1841 INIT_LIST_HEAD(d); 1842 d++; 1843 i--; 1844 } while (i); 1845 err = sysfs_init(); 1846 if (err) 1847 printk(KERN_WARNING "%s: sysfs_init error: %d\n", 1848 __FUNCTION__, err); 1849 err = subsystem_register(&fs_subsys); 1850 if (err) 1851 printk(KERN_WARNING "%s: subsystem_register error: %d\n", 1852 __FUNCTION__, err); 1853 init_rootfs(); 1854 init_mount_tree(); 1855} 1856 1857void __put_mnt_ns(struct mnt_namespace *ns) 1858{ 1859 struct vfsmount *root = ns->root; 1860 LIST_HEAD(umount_list); 1861 ns->root = NULL; 1862 spin_unlock(&vfsmount_lock); 1863 down_write(&namespace_sem); 1864 spin_lock(&vfsmount_lock); 1865 umount_tree(root, 0, &umount_list); 1866 spin_unlock(&vfsmount_lock); 1867 up_write(&namespace_sem); 1868 release_mounts(&umount_list); 1869 kfree(ns); 1870} 1871