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