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 static int unnamed_dev_start = 0; /* don't bother trying below it */ 804 805 int get_anon_bdev(dev_t *p) 806 { 807 int dev; 808 int error; 809 810 retry: 811 if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0) 812 return -ENOMEM; 813 spin_lock(&unnamed_dev_lock); 814 error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev); 815 if (!error) 816 unnamed_dev_start = dev + 1; 817 spin_unlock(&unnamed_dev_lock); 818 if (error == -EAGAIN) 819 /* We raced and lost with another CPU. */ 820 goto retry; 821 else if (error) 822 return -EAGAIN; 823 824 if (dev == (1 << MINORBITS)) { 825 spin_lock(&unnamed_dev_lock); 826 ida_remove(&unnamed_dev_ida, dev); 827 if (unnamed_dev_start > dev) 828 unnamed_dev_start = dev; 829 spin_unlock(&unnamed_dev_lock); 830 return -EMFILE; 831 } 832 *p = MKDEV(0, dev & MINORMASK); 833 return 0; 834 } 835 EXPORT_SYMBOL(get_anon_bdev); 836 837 void free_anon_bdev(dev_t dev) 838 { 839 int slot = MINOR(dev); 840 spin_lock(&unnamed_dev_lock); 841 ida_remove(&unnamed_dev_ida, slot); 842 if (slot < unnamed_dev_start) 843 unnamed_dev_start = slot; 844 spin_unlock(&unnamed_dev_lock); 845 } 846 EXPORT_SYMBOL(free_anon_bdev); 847 848 int set_anon_super(struct super_block *s, void *data) 849 { 850 int error = get_anon_bdev(&s->s_dev); 851 if (!error) 852 s->s_bdi = &noop_backing_dev_info; 853 return error; 854 } 855 856 EXPORT_SYMBOL(set_anon_super); 857 858 void kill_anon_super(struct super_block *sb) 859 { 860 dev_t dev = sb->s_dev; 861 generic_shutdown_super(sb); 862 free_anon_bdev(dev); 863 } 864 865 EXPORT_SYMBOL(kill_anon_super); 866 867 void kill_litter_super(struct super_block *sb) 868 { 869 if (sb->s_root) 870 d_genocide(sb->s_root); 871 kill_anon_super(sb); 872 } 873 874 EXPORT_SYMBOL(kill_litter_super); 875 876 static int ns_test_super(struct super_block *sb, void *data) 877 { 878 return sb->s_fs_info == data; 879 } 880 881 static int ns_set_super(struct super_block *sb, void *data) 882 { 883 sb->s_fs_info = data; 884 return set_anon_super(sb, NULL); 885 } 886 887 struct dentry *mount_ns(struct file_system_type *fs_type, int flags, 888 void *data, int (*fill_super)(struct super_block *, void *, int)) 889 { 890 struct super_block *sb; 891 892 sb = sget(fs_type, ns_test_super, ns_set_super, flags, data); 893 if (IS_ERR(sb)) 894 return ERR_CAST(sb); 895 896 if (!sb->s_root) { 897 int err; 898 err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0); 899 if (err) { 900 deactivate_locked_super(sb); 901 return ERR_PTR(err); 902 } 903 904 sb->s_flags |= MS_ACTIVE; 905 } 906 907 return dget(sb->s_root); 908 } 909 910 EXPORT_SYMBOL(mount_ns); 911 912 #ifdef CONFIG_BLOCK 913 static int set_bdev_super(struct super_block *s, void *data) 914 { 915 s->s_bdev = data; 916 s->s_dev = s->s_bdev->bd_dev; 917 918 /* 919 * We set the bdi here to the queue backing, file systems can 920 * overwrite this in ->fill_super() 921 */ 922 s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info; 923 return 0; 924 } 925 926 static int test_bdev_super(struct super_block *s, void *data) 927 { 928 return (void *)s->s_bdev == data; 929 } 930 931 struct dentry *mount_bdev(struct file_system_type *fs_type, 932 int flags, const char *dev_name, void *data, 933 int (*fill_super)(struct super_block *, void *, int)) 934 { 935 struct block_device *bdev; 936 struct super_block *s; 937 fmode_t mode = FMODE_READ | FMODE_EXCL; 938 int error = 0; 939 940 if (!(flags & MS_RDONLY)) 941 mode |= FMODE_WRITE; 942 943 bdev = blkdev_get_by_path(dev_name, mode, fs_type); 944 if (IS_ERR(bdev)) 945 return ERR_CAST(bdev); 946 947 /* 948 * once the super is inserted into the list by sget, s_umount 949 * will protect the lockfs code from trying to start a snapshot 950 * while we are mounting 951 */ 952 mutex_lock(&bdev->bd_fsfreeze_mutex); 953 if (bdev->bd_fsfreeze_count > 0) { 954 mutex_unlock(&bdev->bd_fsfreeze_mutex); 955 error = -EBUSY; 956 goto error_bdev; 957 } 958 s = sget(fs_type, test_bdev_super, set_bdev_super, flags | MS_NOSEC, 959 bdev); 960 mutex_unlock(&bdev->bd_fsfreeze_mutex); 961 if (IS_ERR(s)) 962 goto error_s; 963 964 if (s->s_root) { 965 if ((flags ^ s->s_flags) & MS_RDONLY) { 966 deactivate_locked_super(s); 967 error = -EBUSY; 968 goto error_bdev; 969 } 970 971 /* 972 * s_umount nests inside bd_mutex during 973 * __invalidate_device(). blkdev_put() acquires 974 * bd_mutex and can't be called under s_umount. Drop 975 * s_umount temporarily. This is safe as we're 976 * holding an active reference. 977 */ 978 up_write(&s->s_umount); 979 blkdev_put(bdev, mode); 980 down_write(&s->s_umount); 981 } else { 982 char b[BDEVNAME_SIZE]; 983 984 s->s_mode = mode; 985 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id)); 986 sb_set_blocksize(s, block_size(bdev)); 987 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0); 988 if (error) { 989 deactivate_locked_super(s); 990 goto error; 991 } 992 993 s->s_flags |= MS_ACTIVE; 994 bdev->bd_super = s; 995 } 996 997 return dget(s->s_root); 998 999 error_s: 1000 error = PTR_ERR(s); 1001 error_bdev: 1002 blkdev_put(bdev, mode); 1003 error: 1004 return ERR_PTR(error); 1005 } 1006 EXPORT_SYMBOL(mount_bdev); 1007 1008 void kill_block_super(struct super_block *sb) 1009 { 1010 struct block_device *bdev = sb->s_bdev; 1011 fmode_t mode = sb->s_mode; 1012 1013 bdev->bd_super = NULL; 1014 generic_shutdown_super(sb); 1015 sync_blockdev(bdev); 1016 WARN_ON_ONCE(!(mode & FMODE_EXCL)); 1017 blkdev_put(bdev, mode | FMODE_EXCL); 1018 } 1019 1020 EXPORT_SYMBOL(kill_block_super); 1021 #endif 1022 1023 struct dentry *mount_nodev(struct file_system_type *fs_type, 1024 int flags, void *data, 1025 int (*fill_super)(struct super_block *, void *, int)) 1026 { 1027 int error; 1028 struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL); 1029 1030 if (IS_ERR(s)) 1031 return ERR_CAST(s); 1032 1033 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0); 1034 if (error) { 1035 deactivate_locked_super(s); 1036 return ERR_PTR(error); 1037 } 1038 s->s_flags |= MS_ACTIVE; 1039 return dget(s->s_root); 1040 } 1041 EXPORT_SYMBOL(mount_nodev); 1042 1043 static int compare_single(struct super_block *s, void *p) 1044 { 1045 return 1; 1046 } 1047 1048 struct dentry *mount_single(struct file_system_type *fs_type, 1049 int flags, void *data, 1050 int (*fill_super)(struct super_block *, void *, int)) 1051 { 1052 struct super_block *s; 1053 int error; 1054 1055 s = sget(fs_type, compare_single, set_anon_super, flags, NULL); 1056 if (IS_ERR(s)) 1057 return ERR_CAST(s); 1058 if (!s->s_root) { 1059 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0); 1060 if (error) { 1061 deactivate_locked_super(s); 1062 return ERR_PTR(error); 1063 } 1064 s->s_flags |= MS_ACTIVE; 1065 } else { 1066 do_remount_sb(s, flags, data, 0); 1067 } 1068 return dget(s->s_root); 1069 } 1070 EXPORT_SYMBOL(mount_single); 1071 1072 struct dentry * 1073 mount_fs(struct file_system_type *type, int flags, const char *name, void *data) 1074 { 1075 struct dentry *root; 1076 struct super_block *sb; 1077 char *secdata = NULL; 1078 int error = -ENOMEM; 1079 1080 if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) { 1081 secdata = alloc_secdata(); 1082 if (!secdata) 1083 goto out; 1084 1085 error = security_sb_copy_data(data, secdata); 1086 if (error) 1087 goto out_free_secdata; 1088 } 1089 1090 root = type->mount(type, flags, name, data); 1091 if (IS_ERR(root)) { 1092 error = PTR_ERR(root); 1093 goto out_free_secdata; 1094 } 1095 sb = root->d_sb; 1096 BUG_ON(!sb); 1097 WARN_ON(!sb->s_bdi); 1098 WARN_ON(sb->s_bdi == &default_backing_dev_info); 1099 sb->s_flags |= MS_BORN; 1100 1101 error = security_sb_kern_mount(sb, flags, secdata); 1102 if (error) 1103 goto out_sb; 1104 1105 /* 1106 * filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE 1107 * but s_maxbytes was an unsigned long long for many releases. Throw 1108 * this warning for a little while to try and catch filesystems that 1109 * violate this rule. 1110 */ 1111 WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to " 1112 "negative value (%lld)\n", type->name, sb->s_maxbytes); 1113 1114 up_write(&sb->s_umount); 1115 free_secdata(secdata); 1116 return root; 1117 out_sb: 1118 dput(root); 1119 deactivate_locked_super(sb); 1120 out_free_secdata: 1121 free_secdata(secdata); 1122 out: 1123 return ERR_PTR(error); 1124 } 1125 1126 /* 1127 * This is an internal function, please use sb_end_{write,pagefault,intwrite} 1128 * instead. 1129 */ 1130 void __sb_end_write(struct super_block *sb, int level) 1131 { 1132 percpu_counter_dec(&sb->s_writers.counter[level-1]); 1133 /* 1134 * Make sure s_writers are updated before we wake up waiters in 1135 * freeze_super(). 1136 */ 1137 smp_mb(); 1138 if (waitqueue_active(&sb->s_writers.wait)) 1139 wake_up(&sb->s_writers.wait); 1140 rwsem_release(&sb->s_writers.lock_map[level-1], 1, _RET_IP_); 1141 } 1142 EXPORT_SYMBOL(__sb_end_write); 1143 1144 #ifdef CONFIG_LOCKDEP 1145 /* 1146 * We want lockdep to tell us about possible deadlocks with freezing but 1147 * it's it bit tricky to properly instrument it. Getting a freeze protection 1148 * works as getting a read lock but there are subtle problems. XFS for example 1149 * gets freeze protection on internal level twice in some cases, which is OK 1150 * only because we already hold a freeze protection also on higher level. Due 1151 * to these cases we have to tell lockdep we are doing trylock when we 1152 * already hold a freeze protection for a higher freeze level. 1153 */ 1154 static void acquire_freeze_lock(struct super_block *sb, int level, bool trylock, 1155 unsigned long ip) 1156 { 1157 int i; 1158 1159 if (!trylock) { 1160 for (i = 0; i < level - 1; i++) 1161 if (lock_is_held(&sb->s_writers.lock_map[i])) { 1162 trylock = true; 1163 break; 1164 } 1165 } 1166 rwsem_acquire_read(&sb->s_writers.lock_map[level-1], 0, trylock, ip); 1167 } 1168 #endif 1169 1170 /* 1171 * This is an internal function, please use sb_start_{write,pagefault,intwrite} 1172 * instead. 1173 */ 1174 int __sb_start_write(struct super_block *sb, int level, bool wait) 1175 { 1176 retry: 1177 if (unlikely(sb->s_writers.frozen >= level)) { 1178 if (!wait) 1179 return 0; 1180 wait_event(sb->s_writers.wait_unfrozen, 1181 sb->s_writers.frozen < level); 1182 } 1183 1184 #ifdef CONFIG_LOCKDEP 1185 acquire_freeze_lock(sb, level, !wait, _RET_IP_); 1186 #endif 1187 percpu_counter_inc(&sb->s_writers.counter[level-1]); 1188 /* 1189 * Make sure counter is updated before we check for frozen. 1190 * freeze_super() first sets frozen and then checks the counter. 1191 */ 1192 smp_mb(); 1193 if (unlikely(sb->s_writers.frozen >= level)) { 1194 __sb_end_write(sb, level); 1195 goto retry; 1196 } 1197 return 1; 1198 } 1199 EXPORT_SYMBOL(__sb_start_write); 1200 1201 /** 1202 * sb_wait_write - wait until all writers to given file system finish 1203 * @sb: the super for which we wait 1204 * @level: type of writers we wait for (normal vs page fault) 1205 * 1206 * This function waits until there are no writers of given type to given file 1207 * system. Caller of this function should make sure there can be no new writers 1208 * of type @level before calling this function. Otherwise this function can 1209 * livelock. 1210 */ 1211 static void sb_wait_write(struct super_block *sb, int level) 1212 { 1213 s64 writers; 1214 1215 /* 1216 * We just cycle-through lockdep here so that it does not complain 1217 * about returning with lock to userspace 1218 */ 1219 rwsem_acquire(&sb->s_writers.lock_map[level-1], 0, 0, _THIS_IP_); 1220 rwsem_release(&sb->s_writers.lock_map[level-1], 1, _THIS_IP_); 1221 1222 do { 1223 DEFINE_WAIT(wait); 1224 1225 /* 1226 * We use a barrier in prepare_to_wait() to separate setting 1227 * of frozen and checking of the counter 1228 */ 1229 prepare_to_wait(&sb->s_writers.wait, &wait, 1230 TASK_UNINTERRUPTIBLE); 1231 1232 writers = percpu_counter_sum(&sb->s_writers.counter[level-1]); 1233 if (writers) 1234 schedule(); 1235 1236 finish_wait(&sb->s_writers.wait, &wait); 1237 } while (writers); 1238 } 1239 1240 /** 1241 * freeze_super - lock the filesystem and force it into a consistent state 1242 * @sb: the super to lock 1243 * 1244 * Syncs the super to make sure the filesystem is consistent and calls the fs's 1245 * freeze_fs. Subsequent calls to this without first thawing the fs will return 1246 * -EBUSY. 1247 * 1248 * During this function, sb->s_writers.frozen goes through these values: 1249 * 1250 * SB_UNFROZEN: File system is normal, all writes progress as usual. 1251 * 1252 * SB_FREEZE_WRITE: The file system is in the process of being frozen. New 1253 * writes should be blocked, though page faults are still allowed. We wait for 1254 * all writes to complete and then proceed to the next stage. 1255 * 1256 * SB_FREEZE_PAGEFAULT: Freezing continues. Now also page faults are blocked 1257 * but internal fs threads can still modify the filesystem (although they 1258 * should not dirty new pages or inodes), writeback can run etc. After waiting 1259 * for all running page faults we sync the filesystem which will clean all 1260 * dirty pages and inodes (no new dirty pages or inodes can be created when 1261 * sync is running). 1262 * 1263 * SB_FREEZE_FS: The file system is frozen. Now all internal sources of fs 1264 * modification are blocked (e.g. XFS preallocation truncation on inode 1265 * reclaim). This is usually implemented by blocking new transactions for 1266 * filesystems that have them and need this additional guard. After all 1267 * internal writers are finished we call ->freeze_fs() to finish filesystem 1268 * freezing. Then we transition to SB_FREEZE_COMPLETE state. This state is 1269 * mostly auxiliary for filesystems to verify they do not modify frozen fs. 1270 * 1271 * sb->s_writers.frozen is protected by sb->s_umount. 1272 */ 1273 int freeze_super(struct super_block *sb) 1274 { 1275 int ret; 1276 1277 atomic_inc(&sb->s_active); 1278 down_write(&sb->s_umount); 1279 if (sb->s_writers.frozen != SB_UNFROZEN) { 1280 deactivate_locked_super(sb); 1281 return -EBUSY; 1282 } 1283 1284 if (!(sb->s_flags & MS_BORN)) { 1285 up_write(&sb->s_umount); 1286 return 0; /* sic - it's "nothing to do" */ 1287 } 1288 1289 if (sb->s_flags & MS_RDONLY) { 1290 /* Nothing to do really... */ 1291 sb->s_writers.frozen = SB_FREEZE_COMPLETE; 1292 up_write(&sb->s_umount); 1293 return 0; 1294 } 1295 1296 /* From now on, no new normal writers can start */ 1297 sb->s_writers.frozen = SB_FREEZE_WRITE; 1298 smp_wmb(); 1299 1300 /* Release s_umount to preserve sb_start_write -> s_umount ordering */ 1301 up_write(&sb->s_umount); 1302 1303 sb_wait_write(sb, SB_FREEZE_WRITE); 1304 1305 /* Now we go and block page faults... */ 1306 down_write(&sb->s_umount); 1307 sb->s_writers.frozen = SB_FREEZE_PAGEFAULT; 1308 smp_wmb(); 1309 1310 sb_wait_write(sb, SB_FREEZE_PAGEFAULT); 1311 1312 /* All writers are done so after syncing there won't be dirty data */ 1313 sync_filesystem(sb); 1314 1315 /* Now wait for internal filesystem counter */ 1316 sb->s_writers.frozen = SB_FREEZE_FS; 1317 smp_wmb(); 1318 sb_wait_write(sb, SB_FREEZE_FS); 1319 1320 if (sb->s_op->freeze_fs) { 1321 ret = sb->s_op->freeze_fs(sb); 1322 if (ret) { 1323 printk(KERN_ERR 1324 "VFS:Filesystem freeze failed\n"); 1325 sb->s_writers.frozen = SB_UNFROZEN; 1326 smp_wmb(); 1327 wake_up(&sb->s_writers.wait_unfrozen); 1328 deactivate_locked_super(sb); 1329 return ret; 1330 } 1331 } 1332 /* 1333 * This is just for debugging purposes so that fs can warn if it 1334 * sees write activity when frozen is set to SB_FREEZE_COMPLETE. 1335 */ 1336 sb->s_writers.frozen = SB_FREEZE_COMPLETE; 1337 up_write(&sb->s_umount); 1338 return 0; 1339 } 1340 EXPORT_SYMBOL(freeze_super); 1341 1342 /** 1343 * thaw_super -- unlock filesystem 1344 * @sb: the super to thaw 1345 * 1346 * Unlocks the filesystem and marks it writeable again after freeze_super(). 1347 */ 1348 int thaw_super(struct super_block *sb) 1349 { 1350 int error; 1351 1352 down_write(&sb->s_umount); 1353 if (sb->s_writers.frozen == SB_UNFROZEN) { 1354 up_write(&sb->s_umount); 1355 return -EINVAL; 1356 } 1357 1358 if (sb->s_flags & MS_RDONLY) 1359 goto out; 1360 1361 if (sb->s_op->unfreeze_fs) { 1362 error = sb->s_op->unfreeze_fs(sb); 1363 if (error) { 1364 printk(KERN_ERR 1365 "VFS:Filesystem thaw failed\n"); 1366 up_write(&sb->s_umount); 1367 return error; 1368 } 1369 } 1370 1371 out: 1372 sb->s_writers.frozen = SB_UNFROZEN; 1373 smp_wmb(); 1374 wake_up(&sb->s_writers.wait_unfrozen); 1375 deactivate_locked_super(sb); 1376 1377 return 0; 1378 } 1379 EXPORT_SYMBOL(thaw_super); 1380