1 /* 2 * linux/fs/super.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * 6 * super.c contains code to handle: - mount structures 7 * - super-block tables 8 * - filesystem drivers list 9 * - mount system call 10 * - umount system call 11 * - ustat system call 12 * 13 * GK 2/5/95 - Changed to support mounting the root fs via NFS 14 * 15 * Added kerneld support: Jacques Gelinas and Bjorn Ekwall 16 * Added change_root: Werner Almesberger & Hans Lermen, Feb '96 17 * Added options to /proc/mounts: 18 * Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996. 19 * Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998 20 * Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000 21 */ 22 23 #include <linux/module.h> 24 #include <linux/slab.h> 25 #include <linux/init.h> 26 #include <linux/smp_lock.h> 27 #include <linux/acct.h> 28 #include <linux/blkdev.h> 29 #include <linux/quotaops.h> 30 #include <linux/namei.h> 31 #include <linux/mount.h> 32 #include <linux/security.h> 33 #include <linux/syscalls.h> 34 #include <linux/vfs.h> 35 #include <linux/writeback.h> /* for the emergency remount stuff */ 36 #include <linux/idr.h> 37 #include <linux/kobject.h> 38 #include <linux/mutex.h> 39 #include <linux/file.h> 40 #include <asm/uaccess.h> 41 #include "internal.h" 42 43 44 LIST_HEAD(super_blocks); 45 DEFINE_SPINLOCK(sb_lock); 46 47 /** 48 * alloc_super - create new superblock 49 * @type: filesystem type superblock should belong to 50 * 51 * Allocates and initializes a new &struct super_block. alloc_super() 52 * returns a pointer new superblock or %NULL if allocation had failed. 53 */ 54 static struct super_block *alloc_super(struct file_system_type *type) 55 { 56 struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER); 57 static const struct super_operations default_op; 58 59 if (s) { 60 if (security_sb_alloc(s)) { 61 kfree(s); 62 s = NULL; 63 goto out; 64 } 65 INIT_LIST_HEAD(&s->s_files); 66 INIT_LIST_HEAD(&s->s_instances); 67 INIT_HLIST_HEAD(&s->s_anon); 68 INIT_LIST_HEAD(&s->s_inodes); 69 INIT_LIST_HEAD(&s->s_dentry_lru); 70 init_rwsem(&s->s_umount); 71 mutex_init(&s->s_lock); 72 lockdep_set_class(&s->s_umount, &type->s_umount_key); 73 /* 74 * The locking rules for s_lock are up to the 75 * filesystem. For example ext3fs has different 76 * lock ordering than usbfs: 77 */ 78 lockdep_set_class(&s->s_lock, &type->s_lock_key); 79 /* 80 * sget() can have s_umount recursion. 81 * 82 * When it cannot find a suitable sb, it allocates a new 83 * one (this one), and tries again to find a suitable old 84 * one. 85 * 86 * In case that succeeds, it will acquire the s_umount 87 * lock of the old one. Since these are clearly distrinct 88 * locks, and this object isn't exposed yet, there's no 89 * risk of deadlocks. 90 * 91 * Annotate this by putting this lock in a different 92 * subclass. 93 */ 94 down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING); 95 s->s_count = S_BIAS; 96 atomic_set(&s->s_active, 1); 97 mutex_init(&s->s_vfs_rename_mutex); 98 mutex_init(&s->s_dquot.dqio_mutex); 99 mutex_init(&s->s_dquot.dqonoff_mutex); 100 init_rwsem(&s->s_dquot.dqptr_sem); 101 init_waitqueue_head(&s->s_wait_unfrozen); 102 s->s_maxbytes = MAX_NON_LFS; 103 s->dq_op = sb_dquot_ops; 104 s->s_qcop = sb_quotactl_ops; 105 s->s_op = &default_op; 106 s->s_time_gran = 1000000000; 107 } 108 out: 109 return s; 110 } 111 112 /** 113 * destroy_super - frees a superblock 114 * @s: superblock to free 115 * 116 * Frees a superblock. 117 */ 118 static inline void destroy_super(struct super_block *s) 119 { 120 security_sb_free(s); 121 kfree(s->s_subtype); 122 kfree(s->s_options); 123 kfree(s); 124 } 125 126 /* Superblock refcounting */ 127 128 /* 129 * Drop a superblock's refcount. Returns non-zero if the superblock was 130 * destroyed. The caller must hold sb_lock. 131 */ 132 static int __put_super(struct super_block *sb) 133 { 134 int ret = 0; 135 136 if (!--sb->s_count) { 137 destroy_super(sb); 138 ret = 1; 139 } 140 return ret; 141 } 142 143 /* 144 * Drop a superblock's refcount. 145 * Returns non-zero if the superblock is about to be destroyed and 146 * at least is already removed from super_blocks list, so if we are 147 * making a loop through super blocks then we need to restart. 148 * The caller must hold sb_lock. 149 */ 150 int __put_super_and_need_restart(struct super_block *sb) 151 { 152 /* check for race with generic_shutdown_super() */ 153 if (list_empty(&sb->s_list)) { 154 /* super block is removed, need to restart... */ 155 __put_super(sb); 156 return 1; 157 } 158 /* can't be the last, since s_list is still in use */ 159 sb->s_count--; 160 BUG_ON(sb->s_count == 0); 161 return 0; 162 } 163 164 /** 165 * put_super - drop a temporary reference to superblock 166 * @sb: superblock in question 167 * 168 * Drops a temporary reference, frees superblock if there's no 169 * references left. 170 */ 171 void put_super(struct super_block *sb) 172 { 173 spin_lock(&sb_lock); 174 __put_super(sb); 175 spin_unlock(&sb_lock); 176 } 177 178 179 /** 180 * deactivate_super - drop an active reference to superblock 181 * @s: superblock to deactivate 182 * 183 * Drops an active reference to superblock, acquiring a temprory one if 184 * there is no active references left. In that case we lock superblock, 185 * tell fs driver to shut it down and drop the temporary reference we 186 * had just acquired. 187 */ 188 void deactivate_super(struct super_block *s) 189 { 190 struct file_system_type *fs = s->s_type; 191 if (atomic_dec_and_lock(&s->s_active, &sb_lock)) { 192 s->s_count -= S_BIAS-1; 193 spin_unlock(&sb_lock); 194 vfs_dq_off(s, 0); 195 down_write(&s->s_umount); 196 fs->kill_sb(s); 197 put_filesystem(fs); 198 put_super(s); 199 } 200 } 201 202 EXPORT_SYMBOL(deactivate_super); 203 204 /** 205 * deactivate_locked_super - drop an active reference to superblock 206 * @s: superblock to deactivate 207 * 208 * Equivalent of up_write(&s->s_umount); deactivate_super(s);, except that 209 * it does not unlock it until it's all over. As the result, it's safe to 210 * use to dispose of new superblock on ->get_sb() failure exits - nobody 211 * will see the sucker until it's all over. Equivalent using up_write + 212 * deactivate_super is safe for that purpose only if superblock is either 213 * safe to use or has NULL ->s_root when we unlock. 214 */ 215 void deactivate_locked_super(struct super_block *s) 216 { 217 struct file_system_type *fs = s->s_type; 218 if (atomic_dec_and_lock(&s->s_active, &sb_lock)) { 219 s->s_count -= S_BIAS-1; 220 spin_unlock(&sb_lock); 221 vfs_dq_off(s, 0); 222 fs->kill_sb(s); 223 put_filesystem(fs); 224 put_super(s); 225 } else { 226 up_write(&s->s_umount); 227 } 228 } 229 230 EXPORT_SYMBOL(deactivate_locked_super); 231 232 /** 233 * grab_super - acquire an active reference 234 * @s: reference we are trying to make active 235 * 236 * Tries to acquire an active reference. grab_super() is used when we 237 * had just found a superblock in super_blocks or fs_type->fs_supers 238 * and want to turn it into a full-blown active reference. grab_super() 239 * is called with sb_lock held and drops it. Returns 1 in case of 240 * success, 0 if we had failed (superblock contents was already dead or 241 * dying when grab_super() had been called). 242 */ 243 static int grab_super(struct super_block *s) __releases(sb_lock) 244 { 245 s->s_count++; 246 spin_unlock(&sb_lock); 247 down_write(&s->s_umount); 248 if (s->s_root) { 249 spin_lock(&sb_lock); 250 if (s->s_count > S_BIAS) { 251 atomic_inc(&s->s_active); 252 s->s_count--; 253 spin_unlock(&sb_lock); 254 return 1; 255 } 256 spin_unlock(&sb_lock); 257 } 258 up_write(&s->s_umount); 259 put_super(s); 260 yield(); 261 return 0; 262 } 263 264 /* 265 * Superblock locking. We really ought to get rid of these two. 266 */ 267 void lock_super(struct super_block * sb) 268 { 269 get_fs_excl(); 270 mutex_lock(&sb->s_lock); 271 } 272 273 void unlock_super(struct super_block * sb) 274 { 275 put_fs_excl(); 276 mutex_unlock(&sb->s_lock); 277 } 278 279 EXPORT_SYMBOL(lock_super); 280 EXPORT_SYMBOL(unlock_super); 281 282 /** 283 * generic_shutdown_super - common helper for ->kill_sb() 284 * @sb: superblock to kill 285 * 286 * generic_shutdown_super() does all fs-independent work on superblock 287 * shutdown. Typical ->kill_sb() should pick all fs-specific objects 288 * that need destruction out of superblock, call generic_shutdown_super() 289 * and release aforementioned objects. Note: dentries and inodes _are_ 290 * taken care of and do not need specific handling. 291 * 292 * Upon calling this function, the filesystem may no longer alter or 293 * rearrange the set of dentries belonging to this super_block, nor may it 294 * change the attachments of dentries to inodes. 295 */ 296 void generic_shutdown_super(struct super_block *sb) 297 { 298 const struct super_operations *sop = sb->s_op; 299 300 301 if (sb->s_root) { 302 shrink_dcache_for_umount(sb); 303 sync_filesystem(sb); 304 get_fs_excl(); 305 sb->s_flags &= ~MS_ACTIVE; 306 307 /* bad name - it should be evict_inodes() */ 308 invalidate_inodes(sb); 309 310 if (sop->put_super) 311 sop->put_super(sb); 312 313 /* Forget any remaining inodes */ 314 if (invalidate_inodes(sb)) { 315 printk("VFS: Busy inodes after unmount of %s. " 316 "Self-destruct in 5 seconds. Have a nice day...\n", 317 sb->s_id); 318 } 319 put_fs_excl(); 320 } 321 spin_lock(&sb_lock); 322 /* should be initialized for __put_super_and_need_restart() */ 323 list_del_init(&sb->s_list); 324 list_del(&sb->s_instances); 325 spin_unlock(&sb_lock); 326 up_write(&sb->s_umount); 327 } 328 329 EXPORT_SYMBOL(generic_shutdown_super); 330 331 /** 332 * sget - find or create a superblock 333 * @type: filesystem type superblock should belong to 334 * @test: comparison callback 335 * @set: setup callback 336 * @data: argument to each of them 337 */ 338 struct super_block *sget(struct file_system_type *type, 339 int (*test)(struct super_block *,void *), 340 int (*set)(struct super_block *,void *), 341 void *data) 342 { 343 struct super_block *s = NULL; 344 struct super_block *old; 345 int err; 346 347 retry: 348 spin_lock(&sb_lock); 349 if (test) { 350 list_for_each_entry(old, &type->fs_supers, s_instances) { 351 if (!test(old, data)) 352 continue; 353 if (!grab_super(old)) 354 goto retry; 355 if (s) { 356 up_write(&s->s_umount); 357 destroy_super(s); 358 } 359 return old; 360 } 361 } 362 if (!s) { 363 spin_unlock(&sb_lock); 364 s = alloc_super(type); 365 if (!s) 366 return ERR_PTR(-ENOMEM); 367 goto retry; 368 } 369 370 err = set(s, data); 371 if (err) { 372 spin_unlock(&sb_lock); 373 up_write(&s->s_umount); 374 destroy_super(s); 375 return ERR_PTR(err); 376 } 377 s->s_type = type; 378 strlcpy(s->s_id, type->name, sizeof(s->s_id)); 379 list_add_tail(&s->s_list, &super_blocks); 380 list_add(&s->s_instances, &type->fs_supers); 381 spin_unlock(&sb_lock); 382 get_filesystem(type); 383 return s; 384 } 385 386 EXPORT_SYMBOL(sget); 387 388 void drop_super(struct super_block *sb) 389 { 390 up_read(&sb->s_umount); 391 put_super(sb); 392 } 393 394 EXPORT_SYMBOL(drop_super); 395 396 /** 397 * sync_supers - helper for periodic superblock writeback 398 * 399 * Call the write_super method if present on all dirty superblocks in 400 * the system. This is for the periodic writeback used by most older 401 * filesystems. For data integrity superblock writeback use 402 * sync_filesystems() instead. 403 * 404 * Note: check the dirty flag before waiting, so we don't 405 * hold up the sync while mounting a device. (The newly 406 * mounted device won't need syncing.) 407 */ 408 void sync_supers(void) 409 { 410 struct super_block *sb; 411 412 spin_lock(&sb_lock); 413 restart: 414 list_for_each_entry(sb, &super_blocks, s_list) { 415 if (sb->s_op->write_super && sb->s_dirt) { 416 sb->s_count++; 417 spin_unlock(&sb_lock); 418 419 down_read(&sb->s_umount); 420 if (sb->s_root && sb->s_dirt) 421 sb->s_op->write_super(sb); 422 up_read(&sb->s_umount); 423 424 spin_lock(&sb_lock); 425 if (__put_super_and_need_restart(sb)) 426 goto restart; 427 } 428 } 429 spin_unlock(&sb_lock); 430 } 431 432 /** 433 * get_super - get the superblock of a device 434 * @bdev: device to get the superblock for 435 * 436 * Scans the superblock list and finds the superblock of the file system 437 * mounted on the device given. %NULL is returned if no match is found. 438 */ 439 440 struct super_block * get_super(struct block_device *bdev) 441 { 442 struct super_block *sb; 443 444 if (!bdev) 445 return NULL; 446 447 spin_lock(&sb_lock); 448 rescan: 449 list_for_each_entry(sb, &super_blocks, s_list) { 450 if (sb->s_bdev == bdev) { 451 sb->s_count++; 452 spin_unlock(&sb_lock); 453 down_read(&sb->s_umount); 454 if (sb->s_root) 455 return sb; 456 up_read(&sb->s_umount); 457 /* restart only when sb is no longer on the list */ 458 spin_lock(&sb_lock); 459 if (__put_super_and_need_restart(sb)) 460 goto rescan; 461 } 462 } 463 spin_unlock(&sb_lock); 464 return NULL; 465 } 466 467 EXPORT_SYMBOL(get_super); 468 469 /** 470 * get_active_super - get an active reference to the superblock of a device 471 * @bdev: device to get the superblock for 472 * 473 * Scans the superblock list and finds the superblock of the file system 474 * mounted on the device given. Returns the superblock with an active 475 * reference and s_umount held exclusively or %NULL if none was found. 476 */ 477 struct super_block *get_active_super(struct block_device *bdev) 478 { 479 struct super_block *sb; 480 481 if (!bdev) 482 return NULL; 483 484 spin_lock(&sb_lock); 485 list_for_each_entry(sb, &super_blocks, s_list) { 486 if (sb->s_bdev != bdev) 487 continue; 488 489 sb->s_count++; 490 spin_unlock(&sb_lock); 491 down_write(&sb->s_umount); 492 if (sb->s_root) { 493 spin_lock(&sb_lock); 494 if (sb->s_count > S_BIAS) { 495 atomic_inc(&sb->s_active); 496 sb->s_count--; 497 spin_unlock(&sb_lock); 498 return sb; 499 } 500 spin_unlock(&sb_lock); 501 } 502 up_write(&sb->s_umount); 503 put_super(sb); 504 yield(); 505 spin_lock(&sb_lock); 506 } 507 spin_unlock(&sb_lock); 508 return NULL; 509 } 510 511 struct super_block * user_get_super(dev_t dev) 512 { 513 struct super_block *sb; 514 515 spin_lock(&sb_lock); 516 rescan: 517 list_for_each_entry(sb, &super_blocks, s_list) { 518 if (sb->s_dev == dev) { 519 sb->s_count++; 520 spin_unlock(&sb_lock); 521 down_read(&sb->s_umount); 522 if (sb->s_root) 523 return sb; 524 up_read(&sb->s_umount); 525 /* restart only when sb is no longer on the list */ 526 spin_lock(&sb_lock); 527 if (__put_super_and_need_restart(sb)) 528 goto rescan; 529 } 530 } 531 spin_unlock(&sb_lock); 532 return NULL; 533 } 534 535 SYSCALL_DEFINE2(ustat, unsigned, dev, struct ustat __user *, ubuf) 536 { 537 struct super_block *s; 538 struct ustat tmp; 539 struct kstatfs sbuf; 540 int err = -EINVAL; 541 542 s = user_get_super(new_decode_dev(dev)); 543 if (s == NULL) 544 goto out; 545 err = vfs_statfs(s->s_root, &sbuf); 546 drop_super(s); 547 if (err) 548 goto out; 549 550 memset(&tmp,0,sizeof(struct ustat)); 551 tmp.f_tfree = sbuf.f_bfree; 552 tmp.f_tinode = sbuf.f_ffree; 553 554 err = copy_to_user(ubuf,&tmp,sizeof(struct ustat)) ? -EFAULT : 0; 555 out: 556 return err; 557 } 558 559 /** 560 * do_remount_sb - asks filesystem to change mount options. 561 * @sb: superblock in question 562 * @flags: numeric part of options 563 * @data: the rest of options 564 * @force: whether or not to force the change 565 * 566 * Alters the mount options of a mounted file system. 567 */ 568 int do_remount_sb(struct super_block *sb, int flags, void *data, int force) 569 { 570 int retval; 571 int remount_rw; 572 573 if (sb->s_frozen != SB_UNFROZEN) 574 return -EBUSY; 575 576 #ifdef CONFIG_BLOCK 577 if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev)) 578 return -EACCES; 579 #endif 580 581 if (flags & MS_RDONLY) 582 acct_auto_close(sb); 583 shrink_dcache_sb(sb); 584 sync_filesystem(sb); 585 586 /* If we are remounting RDONLY and current sb is read/write, 587 make sure there are no rw files opened */ 588 if ((flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY)) { 589 if (force) 590 mark_files_ro(sb); 591 else if (!fs_may_remount_ro(sb)) 592 return -EBUSY; 593 retval = vfs_dq_off(sb, 1); 594 if (retval < 0 && retval != -ENOSYS) 595 return -EBUSY; 596 } 597 remount_rw = !(flags & MS_RDONLY) && (sb->s_flags & MS_RDONLY); 598 599 if (sb->s_op->remount_fs) { 600 retval = sb->s_op->remount_fs(sb, &flags, data); 601 if (retval) 602 return retval; 603 } 604 sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK); 605 if (remount_rw) 606 vfs_dq_quota_on_remount(sb); 607 return 0; 608 } 609 610 static void do_emergency_remount(struct work_struct *work) 611 { 612 struct super_block *sb; 613 614 spin_lock(&sb_lock); 615 list_for_each_entry(sb, &super_blocks, s_list) { 616 sb->s_count++; 617 spin_unlock(&sb_lock); 618 down_write(&sb->s_umount); 619 if (sb->s_root && sb->s_bdev && !(sb->s_flags & MS_RDONLY)) { 620 /* 621 * ->remount_fs needs lock_kernel(). 622 * 623 * What lock protects sb->s_flags?? 624 */ 625 do_remount_sb(sb, MS_RDONLY, NULL, 1); 626 } 627 up_write(&sb->s_umount); 628 put_super(sb); 629 spin_lock(&sb_lock); 630 } 631 spin_unlock(&sb_lock); 632 kfree(work); 633 printk("Emergency Remount complete\n"); 634 } 635 636 void emergency_remount(void) 637 { 638 struct work_struct *work; 639 640 work = kmalloc(sizeof(*work), GFP_ATOMIC); 641 if (work) { 642 INIT_WORK(work, do_emergency_remount); 643 schedule_work(work); 644 } 645 } 646 647 /* 648 * Unnamed block devices are dummy devices used by virtual 649 * filesystems which don't use real block-devices. -- jrs 650 */ 651 652 static DEFINE_IDA(unnamed_dev_ida); 653 static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */ 654 static int unnamed_dev_start = 0; /* don't bother trying below it */ 655 656 int set_anon_super(struct super_block *s, void *data) 657 { 658 int dev; 659 int error; 660 661 retry: 662 if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0) 663 return -ENOMEM; 664 spin_lock(&unnamed_dev_lock); 665 error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev); 666 if (!error) 667 unnamed_dev_start = dev + 1; 668 spin_unlock(&unnamed_dev_lock); 669 if (error == -EAGAIN) 670 /* We raced and lost with another CPU. */ 671 goto retry; 672 else if (error) 673 return -EAGAIN; 674 675 if ((dev & MAX_ID_MASK) == (1 << MINORBITS)) { 676 spin_lock(&unnamed_dev_lock); 677 ida_remove(&unnamed_dev_ida, dev); 678 if (unnamed_dev_start > dev) 679 unnamed_dev_start = dev; 680 spin_unlock(&unnamed_dev_lock); 681 return -EMFILE; 682 } 683 s->s_dev = MKDEV(0, dev & MINORMASK); 684 return 0; 685 } 686 687 EXPORT_SYMBOL(set_anon_super); 688 689 void kill_anon_super(struct super_block *sb) 690 { 691 int slot = MINOR(sb->s_dev); 692 693 generic_shutdown_super(sb); 694 spin_lock(&unnamed_dev_lock); 695 ida_remove(&unnamed_dev_ida, slot); 696 if (slot < unnamed_dev_start) 697 unnamed_dev_start = slot; 698 spin_unlock(&unnamed_dev_lock); 699 } 700 701 EXPORT_SYMBOL(kill_anon_super); 702 703 void kill_litter_super(struct super_block *sb) 704 { 705 if (sb->s_root) 706 d_genocide(sb->s_root); 707 kill_anon_super(sb); 708 } 709 710 EXPORT_SYMBOL(kill_litter_super); 711 712 static int ns_test_super(struct super_block *sb, void *data) 713 { 714 return sb->s_fs_info == data; 715 } 716 717 static int ns_set_super(struct super_block *sb, void *data) 718 { 719 sb->s_fs_info = data; 720 return set_anon_super(sb, NULL); 721 } 722 723 int get_sb_ns(struct file_system_type *fs_type, int flags, void *data, 724 int (*fill_super)(struct super_block *, void *, int), 725 struct vfsmount *mnt) 726 { 727 struct super_block *sb; 728 729 sb = sget(fs_type, ns_test_super, ns_set_super, data); 730 if (IS_ERR(sb)) 731 return PTR_ERR(sb); 732 733 if (!sb->s_root) { 734 int err; 735 sb->s_flags = flags; 736 err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0); 737 if (err) { 738 deactivate_locked_super(sb); 739 return err; 740 } 741 742 sb->s_flags |= MS_ACTIVE; 743 } 744 745 simple_set_mnt(mnt, sb); 746 return 0; 747 } 748 749 EXPORT_SYMBOL(get_sb_ns); 750 751 #ifdef CONFIG_BLOCK 752 static int set_bdev_super(struct super_block *s, void *data) 753 { 754 s->s_bdev = data; 755 s->s_dev = s->s_bdev->bd_dev; 756 757 /* 758 * We set the bdi here to the queue backing, file systems can 759 * overwrite this in ->fill_super() 760 */ 761 s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info; 762 return 0; 763 } 764 765 static int test_bdev_super(struct super_block *s, void *data) 766 { 767 return (void *)s->s_bdev == data; 768 } 769 770 int get_sb_bdev(struct file_system_type *fs_type, 771 int flags, const char *dev_name, void *data, 772 int (*fill_super)(struct super_block *, void *, int), 773 struct vfsmount *mnt) 774 { 775 struct block_device *bdev; 776 struct super_block *s; 777 fmode_t mode = FMODE_READ; 778 int error = 0; 779 780 if (!(flags & MS_RDONLY)) 781 mode |= FMODE_WRITE; 782 783 bdev = open_bdev_exclusive(dev_name, mode, fs_type); 784 if (IS_ERR(bdev)) 785 return PTR_ERR(bdev); 786 787 /* 788 * once the super is inserted into the list by sget, s_umount 789 * will protect the lockfs code from trying to start a snapshot 790 * while we are mounting 791 */ 792 mutex_lock(&bdev->bd_fsfreeze_mutex); 793 if (bdev->bd_fsfreeze_count > 0) { 794 mutex_unlock(&bdev->bd_fsfreeze_mutex); 795 error = -EBUSY; 796 goto error_bdev; 797 } 798 s = sget(fs_type, test_bdev_super, set_bdev_super, bdev); 799 mutex_unlock(&bdev->bd_fsfreeze_mutex); 800 if (IS_ERR(s)) 801 goto error_s; 802 803 if (s->s_root) { 804 if ((flags ^ s->s_flags) & MS_RDONLY) { 805 deactivate_locked_super(s); 806 error = -EBUSY; 807 goto error_bdev; 808 } 809 810 close_bdev_exclusive(bdev, mode); 811 } else { 812 char b[BDEVNAME_SIZE]; 813 814 s->s_flags = flags; 815 s->s_mode = mode; 816 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id)); 817 sb_set_blocksize(s, block_size(bdev)); 818 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0); 819 if (error) { 820 deactivate_locked_super(s); 821 goto error; 822 } 823 824 s->s_flags |= MS_ACTIVE; 825 bdev->bd_super = s; 826 } 827 828 simple_set_mnt(mnt, s); 829 return 0; 830 831 error_s: 832 error = PTR_ERR(s); 833 error_bdev: 834 close_bdev_exclusive(bdev, mode); 835 error: 836 return error; 837 } 838 839 EXPORT_SYMBOL(get_sb_bdev); 840 841 void kill_block_super(struct super_block *sb) 842 { 843 struct block_device *bdev = sb->s_bdev; 844 fmode_t mode = sb->s_mode; 845 846 bdev->bd_super = NULL; 847 generic_shutdown_super(sb); 848 sync_blockdev(bdev); 849 close_bdev_exclusive(bdev, mode); 850 } 851 852 EXPORT_SYMBOL(kill_block_super); 853 #endif 854 855 int get_sb_nodev(struct file_system_type *fs_type, 856 int flags, void *data, 857 int (*fill_super)(struct super_block *, void *, int), 858 struct vfsmount *mnt) 859 { 860 int error; 861 struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL); 862 863 if (IS_ERR(s)) 864 return PTR_ERR(s); 865 866 s->s_flags = flags; 867 868 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0); 869 if (error) { 870 deactivate_locked_super(s); 871 return error; 872 } 873 s->s_flags |= MS_ACTIVE; 874 simple_set_mnt(mnt, s); 875 return 0; 876 } 877 878 EXPORT_SYMBOL(get_sb_nodev); 879 880 static int compare_single(struct super_block *s, void *p) 881 { 882 return 1; 883 } 884 885 int get_sb_single(struct file_system_type *fs_type, 886 int flags, void *data, 887 int (*fill_super)(struct super_block *, void *, int), 888 struct vfsmount *mnt) 889 { 890 struct super_block *s; 891 int error; 892 893 s = sget(fs_type, compare_single, set_anon_super, NULL); 894 if (IS_ERR(s)) 895 return PTR_ERR(s); 896 if (!s->s_root) { 897 s->s_flags = flags; 898 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0); 899 if (error) { 900 deactivate_locked_super(s); 901 return error; 902 } 903 s->s_flags |= MS_ACTIVE; 904 } else { 905 do_remount_sb(s, flags, data, 0); 906 } 907 simple_set_mnt(mnt, s); 908 return 0; 909 } 910 911 EXPORT_SYMBOL(get_sb_single); 912 913 struct vfsmount * 914 vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data) 915 { 916 struct vfsmount *mnt; 917 char *secdata = NULL; 918 int error; 919 920 if (!type) 921 return ERR_PTR(-ENODEV); 922 923 error = -ENOMEM; 924 mnt = alloc_vfsmnt(name); 925 if (!mnt) 926 goto out; 927 928 if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) { 929 secdata = alloc_secdata(); 930 if (!secdata) 931 goto out_mnt; 932 933 error = security_sb_copy_data(data, secdata); 934 if (error) 935 goto out_free_secdata; 936 } 937 938 error = type->get_sb(type, flags, name, data, mnt); 939 if (error < 0) 940 goto out_free_secdata; 941 BUG_ON(!mnt->mnt_sb); 942 943 error = security_sb_kern_mount(mnt->mnt_sb, flags, secdata); 944 if (error) 945 goto out_sb; 946 947 /* 948 * filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE 949 * but s_maxbytes was an unsigned long long for many releases. Throw 950 * this warning for a little while to try and catch filesystems that 951 * violate this rule. This warning should be either removed or 952 * converted to a BUG() in 2.6.34. 953 */ 954 WARN((mnt->mnt_sb->s_maxbytes < 0), "%s set sb->s_maxbytes to " 955 "negative value (%lld)\n", type->name, mnt->mnt_sb->s_maxbytes); 956 957 mnt->mnt_mountpoint = mnt->mnt_root; 958 mnt->mnt_parent = mnt; 959 up_write(&mnt->mnt_sb->s_umount); 960 free_secdata(secdata); 961 return mnt; 962 out_sb: 963 dput(mnt->mnt_root); 964 deactivate_locked_super(mnt->mnt_sb); 965 out_free_secdata: 966 free_secdata(secdata); 967 out_mnt: 968 free_vfsmnt(mnt); 969 out: 970 return ERR_PTR(error); 971 } 972 973 EXPORT_SYMBOL_GPL(vfs_kern_mount); 974 975 static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype) 976 { 977 int err; 978 const char *subtype = strchr(fstype, '.'); 979 if (subtype) { 980 subtype++; 981 err = -EINVAL; 982 if (!subtype[0]) 983 goto err; 984 } else 985 subtype = ""; 986 987 mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL); 988 err = -ENOMEM; 989 if (!mnt->mnt_sb->s_subtype) 990 goto err; 991 return mnt; 992 993 err: 994 mntput(mnt); 995 return ERR_PTR(err); 996 } 997 998 struct vfsmount * 999 do_kern_mount(const char *fstype, int flags, const char *name, void *data) 1000 { 1001 struct file_system_type *type = get_fs_type(fstype); 1002 struct vfsmount *mnt; 1003 if (!type) 1004 return ERR_PTR(-ENODEV); 1005 mnt = vfs_kern_mount(type, flags, name, data); 1006 if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) && 1007 !mnt->mnt_sb->s_subtype) 1008 mnt = fs_set_subtype(mnt, fstype); 1009 put_filesystem(type); 1010 return mnt; 1011 } 1012 EXPORT_SYMBOL_GPL(do_kern_mount); 1013 1014 struct vfsmount *kern_mount_data(struct file_system_type *type, void *data) 1015 { 1016 return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data); 1017 } 1018 1019 EXPORT_SYMBOL_GPL(kern_mount_data); 1020