1 /* 2 * Copyright (C) 2007 Oracle. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public 6 * License v2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this program; if not, write to the 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 16 * Boston, MA 021110-1307, USA. 17 */ 18 19 #include <linux/blkdev.h> 20 #include <linux/module.h> 21 #include <linux/buffer_head.h> 22 #include <linux/fs.h> 23 #include <linux/pagemap.h> 24 #include <linux/highmem.h> 25 #include <linux/time.h> 26 #include <linux/init.h> 27 #include <linux/seq_file.h> 28 #include <linux/string.h> 29 #include <linux/backing-dev.h> 30 #include <linux/mount.h> 31 #include <linux/mpage.h> 32 #include <linux/swap.h> 33 #include <linux/writeback.h> 34 #include <linux/statfs.h> 35 #include <linux/compat.h> 36 #include <linux/parser.h> 37 #include <linux/ctype.h> 38 #include <linux/namei.h> 39 #include <linux/miscdevice.h> 40 #include <linux/magic.h> 41 #include <linux/slab.h> 42 #include "compat.h" 43 #include "ctree.h" 44 #include "disk-io.h" 45 #include "transaction.h" 46 #include "btrfs_inode.h" 47 #include "ioctl.h" 48 #include "print-tree.h" 49 #include "xattr.h" 50 #include "volumes.h" 51 #include "version.h" 52 #include "export.h" 53 #include "compression.h" 54 55 static const struct super_operations btrfs_super_ops; 56 57 static void btrfs_put_super(struct super_block *sb) 58 { 59 struct btrfs_root *root = btrfs_sb(sb); 60 int ret; 61 62 ret = close_ctree(root); 63 sb->s_fs_info = NULL; 64 65 (void)ret; /* FIXME: need to fix VFS to return error? */ 66 } 67 68 enum { 69 Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum, 70 Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd, 71 Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress, 72 Opt_compress_force, Opt_notreelog, Opt_ratio, Opt_flushoncommit, 73 Opt_discard, Opt_space_cache, Opt_clear_cache, Opt_err, 74 Opt_user_subvol_rm_allowed, 75 }; 76 77 static match_table_t tokens = { 78 {Opt_degraded, "degraded"}, 79 {Opt_subvol, "subvol=%s"}, 80 {Opt_subvolid, "subvolid=%d"}, 81 {Opt_device, "device=%s"}, 82 {Opt_nodatasum, "nodatasum"}, 83 {Opt_nodatacow, "nodatacow"}, 84 {Opt_nobarrier, "nobarrier"}, 85 {Opt_max_inline, "max_inline=%s"}, 86 {Opt_alloc_start, "alloc_start=%s"}, 87 {Opt_thread_pool, "thread_pool=%d"}, 88 {Opt_compress, "compress"}, 89 {Opt_compress_force, "compress-force"}, 90 {Opt_ssd, "ssd"}, 91 {Opt_ssd_spread, "ssd_spread"}, 92 {Opt_nossd, "nossd"}, 93 {Opt_noacl, "noacl"}, 94 {Opt_notreelog, "notreelog"}, 95 {Opt_flushoncommit, "flushoncommit"}, 96 {Opt_ratio, "metadata_ratio=%d"}, 97 {Opt_discard, "discard"}, 98 {Opt_space_cache, "space_cache"}, 99 {Opt_clear_cache, "clear_cache"}, 100 {Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"}, 101 {Opt_err, NULL}, 102 }; 103 104 /* 105 * Regular mount options parser. Everything that is needed only when 106 * reading in a new superblock is parsed here. 107 */ 108 int btrfs_parse_options(struct btrfs_root *root, char *options) 109 { 110 struct btrfs_fs_info *info = root->fs_info; 111 substring_t args[MAX_OPT_ARGS]; 112 char *p, *num, *orig; 113 int intarg; 114 int ret = 0; 115 116 if (!options) 117 return 0; 118 119 /* 120 * strsep changes the string, duplicate it because parse_options 121 * gets called twice 122 */ 123 options = kstrdup(options, GFP_NOFS); 124 if (!options) 125 return -ENOMEM; 126 127 orig = options; 128 129 while ((p = strsep(&options, ",")) != NULL) { 130 int token; 131 if (!*p) 132 continue; 133 134 token = match_token(p, tokens, args); 135 switch (token) { 136 case Opt_degraded: 137 printk(KERN_INFO "btrfs: allowing degraded mounts\n"); 138 btrfs_set_opt(info->mount_opt, DEGRADED); 139 break; 140 case Opt_subvol: 141 case Opt_subvolid: 142 case Opt_device: 143 /* 144 * These are parsed by btrfs_parse_early_options 145 * and can be happily ignored here. 146 */ 147 break; 148 case Opt_nodatasum: 149 printk(KERN_INFO "btrfs: setting nodatasum\n"); 150 btrfs_set_opt(info->mount_opt, NODATASUM); 151 break; 152 case Opt_nodatacow: 153 printk(KERN_INFO "btrfs: setting nodatacow\n"); 154 btrfs_set_opt(info->mount_opt, NODATACOW); 155 btrfs_set_opt(info->mount_opt, NODATASUM); 156 break; 157 case Opt_compress: 158 printk(KERN_INFO "btrfs: use compression\n"); 159 btrfs_set_opt(info->mount_opt, COMPRESS); 160 break; 161 case Opt_compress_force: 162 printk(KERN_INFO "btrfs: forcing compression\n"); 163 btrfs_set_opt(info->mount_opt, FORCE_COMPRESS); 164 btrfs_set_opt(info->mount_opt, COMPRESS); 165 break; 166 case Opt_ssd: 167 printk(KERN_INFO "btrfs: use ssd allocation scheme\n"); 168 btrfs_set_opt(info->mount_opt, SSD); 169 break; 170 case Opt_ssd_spread: 171 printk(KERN_INFO "btrfs: use spread ssd " 172 "allocation scheme\n"); 173 btrfs_set_opt(info->mount_opt, SSD); 174 btrfs_set_opt(info->mount_opt, SSD_SPREAD); 175 break; 176 case Opt_nossd: 177 printk(KERN_INFO "btrfs: not using ssd allocation " 178 "scheme\n"); 179 btrfs_set_opt(info->mount_opt, NOSSD); 180 btrfs_clear_opt(info->mount_opt, SSD); 181 btrfs_clear_opt(info->mount_opt, SSD_SPREAD); 182 break; 183 case Opt_nobarrier: 184 printk(KERN_INFO "btrfs: turning off barriers\n"); 185 btrfs_set_opt(info->mount_opt, NOBARRIER); 186 break; 187 case Opt_thread_pool: 188 intarg = 0; 189 match_int(&args[0], &intarg); 190 if (intarg) { 191 info->thread_pool_size = intarg; 192 printk(KERN_INFO "btrfs: thread pool %d\n", 193 info->thread_pool_size); 194 } 195 break; 196 case Opt_max_inline: 197 num = match_strdup(&args[0]); 198 if (num) { 199 info->max_inline = memparse(num, NULL); 200 kfree(num); 201 202 if (info->max_inline) { 203 info->max_inline = max_t(u64, 204 info->max_inline, 205 root->sectorsize); 206 } 207 printk(KERN_INFO "btrfs: max_inline at %llu\n", 208 (unsigned long long)info->max_inline); 209 } 210 break; 211 case Opt_alloc_start: 212 num = match_strdup(&args[0]); 213 if (num) { 214 info->alloc_start = memparse(num, NULL); 215 kfree(num); 216 printk(KERN_INFO 217 "btrfs: allocations start at %llu\n", 218 (unsigned long long)info->alloc_start); 219 } 220 break; 221 case Opt_noacl: 222 root->fs_info->sb->s_flags &= ~MS_POSIXACL; 223 break; 224 case Opt_notreelog: 225 printk(KERN_INFO "btrfs: disabling tree log\n"); 226 btrfs_set_opt(info->mount_opt, NOTREELOG); 227 break; 228 case Opt_flushoncommit: 229 printk(KERN_INFO "btrfs: turning on flush-on-commit\n"); 230 btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT); 231 break; 232 case Opt_ratio: 233 intarg = 0; 234 match_int(&args[0], &intarg); 235 if (intarg) { 236 info->metadata_ratio = intarg; 237 printk(KERN_INFO "btrfs: metadata ratio %d\n", 238 info->metadata_ratio); 239 } 240 break; 241 case Opt_discard: 242 btrfs_set_opt(info->mount_opt, DISCARD); 243 break; 244 case Opt_space_cache: 245 printk(KERN_INFO "btrfs: enabling disk space caching\n"); 246 btrfs_set_opt(info->mount_opt, SPACE_CACHE); 247 case Opt_clear_cache: 248 printk(KERN_INFO "btrfs: force clearing of disk cache\n"); 249 btrfs_set_opt(info->mount_opt, CLEAR_CACHE); 250 break; 251 case Opt_user_subvol_rm_allowed: 252 btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED); 253 break; 254 case Opt_err: 255 printk(KERN_INFO "btrfs: unrecognized mount option " 256 "'%s'\n", p); 257 ret = -EINVAL; 258 goto out; 259 default: 260 break; 261 } 262 } 263 out: 264 kfree(orig); 265 return ret; 266 } 267 268 /* 269 * Parse mount options that are required early in the mount process. 270 * 271 * All other options will be parsed on much later in the mount process and 272 * only when we need to allocate a new super block. 273 */ 274 static int btrfs_parse_early_options(const char *options, fmode_t flags, 275 void *holder, char **subvol_name, u64 *subvol_objectid, 276 struct btrfs_fs_devices **fs_devices) 277 { 278 substring_t args[MAX_OPT_ARGS]; 279 char *opts, *p; 280 int error = 0; 281 int intarg; 282 283 if (!options) 284 goto out; 285 286 /* 287 * strsep changes the string, duplicate it because parse_options 288 * gets called twice 289 */ 290 opts = kstrdup(options, GFP_KERNEL); 291 if (!opts) 292 return -ENOMEM; 293 294 while ((p = strsep(&opts, ",")) != NULL) { 295 int token; 296 if (!*p) 297 continue; 298 299 token = match_token(p, tokens, args); 300 switch (token) { 301 case Opt_subvol: 302 *subvol_name = match_strdup(&args[0]); 303 break; 304 case Opt_subvolid: 305 intarg = 0; 306 error = match_int(&args[0], &intarg); 307 if (!error) { 308 /* we want the original fs_tree */ 309 if (!intarg) 310 *subvol_objectid = 311 BTRFS_FS_TREE_OBJECTID; 312 else 313 *subvol_objectid = intarg; 314 } 315 break; 316 case Opt_device: 317 error = btrfs_scan_one_device(match_strdup(&args[0]), 318 flags, holder, fs_devices); 319 if (error) 320 goto out_free_opts; 321 break; 322 default: 323 break; 324 } 325 } 326 327 out_free_opts: 328 kfree(opts); 329 out: 330 /* 331 * If no subvolume name is specified we use the default one. Allocate 332 * a copy of the string "." here so that code later in the 333 * mount path doesn't care if it's the default volume or another one. 334 */ 335 if (!*subvol_name) { 336 *subvol_name = kstrdup(".", GFP_KERNEL); 337 if (!*subvol_name) 338 return -ENOMEM; 339 } 340 return error; 341 } 342 343 static struct dentry *get_default_root(struct super_block *sb, 344 u64 subvol_objectid) 345 { 346 struct btrfs_root *root = sb->s_fs_info; 347 struct btrfs_root *new_root; 348 struct btrfs_dir_item *di; 349 struct btrfs_path *path; 350 struct btrfs_key location; 351 struct inode *inode; 352 struct dentry *dentry; 353 u64 dir_id; 354 int new = 0; 355 356 /* 357 * We have a specific subvol we want to mount, just setup location and 358 * go look up the root. 359 */ 360 if (subvol_objectid) { 361 location.objectid = subvol_objectid; 362 location.type = BTRFS_ROOT_ITEM_KEY; 363 location.offset = (u64)-1; 364 goto find_root; 365 } 366 367 path = btrfs_alloc_path(); 368 if (!path) 369 return ERR_PTR(-ENOMEM); 370 path->leave_spinning = 1; 371 372 /* 373 * Find the "default" dir item which points to the root item that we 374 * will mount by default if we haven't been given a specific subvolume 375 * to mount. 376 */ 377 dir_id = btrfs_super_root_dir(&root->fs_info->super_copy); 378 di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0); 379 if (IS_ERR(di)) 380 return ERR_CAST(di); 381 if (!di) { 382 /* 383 * Ok the default dir item isn't there. This is weird since 384 * it's always been there, but don't freak out, just try and 385 * mount to root most subvolume. 386 */ 387 btrfs_free_path(path); 388 dir_id = BTRFS_FIRST_FREE_OBJECTID; 389 new_root = root->fs_info->fs_root; 390 goto setup_root; 391 } 392 393 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location); 394 btrfs_free_path(path); 395 396 find_root: 397 new_root = btrfs_read_fs_root_no_name(root->fs_info, &location); 398 if (IS_ERR(new_root)) 399 return ERR_CAST(new_root); 400 401 if (btrfs_root_refs(&new_root->root_item) == 0) 402 return ERR_PTR(-ENOENT); 403 404 dir_id = btrfs_root_dirid(&new_root->root_item); 405 setup_root: 406 location.objectid = dir_id; 407 location.type = BTRFS_INODE_ITEM_KEY; 408 location.offset = 0; 409 410 inode = btrfs_iget(sb, &location, new_root, &new); 411 if (IS_ERR(inode)) 412 return ERR_CAST(inode); 413 414 /* 415 * If we're just mounting the root most subvol put the inode and return 416 * a reference to the dentry. We will have already gotten a reference 417 * to the inode in btrfs_fill_super so we're good to go. 418 */ 419 if (!new && sb->s_root->d_inode == inode) { 420 iput(inode); 421 return dget(sb->s_root); 422 } 423 424 if (new) { 425 const struct qstr name = { .name = "/", .len = 1 }; 426 427 /* 428 * New inode, we need to make the dentry a sibling of s_root so 429 * everything gets cleaned up properly on unmount. 430 */ 431 dentry = d_alloc(sb->s_root, &name); 432 if (!dentry) { 433 iput(inode); 434 return ERR_PTR(-ENOMEM); 435 } 436 d_splice_alias(inode, dentry); 437 } else { 438 /* 439 * We found the inode in cache, just find a dentry for it and 440 * put the reference to the inode we just got. 441 */ 442 dentry = d_find_alias(inode); 443 iput(inode); 444 } 445 446 return dentry; 447 } 448 449 static int btrfs_fill_super(struct super_block *sb, 450 struct btrfs_fs_devices *fs_devices, 451 void *data, int silent) 452 { 453 struct inode *inode; 454 struct dentry *root_dentry; 455 struct btrfs_root *tree_root; 456 struct btrfs_key key; 457 int err; 458 459 sb->s_maxbytes = MAX_LFS_FILESIZE; 460 sb->s_magic = BTRFS_SUPER_MAGIC; 461 sb->s_op = &btrfs_super_ops; 462 sb->s_export_op = &btrfs_export_ops; 463 sb->s_xattr = btrfs_xattr_handlers; 464 sb->s_time_gran = 1; 465 #ifdef CONFIG_BTRFS_FS_POSIX_ACL 466 sb->s_flags |= MS_POSIXACL; 467 #endif 468 469 tree_root = open_ctree(sb, fs_devices, (char *)data); 470 471 if (IS_ERR(tree_root)) { 472 printk("btrfs: open_ctree failed\n"); 473 return PTR_ERR(tree_root); 474 } 475 sb->s_fs_info = tree_root; 476 477 key.objectid = BTRFS_FIRST_FREE_OBJECTID; 478 key.type = BTRFS_INODE_ITEM_KEY; 479 key.offset = 0; 480 inode = btrfs_iget(sb, &key, tree_root->fs_info->fs_root, NULL); 481 if (IS_ERR(inode)) { 482 err = PTR_ERR(inode); 483 goto fail_close; 484 } 485 486 root_dentry = d_alloc_root(inode); 487 if (!root_dentry) { 488 iput(inode); 489 err = -ENOMEM; 490 goto fail_close; 491 } 492 493 sb->s_root = root_dentry; 494 495 save_mount_options(sb, data); 496 return 0; 497 498 fail_close: 499 close_ctree(tree_root); 500 return err; 501 } 502 503 int btrfs_sync_fs(struct super_block *sb, int wait) 504 { 505 struct btrfs_trans_handle *trans; 506 struct btrfs_root *root = btrfs_sb(sb); 507 int ret; 508 509 if (!wait) { 510 filemap_flush(root->fs_info->btree_inode->i_mapping); 511 return 0; 512 } 513 514 btrfs_start_delalloc_inodes(root, 0); 515 btrfs_wait_ordered_extents(root, 0, 0); 516 517 trans = btrfs_start_transaction(root, 0); 518 ret = btrfs_commit_transaction(trans, root); 519 return ret; 520 } 521 522 static int btrfs_show_options(struct seq_file *seq, struct vfsmount *vfs) 523 { 524 struct btrfs_root *root = btrfs_sb(vfs->mnt_sb); 525 struct btrfs_fs_info *info = root->fs_info; 526 527 if (btrfs_test_opt(root, DEGRADED)) 528 seq_puts(seq, ",degraded"); 529 if (btrfs_test_opt(root, NODATASUM)) 530 seq_puts(seq, ",nodatasum"); 531 if (btrfs_test_opt(root, NODATACOW)) 532 seq_puts(seq, ",nodatacow"); 533 if (btrfs_test_opt(root, NOBARRIER)) 534 seq_puts(seq, ",nobarrier"); 535 if (info->max_inline != 8192 * 1024) 536 seq_printf(seq, ",max_inline=%llu", 537 (unsigned long long)info->max_inline); 538 if (info->alloc_start != 0) 539 seq_printf(seq, ",alloc_start=%llu", 540 (unsigned long long)info->alloc_start); 541 if (info->thread_pool_size != min_t(unsigned long, 542 num_online_cpus() + 2, 8)) 543 seq_printf(seq, ",thread_pool=%d", info->thread_pool_size); 544 if (btrfs_test_opt(root, COMPRESS)) 545 seq_puts(seq, ",compress"); 546 if (btrfs_test_opt(root, NOSSD)) 547 seq_puts(seq, ",nossd"); 548 if (btrfs_test_opt(root, SSD_SPREAD)) 549 seq_puts(seq, ",ssd_spread"); 550 else if (btrfs_test_opt(root, SSD)) 551 seq_puts(seq, ",ssd"); 552 if (btrfs_test_opt(root, NOTREELOG)) 553 seq_puts(seq, ",notreelog"); 554 if (btrfs_test_opt(root, FLUSHONCOMMIT)) 555 seq_puts(seq, ",flushoncommit"); 556 if (btrfs_test_opt(root, DISCARD)) 557 seq_puts(seq, ",discard"); 558 if (!(root->fs_info->sb->s_flags & MS_POSIXACL)) 559 seq_puts(seq, ",noacl"); 560 return 0; 561 } 562 563 static int btrfs_test_super(struct super_block *s, void *data) 564 { 565 struct btrfs_fs_devices *test_fs_devices = data; 566 struct btrfs_root *root = btrfs_sb(s); 567 568 return root->fs_info->fs_devices == test_fs_devices; 569 } 570 571 /* 572 * Find a superblock for the given device / mount point. 573 * 574 * Note: This is based on get_sb_bdev from fs/super.c with a few additions 575 * for multiple device setup. Make sure to keep it in sync. 576 */ 577 static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, 578 const char *dev_name, void *data) 579 { 580 struct block_device *bdev = NULL; 581 struct super_block *s; 582 struct dentry *root; 583 struct btrfs_fs_devices *fs_devices = NULL; 584 fmode_t mode = FMODE_READ; 585 char *subvol_name = NULL; 586 u64 subvol_objectid = 0; 587 int error = 0; 588 589 if (!(flags & MS_RDONLY)) 590 mode |= FMODE_WRITE; 591 592 error = btrfs_parse_early_options(data, mode, fs_type, 593 &subvol_name, &subvol_objectid, 594 &fs_devices); 595 if (error) 596 return ERR_PTR(error); 597 598 error = btrfs_scan_one_device(dev_name, mode, fs_type, &fs_devices); 599 if (error) 600 goto error_free_subvol_name; 601 602 error = btrfs_open_devices(fs_devices, mode, fs_type); 603 if (error) 604 goto error_free_subvol_name; 605 606 if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) { 607 error = -EACCES; 608 goto error_close_devices; 609 } 610 611 bdev = fs_devices->latest_bdev; 612 s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices); 613 if (IS_ERR(s)) 614 goto error_s; 615 616 if (s->s_root) { 617 if ((flags ^ s->s_flags) & MS_RDONLY) { 618 deactivate_locked_super(s); 619 error = -EBUSY; 620 goto error_close_devices; 621 } 622 623 btrfs_close_devices(fs_devices); 624 } else { 625 char b[BDEVNAME_SIZE]; 626 627 s->s_flags = flags; 628 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id)); 629 error = btrfs_fill_super(s, fs_devices, data, 630 flags & MS_SILENT ? 1 : 0); 631 if (error) { 632 deactivate_locked_super(s); 633 goto error_free_subvol_name; 634 } 635 636 btrfs_sb(s)->fs_info->bdev_holder = fs_type; 637 s->s_flags |= MS_ACTIVE; 638 } 639 640 root = get_default_root(s, subvol_objectid); 641 if (IS_ERR(root)) { 642 error = PTR_ERR(root); 643 deactivate_locked_super(s); 644 goto error_free_subvol_name; 645 } 646 /* if they gave us a subvolume name bind mount into that */ 647 if (strcmp(subvol_name, ".")) { 648 struct dentry *new_root; 649 mutex_lock(&root->d_inode->i_mutex); 650 new_root = lookup_one_len(subvol_name, root, 651 strlen(subvol_name)); 652 mutex_unlock(&root->d_inode->i_mutex); 653 654 if (IS_ERR(new_root)) { 655 deactivate_locked_super(s); 656 error = PTR_ERR(new_root); 657 dput(root); 658 goto error_free_subvol_name; 659 } 660 if (!new_root->d_inode) { 661 dput(root); 662 dput(new_root); 663 deactivate_locked_super(s); 664 error = -ENXIO; 665 goto error_free_subvol_name; 666 } 667 dput(root); 668 root = new_root; 669 } 670 671 kfree(subvol_name); 672 return root; 673 674 error_s: 675 error = PTR_ERR(s); 676 error_close_devices: 677 btrfs_close_devices(fs_devices); 678 error_free_subvol_name: 679 kfree(subvol_name); 680 return ERR_PTR(error); 681 } 682 683 static int btrfs_remount(struct super_block *sb, int *flags, char *data) 684 { 685 struct btrfs_root *root = btrfs_sb(sb); 686 int ret; 687 688 ret = btrfs_parse_options(root, data); 689 if (ret) 690 return -EINVAL; 691 692 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) 693 return 0; 694 695 if (*flags & MS_RDONLY) { 696 sb->s_flags |= MS_RDONLY; 697 698 ret = btrfs_commit_super(root); 699 WARN_ON(ret); 700 } else { 701 if (root->fs_info->fs_devices->rw_devices == 0) 702 return -EACCES; 703 704 if (btrfs_super_log_root(&root->fs_info->super_copy) != 0) 705 return -EINVAL; 706 707 ret = btrfs_cleanup_fs_roots(root->fs_info); 708 WARN_ON(ret); 709 710 /* recover relocation */ 711 ret = btrfs_recover_relocation(root); 712 WARN_ON(ret); 713 714 sb->s_flags &= ~MS_RDONLY; 715 } 716 717 return 0; 718 } 719 720 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf) 721 { 722 struct btrfs_root *root = btrfs_sb(dentry->d_sb); 723 struct btrfs_super_block *disk_super = &root->fs_info->super_copy; 724 struct list_head *head = &root->fs_info->space_info; 725 struct btrfs_space_info *found; 726 u64 total_used = 0; 727 u64 total_used_data = 0; 728 int bits = dentry->d_sb->s_blocksize_bits; 729 __be32 *fsid = (__be32 *)root->fs_info->fsid; 730 731 rcu_read_lock(); 732 list_for_each_entry_rcu(found, head, list) { 733 if (found->flags & (BTRFS_BLOCK_GROUP_METADATA | 734 BTRFS_BLOCK_GROUP_SYSTEM)) 735 total_used_data += found->disk_total; 736 else 737 total_used_data += found->disk_used; 738 total_used += found->disk_used; 739 } 740 rcu_read_unlock(); 741 742 buf->f_namelen = BTRFS_NAME_LEN; 743 buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits; 744 buf->f_bfree = buf->f_blocks - (total_used >> bits); 745 buf->f_bavail = buf->f_blocks - (total_used_data >> bits); 746 buf->f_bsize = dentry->d_sb->s_blocksize; 747 buf->f_type = BTRFS_SUPER_MAGIC; 748 749 /* We treat it as constant endianness (it doesn't matter _which_) 750 because we want the fsid to come out the same whether mounted 751 on a big-endian or little-endian host */ 752 buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]); 753 buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]); 754 /* Mask in the root object ID too, to disambiguate subvols */ 755 buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32; 756 buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid; 757 758 return 0; 759 } 760 761 static struct file_system_type btrfs_fs_type = { 762 .owner = THIS_MODULE, 763 .name = "btrfs", 764 .mount = btrfs_mount, 765 .kill_sb = kill_anon_super, 766 .fs_flags = FS_REQUIRES_DEV, 767 }; 768 769 /* 770 * used by btrfsctl to scan devices when no FS is mounted 771 */ 772 static long btrfs_control_ioctl(struct file *file, unsigned int cmd, 773 unsigned long arg) 774 { 775 struct btrfs_ioctl_vol_args *vol; 776 struct btrfs_fs_devices *fs_devices; 777 int ret = -ENOTTY; 778 779 if (!capable(CAP_SYS_ADMIN)) 780 return -EPERM; 781 782 vol = memdup_user((void __user *)arg, sizeof(*vol)); 783 if (IS_ERR(vol)) 784 return PTR_ERR(vol); 785 786 switch (cmd) { 787 case BTRFS_IOC_SCAN_DEV: 788 ret = btrfs_scan_one_device(vol->name, FMODE_READ, 789 &btrfs_fs_type, &fs_devices); 790 break; 791 } 792 793 kfree(vol); 794 return ret; 795 } 796 797 static int btrfs_freeze(struct super_block *sb) 798 { 799 struct btrfs_root *root = btrfs_sb(sb); 800 mutex_lock(&root->fs_info->transaction_kthread_mutex); 801 mutex_lock(&root->fs_info->cleaner_mutex); 802 return 0; 803 } 804 805 static int btrfs_unfreeze(struct super_block *sb) 806 { 807 struct btrfs_root *root = btrfs_sb(sb); 808 mutex_unlock(&root->fs_info->cleaner_mutex); 809 mutex_unlock(&root->fs_info->transaction_kthread_mutex); 810 return 0; 811 } 812 813 static const struct super_operations btrfs_super_ops = { 814 .drop_inode = btrfs_drop_inode, 815 .evict_inode = btrfs_evict_inode, 816 .put_super = btrfs_put_super, 817 .sync_fs = btrfs_sync_fs, 818 .show_options = btrfs_show_options, 819 .write_inode = btrfs_write_inode, 820 .dirty_inode = btrfs_dirty_inode, 821 .alloc_inode = btrfs_alloc_inode, 822 .destroy_inode = btrfs_destroy_inode, 823 .statfs = btrfs_statfs, 824 .remount_fs = btrfs_remount, 825 .freeze_fs = btrfs_freeze, 826 .unfreeze_fs = btrfs_unfreeze, 827 }; 828 829 static const struct file_operations btrfs_ctl_fops = { 830 .unlocked_ioctl = btrfs_control_ioctl, 831 .compat_ioctl = btrfs_control_ioctl, 832 .owner = THIS_MODULE, 833 .llseek = noop_llseek, 834 }; 835 836 static struct miscdevice btrfs_misc = { 837 .minor = BTRFS_MINOR, 838 .name = "btrfs-control", 839 .fops = &btrfs_ctl_fops 840 }; 841 842 MODULE_ALIAS_MISCDEV(BTRFS_MINOR); 843 MODULE_ALIAS("devname:btrfs-control"); 844 845 static int btrfs_interface_init(void) 846 { 847 return misc_register(&btrfs_misc); 848 } 849 850 static void btrfs_interface_exit(void) 851 { 852 if (misc_deregister(&btrfs_misc) < 0) 853 printk(KERN_INFO "misc_deregister failed for control device"); 854 } 855 856 static int __init init_btrfs_fs(void) 857 { 858 int err; 859 860 err = btrfs_init_sysfs(); 861 if (err) 862 return err; 863 864 err = btrfs_init_cachep(); 865 if (err) 866 goto free_sysfs; 867 868 err = extent_io_init(); 869 if (err) 870 goto free_cachep; 871 872 err = extent_map_init(); 873 if (err) 874 goto free_extent_io; 875 876 err = btrfs_interface_init(); 877 if (err) 878 goto free_extent_map; 879 880 err = register_filesystem(&btrfs_fs_type); 881 if (err) 882 goto unregister_ioctl; 883 884 printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION); 885 return 0; 886 887 unregister_ioctl: 888 btrfs_interface_exit(); 889 free_extent_map: 890 extent_map_exit(); 891 free_extent_io: 892 extent_io_exit(); 893 free_cachep: 894 btrfs_destroy_cachep(); 895 free_sysfs: 896 btrfs_exit_sysfs(); 897 return err; 898 } 899 900 static void __exit exit_btrfs_fs(void) 901 { 902 btrfs_destroy_cachep(); 903 extent_map_exit(); 904 extent_io_exit(); 905 btrfs_interface_exit(); 906 unregister_filesystem(&btrfs_fs_type); 907 btrfs_exit_sysfs(); 908 btrfs_cleanup_fs_uuids(); 909 btrfs_zlib_exit(); 910 } 911 912 module_init(init_btrfs_fs) 913 module_exit(exit_btrfs_fs) 914 915 MODULE_LICENSE("GPL"); 916