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