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/export.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 <linux/rculist_bl.h> 34 #include <linux/cleancache.h> 35 #include <linux/fsnotify.h> 36 #include <linux/lockdep.h> 37 #include "internal.h" 38 39 40 LIST_HEAD(super_blocks); 41 DEFINE_SPINLOCK(sb_lock); 42 43 static char *sb_writers_name[SB_FREEZE_LEVELS] = { 44 "sb_writers", 45 "sb_pagefaults", 46 "sb_internal", 47 }; 48 49 /* 50 * One thing we have to be careful of with a per-sb shrinker is that we don't 51 * drop the last active reference to the superblock from within the shrinker. 52 * If that happens we could trigger unregistering the shrinker from within the 53 * shrinker path and that leads to deadlock on the shrinker_rwsem. Hence we 54 * take a passive reference to the superblock to avoid this from occurring. 55 */ 56 static unsigned long super_cache_scan(struct shrinker *shrink, 57 struct shrink_control *sc) 58 { 59 struct super_block *sb; 60 long fs_objects = 0; 61 long total_objects; 62 long freed = 0; 63 long dentries; 64 long inodes; 65 66 sb = container_of(shrink, struct super_block, s_shrink); 67 68 /* 69 * Deadlock avoidance. We may hold various FS locks, and we don't want 70 * to recurse into the FS that called us in clear_inode() and friends.. 71 */ 72 if (!(sc->gfp_mask & __GFP_FS)) 73 return SHRINK_STOP; 74 75 if (!grab_super_passive(sb)) 76 return SHRINK_STOP; 77 78 if (sb->s_op->nr_cached_objects) 79 fs_objects = sb->s_op->nr_cached_objects(sb, sc->nid); 80 81 inodes = list_lru_count_node(&sb->s_inode_lru, sc->nid); 82 dentries = list_lru_count_node(&sb->s_dentry_lru, sc->nid); 83 total_objects = dentries + inodes + fs_objects + 1; 84 85 /* proportion the scan between the caches */ 86 dentries = mult_frac(sc->nr_to_scan, dentries, total_objects); 87 inodes = mult_frac(sc->nr_to_scan, inodes, total_objects); 88 89 /* 90 * prune the dcache first as the icache is pinned by it, then 91 * prune the icache, followed by the filesystem specific caches 92 */ 93 freed = prune_dcache_sb(sb, dentries, sc->nid); 94 freed += prune_icache_sb(sb, inodes, sc->nid); 95 96 if (fs_objects) { 97 fs_objects = mult_frac(sc->nr_to_scan, fs_objects, 98 total_objects); 99 freed += sb->s_op->free_cached_objects(sb, fs_objects, 100 sc->nid); 101 } 102 103 drop_super(sb); 104 return freed; 105 } 106 107 static unsigned long super_cache_count(struct shrinker *shrink, 108 struct shrink_control *sc) 109 { 110 struct super_block *sb; 111 long total_objects = 0; 112 113 sb = container_of(shrink, struct super_block, s_shrink); 114 115 if (!grab_super_passive(sb)) 116 return 0; 117 118 if (sb->s_op && sb->s_op->nr_cached_objects) 119 total_objects = sb->s_op->nr_cached_objects(sb, 120 sc->nid); 121 122 total_objects += list_lru_count_node(&sb->s_dentry_lru, 123 sc->nid); 124 total_objects += list_lru_count_node(&sb->s_inode_lru, 125 sc->nid); 126 127 total_objects = vfs_pressure_ratio(total_objects); 128 drop_super(sb); 129 return total_objects; 130 } 131 132 /** 133 * destroy_super - frees a superblock 134 * @s: superblock to free 135 * 136 * Frees a superblock. 137 */ 138 static void destroy_super(struct super_block *s) 139 { 140 int i; 141 list_lru_destroy(&s->s_dentry_lru); 142 list_lru_destroy(&s->s_inode_lru); 143 for (i = 0; i < SB_FREEZE_LEVELS; i++) 144 percpu_counter_destroy(&s->s_writers.counter[i]); 145 security_sb_free(s); 146 WARN_ON(!list_empty(&s->s_mounts)); 147 kfree(s->s_subtype); 148 kfree(s->s_options); 149 kfree_rcu(s, rcu); 150 } 151 152 /** 153 * alloc_super - create new superblock 154 * @type: filesystem type superblock should belong to 155 * @flags: the mount flags 156 * 157 * Allocates and initializes a new &struct super_block. alloc_super() 158 * returns a pointer new superblock or %NULL if allocation had failed. 159 */ 160 static struct super_block *alloc_super(struct file_system_type *type, int flags) 161 { 162 struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER); 163 static const struct super_operations default_op; 164 int i; 165 166 if (!s) 167 return NULL; 168 169 INIT_LIST_HEAD(&s->s_mounts); 170 171 if (security_sb_alloc(s)) 172 goto fail; 173 174 for (i = 0; i < SB_FREEZE_LEVELS; i++) { 175 if (percpu_counter_init(&s->s_writers.counter[i], 0) < 0) 176 goto fail; 177 lockdep_init_map(&s->s_writers.lock_map[i], sb_writers_name[i], 178 &type->s_writers_key[i], 0); 179 } 180 init_waitqueue_head(&s->s_writers.wait); 181 init_waitqueue_head(&s->s_writers.wait_unfrozen); 182 s->s_flags = flags; 183 s->s_bdi = &default_backing_dev_info; 184 INIT_HLIST_NODE(&s->s_instances); 185 INIT_HLIST_BL_HEAD(&s->s_anon); 186 INIT_LIST_HEAD(&s->s_inodes); 187 188 if (list_lru_init(&s->s_dentry_lru)) 189 goto fail; 190 if (list_lru_init(&s->s_inode_lru)) 191 goto fail; 192 193 init_rwsem(&s->s_umount); 194 lockdep_set_class(&s->s_umount, &type->s_umount_key); 195 /* 196 * sget() can have s_umount recursion. 197 * 198 * When it cannot find a suitable sb, it allocates a new 199 * one (this one), and tries again to find a suitable old 200 * one. 201 * 202 * In case that succeeds, it will acquire the s_umount 203 * lock of the old one. Since these are clearly distrinct 204 * locks, and this object isn't exposed yet, there's no 205 * risk of deadlocks. 206 * 207 * Annotate this by putting this lock in a different 208 * subclass. 209 */ 210 down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING); 211 s->s_count = 1; 212 atomic_set(&s->s_active, 1); 213 mutex_init(&s->s_vfs_rename_mutex); 214 lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key); 215 mutex_init(&s->s_dquot.dqio_mutex); 216 mutex_init(&s->s_dquot.dqonoff_mutex); 217 init_rwsem(&s->s_dquot.dqptr_sem); 218 s->s_maxbytes = MAX_NON_LFS; 219 s->s_op = &default_op; 220 s->s_time_gran = 1000000000; 221 s->cleancache_poolid = -1; 222 223 s->s_shrink.seeks = DEFAULT_SEEKS; 224 s->s_shrink.scan_objects = super_cache_scan; 225 s->s_shrink.count_objects = super_cache_count; 226 s->s_shrink.batch = 1024; 227 s->s_shrink.flags = SHRINKER_NUMA_AWARE; 228 return s; 229 230 fail: 231 destroy_super(s); 232 return NULL; 233 } 234 235 /* Superblock refcounting */ 236 237 /* 238 * Drop a superblock's refcount. The caller must hold sb_lock. 239 */ 240 static void __put_super(struct super_block *sb) 241 { 242 if (!--sb->s_count) { 243 list_del_init(&sb->s_list); 244 destroy_super(sb); 245 } 246 } 247 248 /** 249 * put_super - drop a temporary reference to superblock 250 * @sb: superblock in question 251 * 252 * Drops a temporary reference, frees superblock if there's no 253 * references left. 254 */ 255 static void put_super(struct super_block *sb) 256 { 257 spin_lock(&sb_lock); 258 __put_super(sb); 259 spin_unlock(&sb_lock); 260 } 261 262 263 /** 264 * deactivate_locked_super - drop an active reference to superblock 265 * @s: superblock to deactivate 266 * 267 * Drops an active reference to superblock, converting it into a temprory 268 * one if there is no other active references left. In that case we 269 * tell fs driver to shut it down and drop the temporary reference we 270 * had just acquired. 271 * 272 * Caller holds exclusive lock on superblock; that lock is released. 273 */ 274 void deactivate_locked_super(struct super_block *s) 275 { 276 struct file_system_type *fs = s->s_type; 277 if (atomic_dec_and_test(&s->s_active)) { 278 cleancache_invalidate_fs(s); 279 fs->kill_sb(s); 280 281 /* caches are now gone, we can safely kill the shrinker now */ 282 unregister_shrinker(&s->s_shrink); 283 284 put_filesystem(fs); 285 put_super(s); 286 } else { 287 up_write(&s->s_umount); 288 } 289 } 290 291 EXPORT_SYMBOL(deactivate_locked_super); 292 293 /** 294 * deactivate_super - drop an active reference to superblock 295 * @s: superblock to deactivate 296 * 297 * Variant of deactivate_locked_super(), except that superblock is *not* 298 * locked by caller. If we are going to drop the final active reference, 299 * lock will be acquired prior to that. 300 */ 301 void deactivate_super(struct super_block *s) 302 { 303 if (!atomic_add_unless(&s->s_active, -1, 1)) { 304 down_write(&s->s_umount); 305 deactivate_locked_super(s); 306 } 307 } 308 309 EXPORT_SYMBOL(deactivate_super); 310 311 /** 312 * grab_super - acquire an active reference 313 * @s: reference we are trying to make active 314 * 315 * Tries to acquire an active reference. grab_super() is used when we 316 * had just found a superblock in super_blocks or fs_type->fs_supers 317 * and want to turn it into a full-blown active reference. grab_super() 318 * is called with sb_lock held and drops it. Returns 1 in case of 319 * success, 0 if we had failed (superblock contents was already dead or 320 * dying when grab_super() had been called). Note that this is only 321 * called for superblocks not in rundown mode (== ones still on ->fs_supers 322 * of their type), so increment of ->s_count is OK here. 323 */ 324 static int grab_super(struct super_block *s) __releases(sb_lock) 325 { 326 s->s_count++; 327 spin_unlock(&sb_lock); 328 down_write(&s->s_umount); 329 if ((s->s_flags & MS_BORN) && atomic_inc_not_zero(&s->s_active)) { 330 put_super(s); 331 return 1; 332 } 333 up_write(&s->s_umount); 334 put_super(s); 335 return 0; 336 } 337 338 /* 339 * grab_super_passive - acquire a passive reference 340 * @sb: reference we are trying to grab 341 * 342 * Tries to acquire a passive reference. This is used in places where we 343 * cannot take an active reference but we need to ensure that the 344 * superblock does not go away while we are working on it. It returns 345 * false if a reference was not gained, and returns true with the s_umount 346 * lock held in read mode if a reference is gained. On successful return, 347 * the caller must drop the s_umount lock and the passive reference when 348 * done. 349 */ 350 bool grab_super_passive(struct super_block *sb) 351 { 352 spin_lock(&sb_lock); 353 if (hlist_unhashed(&sb->s_instances)) { 354 spin_unlock(&sb_lock); 355 return false; 356 } 357 358 sb->s_count++; 359 spin_unlock(&sb_lock); 360 361 if (down_read_trylock(&sb->s_umount)) { 362 if (sb->s_root && (sb->s_flags & MS_BORN)) 363 return true; 364 up_read(&sb->s_umount); 365 } 366 367 put_super(sb); 368 return false; 369 } 370 371 /** 372 * generic_shutdown_super - common helper for ->kill_sb() 373 * @sb: superblock to kill 374 * 375 * generic_shutdown_super() does all fs-independent work on superblock 376 * shutdown. Typical ->kill_sb() should pick all fs-specific objects 377 * that need destruction out of superblock, call generic_shutdown_super() 378 * and release aforementioned objects. Note: dentries and inodes _are_ 379 * taken care of and do not need specific handling. 380 * 381 * Upon calling this function, the filesystem may no longer alter or 382 * rearrange the set of dentries belonging to this super_block, nor may it 383 * change the attachments of dentries to inodes. 384 */ 385 void generic_shutdown_super(struct super_block *sb) 386 { 387 const struct super_operations *sop = sb->s_op; 388 389 if (sb->s_root) { 390 shrink_dcache_for_umount(sb); 391 sync_filesystem(sb); 392 sb->s_flags &= ~MS_ACTIVE; 393 394 fsnotify_unmount_inodes(&sb->s_inodes); 395 396 evict_inodes(sb); 397 398 if (sb->s_dio_done_wq) { 399 destroy_workqueue(sb->s_dio_done_wq); 400 sb->s_dio_done_wq = NULL; 401 } 402 403 if (sop->put_super) 404 sop->put_super(sb); 405 406 if (!list_empty(&sb->s_inodes)) { 407 printk("VFS: Busy inodes after unmount of %s. " 408 "Self-destruct in 5 seconds. Have a nice day...\n", 409 sb->s_id); 410 } 411 } 412 spin_lock(&sb_lock); 413 /* should be initialized for __put_super_and_need_restart() */ 414 hlist_del_init(&sb->s_instances); 415 spin_unlock(&sb_lock); 416 up_write(&sb->s_umount); 417 } 418 419 EXPORT_SYMBOL(generic_shutdown_super); 420 421 /** 422 * sget - find or create a superblock 423 * @type: filesystem type superblock should belong to 424 * @test: comparison callback 425 * @set: setup callback 426 * @flags: mount flags 427 * @data: argument to each of them 428 */ 429 struct super_block *sget(struct file_system_type *type, 430 int (*test)(struct super_block *,void *), 431 int (*set)(struct super_block *,void *), 432 int flags, 433 void *data) 434 { 435 struct super_block *s = NULL; 436 struct super_block *old; 437 int err; 438 439 retry: 440 spin_lock(&sb_lock); 441 if (test) { 442 hlist_for_each_entry(old, &type->fs_supers, s_instances) { 443 if (!test(old, data)) 444 continue; 445 if (!grab_super(old)) 446 goto retry; 447 if (s) { 448 up_write(&s->s_umount); 449 destroy_super(s); 450 s = NULL; 451 } 452 return old; 453 } 454 } 455 if (!s) { 456 spin_unlock(&sb_lock); 457 s = alloc_super(type, flags); 458 if (!s) 459 return ERR_PTR(-ENOMEM); 460 goto retry; 461 } 462 463 err = set(s, data); 464 if (err) { 465 spin_unlock(&sb_lock); 466 up_write(&s->s_umount); 467 destroy_super(s); 468 return ERR_PTR(err); 469 } 470 s->s_type = type; 471 strlcpy(s->s_id, type->name, sizeof(s->s_id)); 472 list_add_tail(&s->s_list, &super_blocks); 473 hlist_add_head(&s->s_instances, &type->fs_supers); 474 spin_unlock(&sb_lock); 475 get_filesystem(type); 476 register_shrinker(&s->s_shrink); 477 return s; 478 } 479 480 EXPORT_SYMBOL(sget); 481 482 void drop_super(struct super_block *sb) 483 { 484 up_read(&sb->s_umount); 485 put_super(sb); 486 } 487 488 EXPORT_SYMBOL(drop_super); 489 490 /** 491 * iterate_supers - call function for all active superblocks 492 * @f: function to call 493 * @arg: argument to pass to it 494 * 495 * Scans the superblock list and calls given function, passing it 496 * locked superblock and given argument. 497 */ 498 void iterate_supers(void (*f)(struct super_block *, void *), void *arg) 499 { 500 struct super_block *sb, *p = NULL; 501 502 spin_lock(&sb_lock); 503 list_for_each_entry(sb, &super_blocks, s_list) { 504 if (hlist_unhashed(&sb->s_instances)) 505 continue; 506 sb->s_count++; 507 spin_unlock(&sb_lock); 508 509 down_read(&sb->s_umount); 510 if (sb->s_root && (sb->s_flags & MS_BORN)) 511 f(sb, arg); 512 up_read(&sb->s_umount); 513 514 spin_lock(&sb_lock); 515 if (p) 516 __put_super(p); 517 p = sb; 518 } 519 if (p) 520 __put_super(p); 521 spin_unlock(&sb_lock); 522 } 523 524 /** 525 * iterate_supers_type - call function for superblocks of given type 526 * @type: fs type 527 * @f: function to call 528 * @arg: argument to pass to it 529 * 530 * Scans the superblock list and calls given function, passing it 531 * locked superblock and given argument. 532 */ 533 void iterate_supers_type(struct file_system_type *type, 534 void (*f)(struct super_block *, void *), void *arg) 535 { 536 struct super_block *sb, *p = NULL; 537 538 spin_lock(&sb_lock); 539 hlist_for_each_entry(sb, &type->fs_supers, s_instances) { 540 sb->s_count++; 541 spin_unlock(&sb_lock); 542 543 down_read(&sb->s_umount); 544 if (sb->s_root && (sb->s_flags & MS_BORN)) 545 f(sb, arg); 546 up_read(&sb->s_umount); 547 548 spin_lock(&sb_lock); 549 if (p) 550 __put_super(p); 551 p = sb; 552 } 553 if (p) 554 __put_super(p); 555 spin_unlock(&sb_lock); 556 } 557 558 EXPORT_SYMBOL(iterate_supers_type); 559 560 /** 561 * get_super - get the superblock of a device 562 * @bdev: device to get the superblock for 563 * 564 * Scans the superblock list and finds the superblock of the file system 565 * mounted on the device given. %NULL is returned if no match is found. 566 */ 567 568 struct super_block *get_super(struct block_device *bdev) 569 { 570 struct super_block *sb; 571 572 if (!bdev) 573 return NULL; 574 575 spin_lock(&sb_lock); 576 rescan: 577 list_for_each_entry(sb, &super_blocks, s_list) { 578 if (hlist_unhashed(&sb->s_instances)) 579 continue; 580 if (sb->s_bdev == bdev) { 581 sb->s_count++; 582 spin_unlock(&sb_lock); 583 down_read(&sb->s_umount); 584 /* still alive? */ 585 if (sb->s_root && (sb->s_flags & MS_BORN)) 586 return sb; 587 up_read(&sb->s_umount); 588 /* nope, got unmounted */ 589 spin_lock(&sb_lock); 590 __put_super(sb); 591 goto rescan; 592 } 593 } 594 spin_unlock(&sb_lock); 595 return NULL; 596 } 597 598 EXPORT_SYMBOL(get_super); 599 600 /** 601 * get_super_thawed - get thawed superblock of a device 602 * @bdev: device to get the superblock for 603 * 604 * Scans the superblock list and finds the superblock of the file system 605 * mounted on the device. The superblock is returned once it is thawed 606 * (or immediately if it was not frozen). %NULL is returned if no match 607 * is found. 608 */ 609 struct super_block *get_super_thawed(struct block_device *bdev) 610 { 611 while (1) { 612 struct super_block *s = get_super(bdev); 613 if (!s || s->s_writers.frozen == SB_UNFROZEN) 614 return s; 615 up_read(&s->s_umount); 616 wait_event(s->s_writers.wait_unfrozen, 617 s->s_writers.frozen == SB_UNFROZEN); 618 put_super(s); 619 } 620 } 621 EXPORT_SYMBOL(get_super_thawed); 622 623 /** 624 * get_active_super - get an active reference to the superblock of a device 625 * @bdev: device to get the superblock for 626 * 627 * Scans the superblock list and finds the superblock of the file system 628 * mounted on the device given. Returns the superblock with an active 629 * reference or %NULL if none was found. 630 */ 631 struct super_block *get_active_super(struct block_device *bdev) 632 { 633 struct super_block *sb; 634 635 if (!bdev) 636 return NULL; 637 638 restart: 639 spin_lock(&sb_lock); 640 list_for_each_entry(sb, &super_blocks, s_list) { 641 if (hlist_unhashed(&sb->s_instances)) 642 continue; 643 if (sb->s_bdev == bdev) { 644 if (!grab_super(sb)) 645 goto restart; 646 up_write(&sb->s_umount); 647 return sb; 648 } 649 } 650 spin_unlock(&sb_lock); 651 return NULL; 652 } 653 654 struct super_block *user_get_super(dev_t dev) 655 { 656 struct super_block *sb; 657 658 spin_lock(&sb_lock); 659 rescan: 660 list_for_each_entry(sb, &super_blocks, s_list) { 661 if (hlist_unhashed(&sb->s_instances)) 662 continue; 663 if (sb->s_dev == dev) { 664 sb->s_count++; 665 spin_unlock(&sb_lock); 666 down_read(&sb->s_umount); 667 /* still alive? */ 668 if (sb->s_root && (sb->s_flags & MS_BORN)) 669 return sb; 670 up_read(&sb->s_umount); 671 /* nope, got unmounted */ 672 spin_lock(&sb_lock); 673 __put_super(sb); 674 goto rescan; 675 } 676 } 677 spin_unlock(&sb_lock); 678 return NULL; 679 } 680 681 /** 682 * do_remount_sb - asks filesystem to change mount options. 683 * @sb: superblock in question 684 * @flags: numeric part of options 685 * @data: the rest of options 686 * @force: whether or not to force the change 687 * 688 * Alters the mount options of a mounted file system. 689 */ 690 int do_remount_sb(struct super_block *sb, int flags, void *data, int force) 691 { 692 int retval; 693 int remount_ro; 694 695 if (sb->s_writers.frozen != SB_UNFROZEN) 696 return -EBUSY; 697 698 #ifdef CONFIG_BLOCK 699 if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev)) 700 return -EACCES; 701 #endif 702 703 if (flags & MS_RDONLY) 704 acct_auto_close(sb); 705 shrink_dcache_sb(sb); 706 707 remount_ro = (flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY); 708 709 /* If we are remounting RDONLY and current sb is read/write, 710 make sure there are no rw files opened */ 711 if (remount_ro) { 712 if (force) { 713 sb->s_readonly_remount = 1; 714 smp_wmb(); 715 } else { 716 retval = sb_prepare_remount_readonly(sb); 717 if (retval) 718 return retval; 719 } 720 } 721 722 if (sb->s_op->remount_fs) { 723 retval = sb->s_op->remount_fs(sb, &flags, data); 724 if (retval) { 725 if (!force) 726 goto cancel_readonly; 727 /* If forced remount, go ahead despite any errors */ 728 WARN(1, "forced remount of a %s fs returned %i\n", 729 sb->s_type->name, retval); 730 } 731 } 732 sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK); 733 /* Needs to be ordered wrt mnt_is_readonly() */ 734 smp_wmb(); 735 sb->s_readonly_remount = 0; 736 737 /* 738 * Some filesystems modify their metadata via some other path than the 739 * bdev buffer cache (eg. use a private mapping, or directories in 740 * pagecache, etc). Also file data modifications go via their own 741 * mappings. So If we try to mount readonly then copy the filesystem 742 * from bdev, we could get stale data, so invalidate it to give a best 743 * effort at coherency. 744 */ 745 if (remount_ro && sb->s_bdev) 746 invalidate_bdev(sb->s_bdev); 747 return 0; 748 749 cancel_readonly: 750 sb->s_readonly_remount = 0; 751 return retval; 752 } 753 754 static void do_emergency_remount(struct work_struct *work) 755 { 756 struct super_block *sb, *p = NULL; 757 758 spin_lock(&sb_lock); 759 list_for_each_entry(sb, &super_blocks, s_list) { 760 if (hlist_unhashed(&sb->s_instances)) 761 continue; 762 sb->s_count++; 763 spin_unlock(&sb_lock); 764 down_write(&sb->s_umount); 765 if (sb->s_root && sb->s_bdev && (sb->s_flags & MS_BORN) && 766 !(sb->s_flags & MS_RDONLY)) { 767 /* 768 * What lock protects sb->s_flags?? 769 */ 770 do_remount_sb(sb, MS_RDONLY, NULL, 1); 771 } 772 up_write(&sb->s_umount); 773 spin_lock(&sb_lock); 774 if (p) 775 __put_super(p); 776 p = sb; 777 } 778 if (p) 779 __put_super(p); 780 spin_unlock(&sb_lock); 781 kfree(work); 782 printk("Emergency Remount complete\n"); 783 } 784 785 void emergency_remount(void) 786 { 787 struct work_struct *work; 788 789 work = kmalloc(sizeof(*work), GFP_ATOMIC); 790 if (work) { 791 INIT_WORK(work, do_emergency_remount); 792 schedule_work(work); 793 } 794 } 795 796 /* 797 * Unnamed block devices are dummy devices used by virtual 798 * filesystems which don't use real block-devices. -- jrs 799 */ 800 801 static DEFINE_IDA(unnamed_dev_ida); 802 static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */ 803 /* Many userspace utilities consider an FSID of 0 invalid. 804 * Always return at least 1 from get_anon_bdev. 805 */ 806 static int unnamed_dev_start = 1; 807 808 int get_anon_bdev(dev_t *p) 809 { 810 int dev; 811 int error; 812 813 retry: 814 if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0) 815 return -ENOMEM; 816 spin_lock(&unnamed_dev_lock); 817 error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev); 818 if (!error) 819 unnamed_dev_start = dev + 1; 820 spin_unlock(&unnamed_dev_lock); 821 if (error == -EAGAIN) 822 /* We raced and lost with another CPU. */ 823 goto retry; 824 else if (error) 825 return -EAGAIN; 826 827 if (dev == (1 << MINORBITS)) { 828 spin_lock(&unnamed_dev_lock); 829 ida_remove(&unnamed_dev_ida, dev); 830 if (unnamed_dev_start > dev) 831 unnamed_dev_start = dev; 832 spin_unlock(&unnamed_dev_lock); 833 return -EMFILE; 834 } 835 *p = MKDEV(0, dev & MINORMASK); 836 return 0; 837 } 838 EXPORT_SYMBOL(get_anon_bdev); 839 840 void free_anon_bdev(dev_t dev) 841 { 842 int slot = MINOR(dev); 843 spin_lock(&unnamed_dev_lock); 844 ida_remove(&unnamed_dev_ida, slot); 845 if (slot < unnamed_dev_start) 846 unnamed_dev_start = slot; 847 spin_unlock(&unnamed_dev_lock); 848 } 849 EXPORT_SYMBOL(free_anon_bdev); 850 851 int set_anon_super(struct super_block *s, void *data) 852 { 853 int error = get_anon_bdev(&s->s_dev); 854 if (!error) 855 s->s_bdi = &noop_backing_dev_info; 856 return error; 857 } 858 859 EXPORT_SYMBOL(set_anon_super); 860 861 void kill_anon_super(struct super_block *sb) 862 { 863 dev_t dev = sb->s_dev; 864 generic_shutdown_super(sb); 865 free_anon_bdev(dev); 866 } 867 868 EXPORT_SYMBOL(kill_anon_super); 869 870 void kill_litter_super(struct super_block *sb) 871 { 872 if (sb->s_root) 873 d_genocide(sb->s_root); 874 kill_anon_super(sb); 875 } 876 877 EXPORT_SYMBOL(kill_litter_super); 878 879 static int ns_test_super(struct super_block *sb, void *data) 880 { 881 return sb->s_fs_info == data; 882 } 883 884 static int ns_set_super(struct super_block *sb, void *data) 885 { 886 sb->s_fs_info = data; 887 return set_anon_super(sb, NULL); 888 } 889 890 struct dentry *mount_ns(struct file_system_type *fs_type, int flags, 891 void *data, int (*fill_super)(struct super_block *, void *, int)) 892 { 893 struct super_block *sb; 894 895 sb = sget(fs_type, ns_test_super, ns_set_super, flags, data); 896 if (IS_ERR(sb)) 897 return ERR_CAST(sb); 898 899 if (!sb->s_root) { 900 int err; 901 err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0); 902 if (err) { 903 deactivate_locked_super(sb); 904 return ERR_PTR(err); 905 } 906 907 sb->s_flags |= MS_ACTIVE; 908 } 909 910 return dget(sb->s_root); 911 } 912 913 EXPORT_SYMBOL(mount_ns); 914 915 #ifdef CONFIG_BLOCK 916 static int set_bdev_super(struct super_block *s, void *data) 917 { 918 s->s_bdev = data; 919 s->s_dev = s->s_bdev->bd_dev; 920 921 /* 922 * We set the bdi here to the queue backing, file systems can 923 * overwrite this in ->fill_super() 924 */ 925 s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info; 926 return 0; 927 } 928 929 static int test_bdev_super(struct super_block *s, void *data) 930 { 931 return (void *)s->s_bdev == data; 932 } 933 934 struct dentry *mount_bdev(struct file_system_type *fs_type, 935 int flags, const char *dev_name, void *data, 936 int (*fill_super)(struct super_block *, void *, int)) 937 { 938 struct block_device *bdev; 939 struct super_block *s; 940 fmode_t mode = FMODE_READ | FMODE_EXCL; 941 int error = 0; 942 943 if (!(flags & MS_RDONLY)) 944 mode |= FMODE_WRITE; 945 946 bdev = blkdev_get_by_path(dev_name, mode, fs_type); 947 if (IS_ERR(bdev)) 948 return ERR_CAST(bdev); 949 950 /* 951 * once the super is inserted into the list by sget, s_umount 952 * will protect the lockfs code from trying to start a snapshot 953 * while we are mounting 954 */ 955 mutex_lock(&bdev->bd_fsfreeze_mutex); 956 if (bdev->bd_fsfreeze_count > 0) { 957 mutex_unlock(&bdev->bd_fsfreeze_mutex); 958 error = -EBUSY; 959 goto error_bdev; 960 } 961 s = sget(fs_type, test_bdev_super, set_bdev_super, flags | MS_NOSEC, 962 bdev); 963 mutex_unlock(&bdev->bd_fsfreeze_mutex); 964 if (IS_ERR(s)) 965 goto error_s; 966 967 if (s->s_root) { 968 if ((flags ^ s->s_flags) & MS_RDONLY) { 969 deactivate_locked_super(s); 970 error = -EBUSY; 971 goto error_bdev; 972 } 973 974 /* 975 * s_umount nests inside bd_mutex during 976 * __invalidate_device(). blkdev_put() acquires 977 * bd_mutex and can't be called under s_umount. Drop 978 * s_umount temporarily. This is safe as we're 979 * holding an active reference. 980 */ 981 up_write(&s->s_umount); 982 blkdev_put(bdev, mode); 983 down_write(&s->s_umount); 984 } else { 985 char b[BDEVNAME_SIZE]; 986 987 s->s_mode = mode; 988 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id)); 989 sb_set_blocksize(s, block_size(bdev)); 990 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0); 991 if (error) { 992 deactivate_locked_super(s); 993 goto error; 994 } 995 996 s->s_flags |= MS_ACTIVE; 997 bdev->bd_super = s; 998 } 999 1000 return dget(s->s_root); 1001 1002 error_s: 1003 error = PTR_ERR(s); 1004 error_bdev: 1005 blkdev_put(bdev, mode); 1006 error: 1007 return ERR_PTR(error); 1008 } 1009 EXPORT_SYMBOL(mount_bdev); 1010 1011 void kill_block_super(struct super_block *sb) 1012 { 1013 struct block_device *bdev = sb->s_bdev; 1014 fmode_t mode = sb->s_mode; 1015 1016 bdev->bd_super = NULL; 1017 generic_shutdown_super(sb); 1018 sync_blockdev(bdev); 1019 WARN_ON_ONCE(!(mode & FMODE_EXCL)); 1020 blkdev_put(bdev, mode | FMODE_EXCL); 1021 } 1022 1023 EXPORT_SYMBOL(kill_block_super); 1024 #endif 1025 1026 struct dentry *mount_nodev(struct file_system_type *fs_type, 1027 int flags, void *data, 1028 int (*fill_super)(struct super_block *, void *, int)) 1029 { 1030 int error; 1031 struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL); 1032 1033 if (IS_ERR(s)) 1034 return ERR_CAST(s); 1035 1036 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0); 1037 if (error) { 1038 deactivate_locked_super(s); 1039 return ERR_PTR(error); 1040 } 1041 s->s_flags |= MS_ACTIVE; 1042 return dget(s->s_root); 1043 } 1044 EXPORT_SYMBOL(mount_nodev); 1045 1046 static int compare_single(struct super_block *s, void *p) 1047 { 1048 return 1; 1049 } 1050 1051 struct dentry *mount_single(struct file_system_type *fs_type, 1052 int flags, void *data, 1053 int (*fill_super)(struct super_block *, void *, int)) 1054 { 1055 struct super_block *s; 1056 int error; 1057 1058 s = sget(fs_type, compare_single, set_anon_super, flags, NULL); 1059 if (IS_ERR(s)) 1060 return ERR_CAST(s); 1061 if (!s->s_root) { 1062 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0); 1063 if (error) { 1064 deactivate_locked_super(s); 1065 return ERR_PTR(error); 1066 } 1067 s->s_flags |= MS_ACTIVE; 1068 } else { 1069 do_remount_sb(s, flags, data, 0); 1070 } 1071 return dget(s->s_root); 1072 } 1073 EXPORT_SYMBOL(mount_single); 1074 1075 struct dentry * 1076 mount_fs(struct file_system_type *type, int flags, const char *name, void *data) 1077 { 1078 struct dentry *root; 1079 struct super_block *sb; 1080 char *secdata = NULL; 1081 int error = -ENOMEM; 1082 1083 if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) { 1084 secdata = alloc_secdata(); 1085 if (!secdata) 1086 goto out; 1087 1088 error = security_sb_copy_data(data, secdata); 1089 if (error) 1090 goto out_free_secdata; 1091 } 1092 1093 root = type->mount(type, flags, name, data); 1094 if (IS_ERR(root)) { 1095 error = PTR_ERR(root); 1096 goto out_free_secdata; 1097 } 1098 sb = root->d_sb; 1099 BUG_ON(!sb); 1100 WARN_ON(!sb->s_bdi); 1101 WARN_ON(sb->s_bdi == &default_backing_dev_info); 1102 sb->s_flags |= MS_BORN; 1103 1104 error = security_sb_kern_mount(sb, flags, secdata); 1105 if (error) 1106 goto out_sb; 1107 1108 /* 1109 * filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE 1110 * but s_maxbytes was an unsigned long long for many releases. Throw 1111 * this warning for a little while to try and catch filesystems that 1112 * violate this rule. 1113 */ 1114 WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to " 1115 "negative value (%lld)\n", type->name, sb->s_maxbytes); 1116 1117 up_write(&sb->s_umount); 1118 free_secdata(secdata); 1119 return root; 1120 out_sb: 1121 dput(root); 1122 deactivate_locked_super(sb); 1123 out_free_secdata: 1124 free_secdata(secdata); 1125 out: 1126 return ERR_PTR(error); 1127 } 1128 1129 /* 1130 * This is an internal function, please use sb_end_{write,pagefault,intwrite} 1131 * instead. 1132 */ 1133 void __sb_end_write(struct super_block *sb, int level) 1134 { 1135 percpu_counter_dec(&sb->s_writers.counter[level-1]); 1136 /* 1137 * Make sure s_writers are updated before we wake up waiters in 1138 * freeze_super(). 1139 */ 1140 smp_mb(); 1141 if (waitqueue_active(&sb->s_writers.wait)) 1142 wake_up(&sb->s_writers.wait); 1143 rwsem_release(&sb->s_writers.lock_map[level-1], 1, _RET_IP_); 1144 } 1145 EXPORT_SYMBOL(__sb_end_write); 1146 1147 #ifdef CONFIG_LOCKDEP 1148 /* 1149 * We want lockdep to tell us about possible deadlocks with freezing but 1150 * it's it bit tricky to properly instrument it. Getting a freeze protection 1151 * works as getting a read lock but there are subtle problems. XFS for example 1152 * gets freeze protection on internal level twice in some cases, which is OK 1153 * only because we already hold a freeze protection also on higher level. Due 1154 * to these cases we have to tell lockdep we are doing trylock when we 1155 * already hold a freeze protection for a higher freeze level. 1156 */ 1157 static void acquire_freeze_lock(struct super_block *sb, int level, bool trylock, 1158 unsigned long ip) 1159 { 1160 int i; 1161 1162 if (!trylock) { 1163 for (i = 0; i < level - 1; i++) 1164 if (lock_is_held(&sb->s_writers.lock_map[i])) { 1165 trylock = true; 1166 break; 1167 } 1168 } 1169 rwsem_acquire_read(&sb->s_writers.lock_map[level-1], 0, trylock, ip); 1170 } 1171 #endif 1172 1173 /* 1174 * This is an internal function, please use sb_start_{write,pagefault,intwrite} 1175 * instead. 1176 */ 1177 int __sb_start_write(struct super_block *sb, int level, bool wait) 1178 { 1179 retry: 1180 if (unlikely(sb->s_writers.frozen >= level)) { 1181 if (!wait) 1182 return 0; 1183 wait_event(sb->s_writers.wait_unfrozen, 1184 sb->s_writers.frozen < level); 1185 } 1186 1187 #ifdef CONFIG_LOCKDEP 1188 acquire_freeze_lock(sb, level, !wait, _RET_IP_); 1189 #endif 1190 percpu_counter_inc(&sb->s_writers.counter[level-1]); 1191 /* 1192 * Make sure counter is updated before we check for frozen. 1193 * freeze_super() first sets frozen and then checks the counter. 1194 */ 1195 smp_mb(); 1196 if (unlikely(sb->s_writers.frozen >= level)) { 1197 __sb_end_write(sb, level); 1198 goto retry; 1199 } 1200 return 1; 1201 } 1202 EXPORT_SYMBOL(__sb_start_write); 1203 1204 /** 1205 * sb_wait_write - wait until all writers to given file system finish 1206 * @sb: the super for which we wait 1207 * @level: type of writers we wait for (normal vs page fault) 1208 * 1209 * This function waits until there are no writers of given type to given file 1210 * system. Caller of this function should make sure there can be no new writers 1211 * of type @level before calling this function. Otherwise this function can 1212 * livelock. 1213 */ 1214 static void sb_wait_write(struct super_block *sb, int level) 1215 { 1216 s64 writers; 1217 1218 /* 1219 * We just cycle-through lockdep here so that it does not complain 1220 * about returning with lock to userspace 1221 */ 1222 rwsem_acquire(&sb->s_writers.lock_map[level-1], 0, 0, _THIS_IP_); 1223 rwsem_release(&sb->s_writers.lock_map[level-1], 1, _THIS_IP_); 1224 1225 do { 1226 DEFINE_WAIT(wait); 1227 1228 /* 1229 * We use a barrier in prepare_to_wait() to separate setting 1230 * of frozen and checking of the counter 1231 */ 1232 prepare_to_wait(&sb->s_writers.wait, &wait, 1233 TASK_UNINTERRUPTIBLE); 1234 1235 writers = percpu_counter_sum(&sb->s_writers.counter[level-1]); 1236 if (writers) 1237 schedule(); 1238 1239 finish_wait(&sb->s_writers.wait, &wait); 1240 } while (writers); 1241 } 1242 1243 /** 1244 * freeze_super - lock the filesystem and force it into a consistent state 1245 * @sb: the super to lock 1246 * 1247 * Syncs the super to make sure the filesystem is consistent and calls the fs's 1248 * freeze_fs. Subsequent calls to this without first thawing the fs will return 1249 * -EBUSY. 1250 * 1251 * During this function, sb->s_writers.frozen goes through these values: 1252 * 1253 * SB_UNFROZEN: File system is normal, all writes progress as usual. 1254 * 1255 * SB_FREEZE_WRITE: The file system is in the process of being frozen. New 1256 * writes should be blocked, though page faults are still allowed. We wait for 1257 * all writes to complete and then proceed to the next stage. 1258 * 1259 * SB_FREEZE_PAGEFAULT: Freezing continues. Now also page faults are blocked 1260 * but internal fs threads can still modify the filesystem (although they 1261 * should not dirty new pages or inodes), writeback can run etc. After waiting 1262 * for all running page faults we sync the filesystem which will clean all 1263 * dirty pages and inodes (no new dirty pages or inodes can be created when 1264 * sync is running). 1265 * 1266 * SB_FREEZE_FS: The file system is frozen. Now all internal sources of fs 1267 * modification are blocked (e.g. XFS preallocation truncation on inode 1268 * reclaim). This is usually implemented by blocking new transactions for 1269 * filesystems that have them and need this additional guard. After all 1270 * internal writers are finished we call ->freeze_fs() to finish filesystem 1271 * freezing. Then we transition to SB_FREEZE_COMPLETE state. This state is 1272 * mostly auxiliary for filesystems to verify they do not modify frozen fs. 1273 * 1274 * sb->s_writers.frozen is protected by sb->s_umount. 1275 */ 1276 int freeze_super(struct super_block *sb) 1277 { 1278 int ret; 1279 1280 atomic_inc(&sb->s_active); 1281 down_write(&sb->s_umount); 1282 if (sb->s_writers.frozen != SB_UNFROZEN) { 1283 deactivate_locked_super(sb); 1284 return -EBUSY; 1285 } 1286 1287 if (!(sb->s_flags & MS_BORN)) { 1288 up_write(&sb->s_umount); 1289 return 0; /* sic - it's "nothing to do" */ 1290 } 1291 1292 if (sb->s_flags & MS_RDONLY) { 1293 /* Nothing to do really... */ 1294 sb->s_writers.frozen = SB_FREEZE_COMPLETE; 1295 up_write(&sb->s_umount); 1296 return 0; 1297 } 1298 1299 /* From now on, no new normal writers can start */ 1300 sb->s_writers.frozen = SB_FREEZE_WRITE; 1301 smp_wmb(); 1302 1303 /* Release s_umount to preserve sb_start_write -> s_umount ordering */ 1304 up_write(&sb->s_umount); 1305 1306 sb_wait_write(sb, SB_FREEZE_WRITE); 1307 1308 /* Now we go and block page faults... */ 1309 down_write(&sb->s_umount); 1310 sb->s_writers.frozen = SB_FREEZE_PAGEFAULT; 1311 smp_wmb(); 1312 1313 sb_wait_write(sb, SB_FREEZE_PAGEFAULT); 1314 1315 /* All writers are done so after syncing there won't be dirty data */ 1316 sync_filesystem(sb); 1317 1318 /* Now wait for internal filesystem counter */ 1319 sb->s_writers.frozen = SB_FREEZE_FS; 1320 smp_wmb(); 1321 sb_wait_write(sb, SB_FREEZE_FS); 1322 1323 if (sb->s_op->freeze_fs) { 1324 ret = sb->s_op->freeze_fs(sb); 1325 if (ret) { 1326 printk(KERN_ERR 1327 "VFS:Filesystem freeze failed\n"); 1328 sb->s_writers.frozen = SB_UNFROZEN; 1329 smp_wmb(); 1330 wake_up(&sb->s_writers.wait_unfrozen); 1331 deactivate_locked_super(sb); 1332 return ret; 1333 } 1334 } 1335 /* 1336 * This is just for debugging purposes so that fs can warn if it 1337 * sees write activity when frozen is set to SB_FREEZE_COMPLETE. 1338 */ 1339 sb->s_writers.frozen = SB_FREEZE_COMPLETE; 1340 up_write(&sb->s_umount); 1341 return 0; 1342 } 1343 EXPORT_SYMBOL(freeze_super); 1344 1345 /** 1346 * thaw_super -- unlock filesystem 1347 * @sb: the super to thaw 1348 * 1349 * Unlocks the filesystem and marks it writeable again after freeze_super(). 1350 */ 1351 int thaw_super(struct super_block *sb) 1352 { 1353 int error; 1354 1355 down_write(&sb->s_umount); 1356 if (sb->s_writers.frozen == SB_UNFROZEN) { 1357 up_write(&sb->s_umount); 1358 return -EINVAL; 1359 } 1360 1361 if (sb->s_flags & MS_RDONLY) 1362 goto out; 1363 1364 if (sb->s_op->unfreeze_fs) { 1365 error = sb->s_op->unfreeze_fs(sb); 1366 if (error) { 1367 printk(KERN_ERR 1368 "VFS:Filesystem thaw failed\n"); 1369 up_write(&sb->s_umount); 1370 return error; 1371 } 1372 } 1373 1374 out: 1375 sb->s_writers.frozen = SB_UNFROZEN; 1376 smp_wmb(); 1377 wake_up(&sb->s_writers.wait_unfrozen); 1378 deactivate_locked_super(sb); 1379 1380 return 0; 1381 } 1382 EXPORT_SYMBOL(thaw_super); 1383