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 <linux/cleancache.h> 43 #include <linux/ratelimit.h> 44 #include <linux/btrfs.h> 45 #include "delayed-inode.h" 46 #include "ctree.h" 47 #include "disk-io.h" 48 #include "transaction.h" 49 #include "btrfs_inode.h" 50 #include "print-tree.h" 51 #include "hash.h" 52 #include "props.h" 53 #include "xattr.h" 54 #include "volumes.h" 55 #include "export.h" 56 #include "compression.h" 57 #include "rcu-string.h" 58 #include "dev-replace.h" 59 #include "free-space-cache.h" 60 #include "backref.h" 61 #include "tests/btrfs-tests.h" 62 63 #include "qgroup.h" 64 #define CREATE_TRACE_POINTS 65 #include <trace/events/btrfs.h> 66 67 static const struct super_operations btrfs_super_ops; 68 static struct file_system_type btrfs_fs_type; 69 70 static int btrfs_remount(struct super_block *sb, int *flags, char *data); 71 72 const char *btrfs_decode_error(int errno) 73 { 74 char *errstr = "unknown"; 75 76 switch (errno) { 77 case -EIO: 78 errstr = "IO failure"; 79 break; 80 case -ENOMEM: 81 errstr = "Out of memory"; 82 break; 83 case -EROFS: 84 errstr = "Readonly filesystem"; 85 break; 86 case -EEXIST: 87 errstr = "Object already exists"; 88 break; 89 case -ENOSPC: 90 errstr = "No space left"; 91 break; 92 case -ENOENT: 93 errstr = "No such entry"; 94 break; 95 } 96 97 return errstr; 98 } 99 100 static void save_error_info(struct btrfs_fs_info *fs_info) 101 { 102 /* 103 * today we only save the error info into ram. Long term we'll 104 * also send it down to the disk 105 */ 106 set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state); 107 } 108 109 /* btrfs handle error by forcing the filesystem readonly */ 110 static void btrfs_handle_error(struct btrfs_fs_info *fs_info) 111 { 112 struct super_block *sb = fs_info->sb; 113 114 if (sb->s_flags & MS_RDONLY) 115 return; 116 117 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 118 sb->s_flags |= MS_RDONLY; 119 btrfs_info(fs_info, "forced readonly"); 120 /* 121 * Note that a running device replace operation is not 122 * canceled here although there is no way to update 123 * the progress. It would add the risk of a deadlock, 124 * therefore the canceling is ommited. The only penalty 125 * is that some I/O remains active until the procedure 126 * completes. The next time when the filesystem is 127 * mounted writeable again, the device replace 128 * operation continues. 129 */ 130 } 131 } 132 133 /* 134 * __btrfs_std_error decodes expected errors from the caller and 135 * invokes the approciate error response. 136 */ 137 __cold 138 void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function, 139 unsigned int line, int errno, const char *fmt, ...) 140 { 141 struct super_block *sb = fs_info->sb; 142 #ifdef CONFIG_PRINTK 143 const char *errstr; 144 #endif 145 146 /* 147 * Special case: if the error is EROFS, and we're already 148 * under MS_RDONLY, then it is safe here. 149 */ 150 if (errno == -EROFS && (sb->s_flags & MS_RDONLY)) 151 return; 152 153 #ifdef CONFIG_PRINTK 154 errstr = btrfs_decode_error(errno); 155 if (fmt) { 156 struct va_format vaf; 157 va_list args; 158 159 va_start(args, fmt); 160 vaf.fmt = fmt; 161 vaf.va = &args; 162 163 printk(KERN_CRIT 164 "BTRFS: error (device %s) in %s:%d: errno=%d %s (%pV)\n", 165 sb->s_id, function, line, errno, errstr, &vaf); 166 va_end(args); 167 } else { 168 printk(KERN_CRIT "BTRFS: error (device %s) in %s:%d: errno=%d %s\n", 169 sb->s_id, function, line, errno, errstr); 170 } 171 #endif 172 173 /* Don't go through full error handling during mount */ 174 save_error_info(fs_info); 175 if (sb->s_flags & MS_BORN) 176 btrfs_handle_error(fs_info); 177 } 178 179 #ifdef CONFIG_PRINTK 180 static const char * const logtypes[] = { 181 "emergency", 182 "alert", 183 "critical", 184 "error", 185 "warning", 186 "notice", 187 "info", 188 "debug", 189 }; 190 191 void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...) 192 { 193 struct super_block *sb = fs_info->sb; 194 char lvl[4]; 195 struct va_format vaf; 196 va_list args; 197 const char *type = logtypes[4]; 198 int kern_level; 199 200 va_start(args, fmt); 201 202 kern_level = printk_get_level(fmt); 203 if (kern_level) { 204 size_t size = printk_skip_level(fmt) - fmt; 205 memcpy(lvl, fmt, size); 206 lvl[size] = '\0'; 207 fmt += size; 208 type = logtypes[kern_level - '0']; 209 } else 210 *lvl = '\0'; 211 212 vaf.fmt = fmt; 213 vaf.va = &args; 214 215 printk("%sBTRFS %s (device %s): %pV\n", lvl, type, sb->s_id, &vaf); 216 217 va_end(args); 218 } 219 #endif 220 221 /* 222 * We only mark the transaction aborted and then set the file system read-only. 223 * This will prevent new transactions from starting or trying to join this 224 * one. 225 * 226 * This means that error recovery at the call site is limited to freeing 227 * any local memory allocations and passing the error code up without 228 * further cleanup. The transaction should complete as it normally would 229 * in the call path but will return -EIO. 230 * 231 * We'll complete the cleanup in btrfs_end_transaction and 232 * btrfs_commit_transaction. 233 */ 234 __cold 235 void __btrfs_abort_transaction(struct btrfs_trans_handle *trans, 236 struct btrfs_root *root, const char *function, 237 unsigned int line, int errno) 238 { 239 trans->aborted = errno; 240 /* Nothing used. The other threads that have joined this 241 * transaction may be able to continue. */ 242 if (!trans->blocks_used && list_empty(&trans->new_bgs)) { 243 const char *errstr; 244 245 errstr = btrfs_decode_error(errno); 246 btrfs_warn(root->fs_info, 247 "%s:%d: Aborting unused transaction(%s).", 248 function, line, errstr); 249 return; 250 } 251 ACCESS_ONCE(trans->transaction->aborted) = errno; 252 /* Wake up anybody who may be waiting on this transaction */ 253 wake_up(&root->fs_info->transaction_wait); 254 wake_up(&root->fs_info->transaction_blocked_wait); 255 __btrfs_std_error(root->fs_info, function, line, errno, NULL); 256 } 257 /* 258 * __btrfs_panic decodes unexpected, fatal errors from the caller, 259 * issues an alert, and either panics or BUGs, depending on mount options. 260 */ 261 __cold 262 void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function, 263 unsigned int line, int errno, const char *fmt, ...) 264 { 265 char *s_id = "<unknown>"; 266 const char *errstr; 267 struct va_format vaf = { .fmt = fmt }; 268 va_list args; 269 270 if (fs_info) 271 s_id = fs_info->sb->s_id; 272 273 va_start(args, fmt); 274 vaf.va = &args; 275 276 errstr = btrfs_decode_error(errno); 277 if (fs_info && (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR)) 278 panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n", 279 s_id, function, line, &vaf, errno, errstr); 280 281 btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)", 282 function, line, &vaf, errno, errstr); 283 va_end(args); 284 /* Caller calls BUG() */ 285 } 286 287 static void btrfs_put_super(struct super_block *sb) 288 { 289 close_ctree(btrfs_sb(sb)->tree_root); 290 } 291 292 enum { 293 Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum, 294 Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd, 295 Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress, 296 Opt_compress_type, Opt_compress_force, Opt_compress_force_type, 297 Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard, 298 Opt_space_cache, Opt_space_cache_version, Opt_clear_cache, 299 Opt_user_subvol_rm_allowed, Opt_enospc_debug, Opt_subvolrootid, 300 Opt_defrag, Opt_inode_cache, Opt_no_space_cache, Opt_recovery, 301 Opt_skip_balance, Opt_check_integrity, 302 Opt_check_integrity_including_extent_data, 303 Opt_check_integrity_print_mask, Opt_fatal_errors, Opt_rescan_uuid_tree, 304 Opt_commit_interval, Opt_barrier, Opt_nodefrag, Opt_nodiscard, 305 Opt_noenospc_debug, Opt_noflushoncommit, Opt_acl, Opt_datacow, 306 Opt_datasum, Opt_treelog, Opt_noinode_cache, 307 #ifdef CONFIG_BTRFS_DEBUG 308 Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all, 309 #endif 310 Opt_err, 311 }; 312 313 static const match_table_t tokens = { 314 {Opt_degraded, "degraded"}, 315 {Opt_subvol, "subvol=%s"}, 316 {Opt_subvolid, "subvolid=%s"}, 317 {Opt_device, "device=%s"}, 318 {Opt_nodatasum, "nodatasum"}, 319 {Opt_datasum, "datasum"}, 320 {Opt_nodatacow, "nodatacow"}, 321 {Opt_datacow, "datacow"}, 322 {Opt_nobarrier, "nobarrier"}, 323 {Opt_barrier, "barrier"}, 324 {Opt_max_inline, "max_inline=%s"}, 325 {Opt_alloc_start, "alloc_start=%s"}, 326 {Opt_thread_pool, "thread_pool=%d"}, 327 {Opt_compress, "compress"}, 328 {Opt_compress_type, "compress=%s"}, 329 {Opt_compress_force, "compress-force"}, 330 {Opt_compress_force_type, "compress-force=%s"}, 331 {Opt_ssd, "ssd"}, 332 {Opt_ssd_spread, "ssd_spread"}, 333 {Opt_nossd, "nossd"}, 334 {Opt_acl, "acl"}, 335 {Opt_noacl, "noacl"}, 336 {Opt_notreelog, "notreelog"}, 337 {Opt_treelog, "treelog"}, 338 {Opt_flushoncommit, "flushoncommit"}, 339 {Opt_noflushoncommit, "noflushoncommit"}, 340 {Opt_ratio, "metadata_ratio=%d"}, 341 {Opt_discard, "discard"}, 342 {Opt_nodiscard, "nodiscard"}, 343 {Opt_space_cache, "space_cache"}, 344 {Opt_space_cache_version, "space_cache=%s"}, 345 {Opt_clear_cache, "clear_cache"}, 346 {Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"}, 347 {Opt_enospc_debug, "enospc_debug"}, 348 {Opt_noenospc_debug, "noenospc_debug"}, 349 {Opt_subvolrootid, "subvolrootid=%d"}, 350 {Opt_defrag, "autodefrag"}, 351 {Opt_nodefrag, "noautodefrag"}, 352 {Opt_inode_cache, "inode_cache"}, 353 {Opt_noinode_cache, "noinode_cache"}, 354 {Opt_no_space_cache, "nospace_cache"}, 355 {Opt_recovery, "recovery"}, 356 {Opt_skip_balance, "skip_balance"}, 357 {Opt_check_integrity, "check_int"}, 358 {Opt_check_integrity_including_extent_data, "check_int_data"}, 359 {Opt_check_integrity_print_mask, "check_int_print_mask=%d"}, 360 {Opt_rescan_uuid_tree, "rescan_uuid_tree"}, 361 {Opt_fatal_errors, "fatal_errors=%s"}, 362 {Opt_commit_interval, "commit=%d"}, 363 #ifdef CONFIG_BTRFS_DEBUG 364 {Opt_fragment_data, "fragment=data"}, 365 {Opt_fragment_metadata, "fragment=metadata"}, 366 {Opt_fragment_all, "fragment=all"}, 367 #endif 368 {Opt_err, NULL}, 369 }; 370 371 /* 372 * Regular mount options parser. Everything that is needed only when 373 * reading in a new superblock is parsed here. 374 * XXX JDM: This needs to be cleaned up for remount. 375 */ 376 int btrfs_parse_options(struct btrfs_root *root, char *options) 377 { 378 struct btrfs_fs_info *info = root->fs_info; 379 substring_t args[MAX_OPT_ARGS]; 380 char *p, *num, *orig = NULL; 381 u64 cache_gen; 382 int intarg; 383 int ret = 0; 384 char *compress_type; 385 bool compress_force = false; 386 enum btrfs_compression_type saved_compress_type; 387 bool saved_compress_force; 388 int no_compress = 0; 389 390 cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy); 391 if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE)) 392 btrfs_set_opt(info->mount_opt, FREE_SPACE_TREE); 393 else if (cache_gen) 394 btrfs_set_opt(info->mount_opt, SPACE_CACHE); 395 396 if (!options) 397 goto out; 398 399 /* 400 * strsep changes the string, duplicate it because parse_options 401 * gets called twice 402 */ 403 options = kstrdup(options, GFP_NOFS); 404 if (!options) 405 return -ENOMEM; 406 407 orig = options; 408 409 while ((p = strsep(&options, ",")) != NULL) { 410 int token; 411 if (!*p) 412 continue; 413 414 token = match_token(p, tokens, args); 415 switch (token) { 416 case Opt_degraded: 417 btrfs_info(root->fs_info, "allowing degraded mounts"); 418 btrfs_set_opt(info->mount_opt, DEGRADED); 419 break; 420 case Opt_subvol: 421 case Opt_subvolid: 422 case Opt_subvolrootid: 423 case Opt_device: 424 /* 425 * These are parsed by btrfs_parse_early_options 426 * and can be happily ignored here. 427 */ 428 break; 429 case Opt_nodatasum: 430 btrfs_set_and_info(root, NODATASUM, 431 "setting nodatasum"); 432 break; 433 case Opt_datasum: 434 if (btrfs_test_opt(root, NODATASUM)) { 435 if (btrfs_test_opt(root, NODATACOW)) 436 btrfs_info(root->fs_info, "setting datasum, datacow enabled"); 437 else 438 btrfs_info(root->fs_info, "setting datasum"); 439 } 440 btrfs_clear_opt(info->mount_opt, NODATACOW); 441 btrfs_clear_opt(info->mount_opt, NODATASUM); 442 break; 443 case Opt_nodatacow: 444 if (!btrfs_test_opt(root, NODATACOW)) { 445 if (!btrfs_test_opt(root, COMPRESS) || 446 !btrfs_test_opt(root, FORCE_COMPRESS)) { 447 btrfs_info(root->fs_info, 448 "setting nodatacow, compression disabled"); 449 } else { 450 btrfs_info(root->fs_info, "setting nodatacow"); 451 } 452 } 453 btrfs_clear_opt(info->mount_opt, COMPRESS); 454 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS); 455 btrfs_set_opt(info->mount_opt, NODATACOW); 456 btrfs_set_opt(info->mount_opt, NODATASUM); 457 break; 458 case Opt_datacow: 459 btrfs_clear_and_info(root, NODATACOW, 460 "setting datacow"); 461 break; 462 case Opt_compress_force: 463 case Opt_compress_force_type: 464 compress_force = true; 465 /* Fallthrough */ 466 case Opt_compress: 467 case Opt_compress_type: 468 saved_compress_type = btrfs_test_opt(root, COMPRESS) ? 469 info->compress_type : BTRFS_COMPRESS_NONE; 470 saved_compress_force = 471 btrfs_test_opt(root, FORCE_COMPRESS); 472 if (token == Opt_compress || 473 token == Opt_compress_force || 474 strcmp(args[0].from, "zlib") == 0) { 475 compress_type = "zlib"; 476 info->compress_type = BTRFS_COMPRESS_ZLIB; 477 btrfs_set_opt(info->mount_opt, COMPRESS); 478 btrfs_clear_opt(info->mount_opt, NODATACOW); 479 btrfs_clear_opt(info->mount_opt, NODATASUM); 480 no_compress = 0; 481 } else if (strcmp(args[0].from, "lzo") == 0) { 482 compress_type = "lzo"; 483 info->compress_type = BTRFS_COMPRESS_LZO; 484 btrfs_set_opt(info->mount_opt, COMPRESS); 485 btrfs_clear_opt(info->mount_opt, NODATACOW); 486 btrfs_clear_opt(info->mount_opt, NODATASUM); 487 btrfs_set_fs_incompat(info, COMPRESS_LZO); 488 no_compress = 0; 489 } else if (strncmp(args[0].from, "no", 2) == 0) { 490 compress_type = "no"; 491 btrfs_clear_opt(info->mount_opt, COMPRESS); 492 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS); 493 compress_force = false; 494 no_compress++; 495 } else { 496 ret = -EINVAL; 497 goto out; 498 } 499 500 if (compress_force) { 501 btrfs_set_opt(info->mount_opt, FORCE_COMPRESS); 502 } else { 503 /* 504 * If we remount from compress-force=xxx to 505 * compress=xxx, we need clear FORCE_COMPRESS 506 * flag, otherwise, there is no way for users 507 * to disable forcible compression separately. 508 */ 509 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS); 510 } 511 if ((btrfs_test_opt(root, COMPRESS) && 512 (info->compress_type != saved_compress_type || 513 compress_force != saved_compress_force)) || 514 (!btrfs_test_opt(root, COMPRESS) && 515 no_compress == 1)) { 516 btrfs_info(root->fs_info, 517 "%s %s compression", 518 (compress_force) ? "force" : "use", 519 compress_type); 520 } 521 compress_force = false; 522 break; 523 case Opt_ssd: 524 btrfs_set_and_info(root, SSD, 525 "use ssd allocation scheme"); 526 break; 527 case Opt_ssd_spread: 528 btrfs_set_and_info(root, SSD_SPREAD, 529 "use spread ssd allocation scheme"); 530 btrfs_set_opt(info->mount_opt, SSD); 531 break; 532 case Opt_nossd: 533 btrfs_set_and_info(root, NOSSD, 534 "not using ssd allocation scheme"); 535 btrfs_clear_opt(info->mount_opt, SSD); 536 break; 537 case Opt_barrier: 538 btrfs_clear_and_info(root, NOBARRIER, 539 "turning on barriers"); 540 break; 541 case Opt_nobarrier: 542 btrfs_set_and_info(root, NOBARRIER, 543 "turning off barriers"); 544 break; 545 case Opt_thread_pool: 546 ret = match_int(&args[0], &intarg); 547 if (ret) { 548 goto out; 549 } else if (intarg > 0) { 550 info->thread_pool_size = intarg; 551 } else { 552 ret = -EINVAL; 553 goto out; 554 } 555 break; 556 case Opt_max_inline: 557 num = match_strdup(&args[0]); 558 if (num) { 559 info->max_inline = memparse(num, NULL); 560 kfree(num); 561 562 if (info->max_inline) { 563 info->max_inline = min_t(u64, 564 info->max_inline, 565 root->sectorsize); 566 } 567 btrfs_info(root->fs_info, "max_inline at %llu", 568 info->max_inline); 569 } else { 570 ret = -ENOMEM; 571 goto out; 572 } 573 break; 574 case Opt_alloc_start: 575 num = match_strdup(&args[0]); 576 if (num) { 577 mutex_lock(&info->chunk_mutex); 578 info->alloc_start = memparse(num, NULL); 579 mutex_unlock(&info->chunk_mutex); 580 kfree(num); 581 btrfs_info(root->fs_info, "allocations start at %llu", 582 info->alloc_start); 583 } else { 584 ret = -ENOMEM; 585 goto out; 586 } 587 break; 588 case Opt_acl: 589 #ifdef CONFIG_BTRFS_FS_POSIX_ACL 590 root->fs_info->sb->s_flags |= MS_POSIXACL; 591 break; 592 #else 593 btrfs_err(root->fs_info, 594 "support for ACL not compiled in!"); 595 ret = -EINVAL; 596 goto out; 597 #endif 598 case Opt_noacl: 599 root->fs_info->sb->s_flags &= ~MS_POSIXACL; 600 break; 601 case Opt_notreelog: 602 btrfs_set_and_info(root, NOTREELOG, 603 "disabling tree log"); 604 break; 605 case Opt_treelog: 606 btrfs_clear_and_info(root, NOTREELOG, 607 "enabling tree log"); 608 break; 609 case Opt_flushoncommit: 610 btrfs_set_and_info(root, FLUSHONCOMMIT, 611 "turning on flush-on-commit"); 612 break; 613 case Opt_noflushoncommit: 614 btrfs_clear_and_info(root, FLUSHONCOMMIT, 615 "turning off flush-on-commit"); 616 break; 617 case Opt_ratio: 618 ret = match_int(&args[0], &intarg); 619 if (ret) { 620 goto out; 621 } else if (intarg >= 0) { 622 info->metadata_ratio = intarg; 623 btrfs_info(root->fs_info, "metadata ratio %d", 624 info->metadata_ratio); 625 } else { 626 ret = -EINVAL; 627 goto out; 628 } 629 break; 630 case Opt_discard: 631 btrfs_set_and_info(root, DISCARD, 632 "turning on discard"); 633 break; 634 case Opt_nodiscard: 635 btrfs_clear_and_info(root, DISCARD, 636 "turning off discard"); 637 break; 638 case Opt_space_cache: 639 case Opt_space_cache_version: 640 if (token == Opt_space_cache || 641 strcmp(args[0].from, "v1") == 0) { 642 btrfs_clear_opt(root->fs_info->mount_opt, 643 FREE_SPACE_TREE); 644 btrfs_set_and_info(root, SPACE_CACHE, 645 "enabling disk space caching"); 646 } else if (strcmp(args[0].from, "v2") == 0) { 647 btrfs_clear_opt(root->fs_info->mount_opt, 648 SPACE_CACHE); 649 btrfs_set_and_info(root, FREE_SPACE_TREE, 650 "enabling free space tree"); 651 } else { 652 ret = -EINVAL; 653 goto out; 654 } 655 break; 656 case Opt_rescan_uuid_tree: 657 btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE); 658 break; 659 case Opt_no_space_cache: 660 if (btrfs_test_opt(root, SPACE_CACHE)) { 661 btrfs_clear_and_info(root, SPACE_CACHE, 662 "disabling disk space caching"); 663 } 664 if (btrfs_test_opt(root, FREE_SPACE_TREE)) { 665 btrfs_clear_and_info(root, FREE_SPACE_TREE, 666 "disabling free space tree"); 667 } 668 break; 669 case Opt_inode_cache: 670 btrfs_set_pending_and_info(info, INODE_MAP_CACHE, 671 "enabling inode map caching"); 672 break; 673 case Opt_noinode_cache: 674 btrfs_clear_pending_and_info(info, INODE_MAP_CACHE, 675 "disabling inode map caching"); 676 break; 677 case Opt_clear_cache: 678 btrfs_set_and_info(root, CLEAR_CACHE, 679 "force clearing of disk cache"); 680 break; 681 case Opt_user_subvol_rm_allowed: 682 btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED); 683 break; 684 case Opt_enospc_debug: 685 btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG); 686 break; 687 case Opt_noenospc_debug: 688 btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG); 689 break; 690 case Opt_defrag: 691 btrfs_set_and_info(root, AUTO_DEFRAG, 692 "enabling auto defrag"); 693 break; 694 case Opt_nodefrag: 695 btrfs_clear_and_info(root, AUTO_DEFRAG, 696 "disabling auto defrag"); 697 break; 698 case Opt_recovery: 699 btrfs_info(root->fs_info, "enabling auto recovery"); 700 btrfs_set_opt(info->mount_opt, RECOVERY); 701 break; 702 case Opt_skip_balance: 703 btrfs_set_opt(info->mount_opt, SKIP_BALANCE); 704 break; 705 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY 706 case Opt_check_integrity_including_extent_data: 707 btrfs_info(root->fs_info, 708 "enabling check integrity including extent data"); 709 btrfs_set_opt(info->mount_opt, 710 CHECK_INTEGRITY_INCLUDING_EXTENT_DATA); 711 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY); 712 break; 713 case Opt_check_integrity: 714 btrfs_info(root->fs_info, "enabling check integrity"); 715 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY); 716 break; 717 case Opt_check_integrity_print_mask: 718 ret = match_int(&args[0], &intarg); 719 if (ret) { 720 goto out; 721 } else if (intarg >= 0) { 722 info->check_integrity_print_mask = intarg; 723 btrfs_info(root->fs_info, "check_integrity_print_mask 0x%x", 724 info->check_integrity_print_mask); 725 } else { 726 ret = -EINVAL; 727 goto out; 728 } 729 break; 730 #else 731 case Opt_check_integrity_including_extent_data: 732 case Opt_check_integrity: 733 case Opt_check_integrity_print_mask: 734 btrfs_err(root->fs_info, 735 "support for check_integrity* not compiled in!"); 736 ret = -EINVAL; 737 goto out; 738 #endif 739 case Opt_fatal_errors: 740 if (strcmp(args[0].from, "panic") == 0) 741 btrfs_set_opt(info->mount_opt, 742 PANIC_ON_FATAL_ERROR); 743 else if (strcmp(args[0].from, "bug") == 0) 744 btrfs_clear_opt(info->mount_opt, 745 PANIC_ON_FATAL_ERROR); 746 else { 747 ret = -EINVAL; 748 goto out; 749 } 750 break; 751 case Opt_commit_interval: 752 intarg = 0; 753 ret = match_int(&args[0], &intarg); 754 if (ret < 0) { 755 btrfs_err(root->fs_info, "invalid commit interval"); 756 ret = -EINVAL; 757 goto out; 758 } 759 if (intarg > 0) { 760 if (intarg > 300) { 761 btrfs_warn(root->fs_info, "excessive commit interval %d", 762 intarg); 763 } 764 info->commit_interval = intarg; 765 } else { 766 btrfs_info(root->fs_info, "using default commit interval %ds", 767 BTRFS_DEFAULT_COMMIT_INTERVAL); 768 info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL; 769 } 770 break; 771 #ifdef CONFIG_BTRFS_DEBUG 772 case Opt_fragment_all: 773 btrfs_info(root->fs_info, "fragmenting all space"); 774 btrfs_set_opt(info->mount_opt, FRAGMENT_DATA); 775 btrfs_set_opt(info->mount_opt, FRAGMENT_METADATA); 776 break; 777 case Opt_fragment_metadata: 778 btrfs_info(root->fs_info, "fragmenting metadata"); 779 btrfs_set_opt(info->mount_opt, 780 FRAGMENT_METADATA); 781 break; 782 case Opt_fragment_data: 783 btrfs_info(root->fs_info, "fragmenting data"); 784 btrfs_set_opt(info->mount_opt, FRAGMENT_DATA); 785 break; 786 #endif 787 case Opt_err: 788 btrfs_info(root->fs_info, "unrecognized mount option '%s'", p); 789 ret = -EINVAL; 790 goto out; 791 default: 792 break; 793 } 794 } 795 out: 796 if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE) && 797 !btrfs_test_opt(root, FREE_SPACE_TREE) && 798 !btrfs_test_opt(root, CLEAR_CACHE)) { 799 btrfs_err(root->fs_info, "cannot disable free space tree"); 800 ret = -EINVAL; 801 802 } 803 if (!ret && btrfs_test_opt(root, SPACE_CACHE)) 804 btrfs_info(root->fs_info, "disk space caching is enabled"); 805 if (!ret && btrfs_test_opt(root, FREE_SPACE_TREE)) 806 btrfs_info(root->fs_info, "using free space tree"); 807 kfree(orig); 808 return ret; 809 } 810 811 /* 812 * Parse mount options that are required early in the mount process. 813 * 814 * All other options will be parsed on much later in the mount process and 815 * only when we need to allocate a new super block. 816 */ 817 static int btrfs_parse_early_options(const char *options, fmode_t flags, 818 void *holder, char **subvol_name, u64 *subvol_objectid, 819 struct btrfs_fs_devices **fs_devices) 820 { 821 substring_t args[MAX_OPT_ARGS]; 822 char *device_name, *opts, *orig, *p; 823 char *num = NULL; 824 int error = 0; 825 826 if (!options) 827 return 0; 828 829 /* 830 * strsep changes the string, duplicate it because parse_options 831 * gets called twice 832 */ 833 opts = kstrdup(options, GFP_KERNEL); 834 if (!opts) 835 return -ENOMEM; 836 orig = opts; 837 838 while ((p = strsep(&opts, ",")) != NULL) { 839 int token; 840 if (!*p) 841 continue; 842 843 token = match_token(p, tokens, args); 844 switch (token) { 845 case Opt_subvol: 846 kfree(*subvol_name); 847 *subvol_name = match_strdup(&args[0]); 848 if (!*subvol_name) { 849 error = -ENOMEM; 850 goto out; 851 } 852 break; 853 case Opt_subvolid: 854 num = match_strdup(&args[0]); 855 if (num) { 856 *subvol_objectid = memparse(num, NULL); 857 kfree(num); 858 /* we want the original fs_tree */ 859 if (!*subvol_objectid) 860 *subvol_objectid = 861 BTRFS_FS_TREE_OBJECTID; 862 } else { 863 error = -EINVAL; 864 goto out; 865 } 866 break; 867 case Opt_subvolrootid: 868 printk(KERN_WARNING 869 "BTRFS: 'subvolrootid' mount option is deprecated and has " 870 "no effect\n"); 871 break; 872 case Opt_device: 873 device_name = match_strdup(&args[0]); 874 if (!device_name) { 875 error = -ENOMEM; 876 goto out; 877 } 878 error = btrfs_scan_one_device(device_name, 879 flags, holder, fs_devices); 880 kfree(device_name); 881 if (error) 882 goto out; 883 break; 884 default: 885 break; 886 } 887 } 888 889 out: 890 kfree(orig); 891 return error; 892 } 893 894 static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, 895 u64 subvol_objectid) 896 { 897 struct btrfs_root *root = fs_info->tree_root; 898 struct btrfs_root *fs_root; 899 struct btrfs_root_ref *root_ref; 900 struct btrfs_inode_ref *inode_ref; 901 struct btrfs_key key; 902 struct btrfs_path *path = NULL; 903 char *name = NULL, *ptr; 904 u64 dirid; 905 int len; 906 int ret; 907 908 path = btrfs_alloc_path(); 909 if (!path) { 910 ret = -ENOMEM; 911 goto err; 912 } 913 path->leave_spinning = 1; 914 915 name = kmalloc(PATH_MAX, GFP_NOFS); 916 if (!name) { 917 ret = -ENOMEM; 918 goto err; 919 } 920 ptr = name + PATH_MAX - 1; 921 ptr[0] = '\0'; 922 923 /* 924 * Walk up the subvolume trees in the tree of tree roots by root 925 * backrefs until we hit the top-level subvolume. 926 */ 927 while (subvol_objectid != BTRFS_FS_TREE_OBJECTID) { 928 key.objectid = subvol_objectid; 929 key.type = BTRFS_ROOT_BACKREF_KEY; 930 key.offset = (u64)-1; 931 932 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 933 if (ret < 0) { 934 goto err; 935 } else if (ret > 0) { 936 ret = btrfs_previous_item(root, path, subvol_objectid, 937 BTRFS_ROOT_BACKREF_KEY); 938 if (ret < 0) { 939 goto err; 940 } else if (ret > 0) { 941 ret = -ENOENT; 942 goto err; 943 } 944 } 945 946 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 947 subvol_objectid = key.offset; 948 949 root_ref = btrfs_item_ptr(path->nodes[0], path->slots[0], 950 struct btrfs_root_ref); 951 len = btrfs_root_ref_name_len(path->nodes[0], root_ref); 952 ptr -= len + 1; 953 if (ptr < name) { 954 ret = -ENAMETOOLONG; 955 goto err; 956 } 957 read_extent_buffer(path->nodes[0], ptr + 1, 958 (unsigned long)(root_ref + 1), len); 959 ptr[0] = '/'; 960 dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref); 961 btrfs_release_path(path); 962 963 key.objectid = subvol_objectid; 964 key.type = BTRFS_ROOT_ITEM_KEY; 965 key.offset = (u64)-1; 966 fs_root = btrfs_read_fs_root_no_name(fs_info, &key); 967 if (IS_ERR(fs_root)) { 968 ret = PTR_ERR(fs_root); 969 goto err; 970 } 971 972 /* 973 * Walk up the filesystem tree by inode refs until we hit the 974 * root directory. 975 */ 976 while (dirid != BTRFS_FIRST_FREE_OBJECTID) { 977 key.objectid = dirid; 978 key.type = BTRFS_INODE_REF_KEY; 979 key.offset = (u64)-1; 980 981 ret = btrfs_search_slot(NULL, fs_root, &key, path, 0, 0); 982 if (ret < 0) { 983 goto err; 984 } else if (ret > 0) { 985 ret = btrfs_previous_item(fs_root, path, dirid, 986 BTRFS_INODE_REF_KEY); 987 if (ret < 0) { 988 goto err; 989 } else if (ret > 0) { 990 ret = -ENOENT; 991 goto err; 992 } 993 } 994 995 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 996 dirid = key.offset; 997 998 inode_ref = btrfs_item_ptr(path->nodes[0], 999 path->slots[0], 1000 struct btrfs_inode_ref); 1001 len = btrfs_inode_ref_name_len(path->nodes[0], 1002 inode_ref); 1003 ptr -= len + 1; 1004 if (ptr < name) { 1005 ret = -ENAMETOOLONG; 1006 goto err; 1007 } 1008 read_extent_buffer(path->nodes[0], ptr + 1, 1009 (unsigned long)(inode_ref + 1), len); 1010 ptr[0] = '/'; 1011 btrfs_release_path(path); 1012 } 1013 } 1014 1015 btrfs_free_path(path); 1016 if (ptr == name + PATH_MAX - 1) { 1017 name[0] = '/'; 1018 name[1] = '\0'; 1019 } else { 1020 memmove(name, ptr, name + PATH_MAX - ptr); 1021 } 1022 return name; 1023 1024 err: 1025 btrfs_free_path(path); 1026 kfree(name); 1027 return ERR_PTR(ret); 1028 } 1029 1030 static int get_default_subvol_objectid(struct btrfs_fs_info *fs_info, u64 *objectid) 1031 { 1032 struct btrfs_root *root = fs_info->tree_root; 1033 struct btrfs_dir_item *di; 1034 struct btrfs_path *path; 1035 struct btrfs_key location; 1036 u64 dir_id; 1037 1038 path = btrfs_alloc_path(); 1039 if (!path) 1040 return -ENOMEM; 1041 path->leave_spinning = 1; 1042 1043 /* 1044 * Find the "default" dir item which points to the root item that we 1045 * will mount by default if we haven't been given a specific subvolume 1046 * to mount. 1047 */ 1048 dir_id = btrfs_super_root_dir(fs_info->super_copy); 1049 di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0); 1050 if (IS_ERR(di)) { 1051 btrfs_free_path(path); 1052 return PTR_ERR(di); 1053 } 1054 if (!di) { 1055 /* 1056 * Ok the default dir item isn't there. This is weird since 1057 * it's always been there, but don't freak out, just try and 1058 * mount the top-level subvolume. 1059 */ 1060 btrfs_free_path(path); 1061 *objectid = BTRFS_FS_TREE_OBJECTID; 1062 return 0; 1063 } 1064 1065 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location); 1066 btrfs_free_path(path); 1067 *objectid = location.objectid; 1068 return 0; 1069 } 1070 1071 static int btrfs_fill_super(struct super_block *sb, 1072 struct btrfs_fs_devices *fs_devices, 1073 void *data, int silent) 1074 { 1075 struct inode *inode; 1076 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 1077 struct btrfs_key key; 1078 int err; 1079 1080 sb->s_maxbytes = MAX_LFS_FILESIZE; 1081 sb->s_magic = BTRFS_SUPER_MAGIC; 1082 sb->s_op = &btrfs_super_ops; 1083 sb->s_d_op = &btrfs_dentry_operations; 1084 sb->s_export_op = &btrfs_export_ops; 1085 sb->s_xattr = btrfs_xattr_handlers; 1086 sb->s_time_gran = 1; 1087 #ifdef CONFIG_BTRFS_FS_POSIX_ACL 1088 sb->s_flags |= MS_POSIXACL; 1089 #endif 1090 sb->s_flags |= MS_I_VERSION; 1091 sb->s_iflags |= SB_I_CGROUPWB; 1092 err = open_ctree(sb, fs_devices, (char *)data); 1093 if (err) { 1094 printk(KERN_ERR "BTRFS: open_ctree failed\n"); 1095 return err; 1096 } 1097 1098 key.objectid = BTRFS_FIRST_FREE_OBJECTID; 1099 key.type = BTRFS_INODE_ITEM_KEY; 1100 key.offset = 0; 1101 inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL); 1102 if (IS_ERR(inode)) { 1103 err = PTR_ERR(inode); 1104 goto fail_close; 1105 } 1106 1107 sb->s_root = d_make_root(inode); 1108 if (!sb->s_root) { 1109 err = -ENOMEM; 1110 goto fail_close; 1111 } 1112 1113 save_mount_options(sb, data); 1114 cleancache_init_fs(sb); 1115 sb->s_flags |= MS_ACTIVE; 1116 return 0; 1117 1118 fail_close: 1119 close_ctree(fs_info->tree_root); 1120 return err; 1121 } 1122 1123 int btrfs_sync_fs(struct super_block *sb, int wait) 1124 { 1125 struct btrfs_trans_handle *trans; 1126 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 1127 struct btrfs_root *root = fs_info->tree_root; 1128 1129 trace_btrfs_sync_fs(wait); 1130 1131 if (!wait) { 1132 filemap_flush(fs_info->btree_inode->i_mapping); 1133 return 0; 1134 } 1135 1136 btrfs_wait_ordered_roots(fs_info, -1); 1137 1138 trans = btrfs_attach_transaction_barrier(root); 1139 if (IS_ERR(trans)) { 1140 /* no transaction, don't bother */ 1141 if (PTR_ERR(trans) == -ENOENT) { 1142 /* 1143 * Exit unless we have some pending changes 1144 * that need to go through commit 1145 */ 1146 if (fs_info->pending_changes == 0) 1147 return 0; 1148 /* 1149 * A non-blocking test if the fs is frozen. We must not 1150 * start a new transaction here otherwise a deadlock 1151 * happens. The pending operations are delayed to the 1152 * next commit after thawing. 1153 */ 1154 if (__sb_start_write(sb, SB_FREEZE_WRITE, false)) 1155 __sb_end_write(sb, SB_FREEZE_WRITE); 1156 else 1157 return 0; 1158 trans = btrfs_start_transaction(root, 0); 1159 } 1160 if (IS_ERR(trans)) 1161 return PTR_ERR(trans); 1162 } 1163 return btrfs_commit_transaction(trans, root); 1164 } 1165 1166 static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry) 1167 { 1168 struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb); 1169 struct btrfs_root *root = info->tree_root; 1170 char *compress_type; 1171 1172 if (btrfs_test_opt(root, DEGRADED)) 1173 seq_puts(seq, ",degraded"); 1174 if (btrfs_test_opt(root, NODATASUM)) 1175 seq_puts(seq, ",nodatasum"); 1176 if (btrfs_test_opt(root, NODATACOW)) 1177 seq_puts(seq, ",nodatacow"); 1178 if (btrfs_test_opt(root, NOBARRIER)) 1179 seq_puts(seq, ",nobarrier"); 1180 if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE) 1181 seq_printf(seq, ",max_inline=%llu", info->max_inline); 1182 if (info->alloc_start != 0) 1183 seq_printf(seq, ",alloc_start=%llu", info->alloc_start); 1184 if (info->thread_pool_size != min_t(unsigned long, 1185 num_online_cpus() + 2, 8)) 1186 seq_printf(seq, ",thread_pool=%d", info->thread_pool_size); 1187 if (btrfs_test_opt(root, COMPRESS)) { 1188 if (info->compress_type == BTRFS_COMPRESS_ZLIB) 1189 compress_type = "zlib"; 1190 else 1191 compress_type = "lzo"; 1192 if (btrfs_test_opt(root, FORCE_COMPRESS)) 1193 seq_printf(seq, ",compress-force=%s", compress_type); 1194 else 1195 seq_printf(seq, ",compress=%s", compress_type); 1196 } 1197 if (btrfs_test_opt(root, NOSSD)) 1198 seq_puts(seq, ",nossd"); 1199 if (btrfs_test_opt(root, SSD_SPREAD)) 1200 seq_puts(seq, ",ssd_spread"); 1201 else if (btrfs_test_opt(root, SSD)) 1202 seq_puts(seq, ",ssd"); 1203 if (btrfs_test_opt(root, NOTREELOG)) 1204 seq_puts(seq, ",notreelog"); 1205 if (btrfs_test_opt(root, FLUSHONCOMMIT)) 1206 seq_puts(seq, ",flushoncommit"); 1207 if (btrfs_test_opt(root, DISCARD)) 1208 seq_puts(seq, ",discard"); 1209 if (!(root->fs_info->sb->s_flags & MS_POSIXACL)) 1210 seq_puts(seq, ",noacl"); 1211 if (btrfs_test_opt(root, SPACE_CACHE)) 1212 seq_puts(seq, ",space_cache"); 1213 else if (btrfs_test_opt(root, FREE_SPACE_TREE)) 1214 seq_puts(seq, ",space_cache=v2"); 1215 else 1216 seq_puts(seq, ",nospace_cache"); 1217 if (btrfs_test_opt(root, RESCAN_UUID_TREE)) 1218 seq_puts(seq, ",rescan_uuid_tree"); 1219 if (btrfs_test_opt(root, CLEAR_CACHE)) 1220 seq_puts(seq, ",clear_cache"); 1221 if (btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED)) 1222 seq_puts(seq, ",user_subvol_rm_allowed"); 1223 if (btrfs_test_opt(root, ENOSPC_DEBUG)) 1224 seq_puts(seq, ",enospc_debug"); 1225 if (btrfs_test_opt(root, AUTO_DEFRAG)) 1226 seq_puts(seq, ",autodefrag"); 1227 if (btrfs_test_opt(root, INODE_MAP_CACHE)) 1228 seq_puts(seq, ",inode_cache"); 1229 if (btrfs_test_opt(root, SKIP_BALANCE)) 1230 seq_puts(seq, ",skip_balance"); 1231 if (btrfs_test_opt(root, RECOVERY)) 1232 seq_puts(seq, ",recovery"); 1233 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY 1234 if (btrfs_test_opt(root, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA)) 1235 seq_puts(seq, ",check_int_data"); 1236 else if (btrfs_test_opt(root, CHECK_INTEGRITY)) 1237 seq_puts(seq, ",check_int"); 1238 if (info->check_integrity_print_mask) 1239 seq_printf(seq, ",check_int_print_mask=%d", 1240 info->check_integrity_print_mask); 1241 #endif 1242 if (info->metadata_ratio) 1243 seq_printf(seq, ",metadata_ratio=%d", 1244 info->metadata_ratio); 1245 if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR)) 1246 seq_puts(seq, ",fatal_errors=panic"); 1247 if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL) 1248 seq_printf(seq, ",commit=%d", info->commit_interval); 1249 #ifdef CONFIG_BTRFS_DEBUG 1250 if (btrfs_test_opt(root, FRAGMENT_DATA)) 1251 seq_puts(seq, ",fragment=data"); 1252 if (btrfs_test_opt(root, FRAGMENT_METADATA)) 1253 seq_puts(seq, ",fragment=metadata"); 1254 #endif 1255 seq_printf(seq, ",subvolid=%llu", 1256 BTRFS_I(d_inode(dentry))->root->root_key.objectid); 1257 seq_puts(seq, ",subvol="); 1258 seq_dentry(seq, dentry, " \t\n\\"); 1259 return 0; 1260 } 1261 1262 static int btrfs_test_super(struct super_block *s, void *data) 1263 { 1264 struct btrfs_fs_info *p = data; 1265 struct btrfs_fs_info *fs_info = btrfs_sb(s); 1266 1267 return fs_info->fs_devices == p->fs_devices; 1268 } 1269 1270 static int btrfs_set_super(struct super_block *s, void *data) 1271 { 1272 int err = set_anon_super(s, data); 1273 if (!err) 1274 s->s_fs_info = data; 1275 return err; 1276 } 1277 1278 /* 1279 * subvolumes are identified by ino 256 1280 */ 1281 static inline int is_subvolume_inode(struct inode *inode) 1282 { 1283 if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID) 1284 return 1; 1285 return 0; 1286 } 1287 1288 /* 1289 * This will add subvolid=0 to the argument string while removing any subvol= 1290 * and subvolid= arguments to make sure we get the top-level root for path 1291 * walking to the subvol we want. 1292 */ 1293 static char *setup_root_args(char *args) 1294 { 1295 char *buf, *dst, *sep; 1296 1297 if (!args) 1298 return kstrdup("subvolid=0", GFP_NOFS); 1299 1300 /* The worst case is that we add ",subvolid=0" to the end. */ 1301 buf = dst = kmalloc(strlen(args) + strlen(",subvolid=0") + 1, GFP_NOFS); 1302 if (!buf) 1303 return NULL; 1304 1305 while (1) { 1306 sep = strchrnul(args, ','); 1307 if (!strstarts(args, "subvol=") && 1308 !strstarts(args, "subvolid=")) { 1309 memcpy(dst, args, sep - args); 1310 dst += sep - args; 1311 *dst++ = ','; 1312 } 1313 if (*sep) 1314 args = sep + 1; 1315 else 1316 break; 1317 } 1318 strcpy(dst, "subvolid=0"); 1319 1320 return buf; 1321 } 1322 1323 static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid, 1324 int flags, const char *device_name, 1325 char *data) 1326 { 1327 struct dentry *root; 1328 struct vfsmount *mnt = NULL; 1329 char *newargs; 1330 int ret; 1331 1332 newargs = setup_root_args(data); 1333 if (!newargs) { 1334 root = ERR_PTR(-ENOMEM); 1335 goto out; 1336 } 1337 1338 mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name, newargs); 1339 if (PTR_ERR_OR_ZERO(mnt) == -EBUSY) { 1340 if (flags & MS_RDONLY) { 1341 mnt = vfs_kern_mount(&btrfs_fs_type, flags & ~MS_RDONLY, 1342 device_name, newargs); 1343 } else { 1344 mnt = vfs_kern_mount(&btrfs_fs_type, flags | MS_RDONLY, 1345 device_name, newargs); 1346 if (IS_ERR(mnt)) { 1347 root = ERR_CAST(mnt); 1348 mnt = NULL; 1349 goto out; 1350 } 1351 1352 down_write(&mnt->mnt_sb->s_umount); 1353 ret = btrfs_remount(mnt->mnt_sb, &flags, NULL); 1354 up_write(&mnt->mnt_sb->s_umount); 1355 if (ret < 0) { 1356 root = ERR_PTR(ret); 1357 goto out; 1358 } 1359 } 1360 } 1361 if (IS_ERR(mnt)) { 1362 root = ERR_CAST(mnt); 1363 mnt = NULL; 1364 goto out; 1365 } 1366 1367 if (!subvol_name) { 1368 if (!subvol_objectid) { 1369 ret = get_default_subvol_objectid(btrfs_sb(mnt->mnt_sb), 1370 &subvol_objectid); 1371 if (ret) { 1372 root = ERR_PTR(ret); 1373 goto out; 1374 } 1375 } 1376 subvol_name = get_subvol_name_from_objectid(btrfs_sb(mnt->mnt_sb), 1377 subvol_objectid); 1378 if (IS_ERR(subvol_name)) { 1379 root = ERR_CAST(subvol_name); 1380 subvol_name = NULL; 1381 goto out; 1382 } 1383 1384 } 1385 1386 root = mount_subtree(mnt, subvol_name); 1387 /* mount_subtree() drops our reference on the vfsmount. */ 1388 mnt = NULL; 1389 1390 if (!IS_ERR(root)) { 1391 struct super_block *s = root->d_sb; 1392 struct inode *root_inode = d_inode(root); 1393 u64 root_objectid = BTRFS_I(root_inode)->root->root_key.objectid; 1394 1395 ret = 0; 1396 if (!is_subvolume_inode(root_inode)) { 1397 pr_err("BTRFS: '%s' is not a valid subvolume\n", 1398 subvol_name); 1399 ret = -EINVAL; 1400 } 1401 if (subvol_objectid && root_objectid != subvol_objectid) { 1402 /* 1403 * This will also catch a race condition where a 1404 * subvolume which was passed by ID is renamed and 1405 * another subvolume is renamed over the old location. 1406 */ 1407 pr_err("BTRFS: subvol '%s' does not match subvolid %llu\n", 1408 subvol_name, subvol_objectid); 1409 ret = -EINVAL; 1410 } 1411 if (ret) { 1412 dput(root); 1413 root = ERR_PTR(ret); 1414 deactivate_locked_super(s); 1415 } 1416 } 1417 1418 out: 1419 mntput(mnt); 1420 kfree(newargs); 1421 kfree(subvol_name); 1422 return root; 1423 } 1424 1425 static int parse_security_options(char *orig_opts, 1426 struct security_mnt_opts *sec_opts) 1427 { 1428 char *secdata = NULL; 1429 int ret = 0; 1430 1431 secdata = alloc_secdata(); 1432 if (!secdata) 1433 return -ENOMEM; 1434 ret = security_sb_copy_data(orig_opts, secdata); 1435 if (ret) { 1436 free_secdata(secdata); 1437 return ret; 1438 } 1439 ret = security_sb_parse_opts_str(secdata, sec_opts); 1440 free_secdata(secdata); 1441 return ret; 1442 } 1443 1444 static int setup_security_options(struct btrfs_fs_info *fs_info, 1445 struct super_block *sb, 1446 struct security_mnt_opts *sec_opts) 1447 { 1448 int ret = 0; 1449 1450 /* 1451 * Call security_sb_set_mnt_opts() to check whether new sec_opts 1452 * is valid. 1453 */ 1454 ret = security_sb_set_mnt_opts(sb, sec_opts, 0, NULL); 1455 if (ret) 1456 return ret; 1457 1458 #ifdef CONFIG_SECURITY 1459 if (!fs_info->security_opts.num_mnt_opts) { 1460 /* first time security setup, copy sec_opts to fs_info */ 1461 memcpy(&fs_info->security_opts, sec_opts, sizeof(*sec_opts)); 1462 } else { 1463 /* 1464 * Since SELinux(the only one supports security_mnt_opts) does 1465 * NOT support changing context during remount/mount same sb, 1466 * This must be the same or part of the same security options, 1467 * just free it. 1468 */ 1469 security_free_mnt_opts(sec_opts); 1470 } 1471 #endif 1472 return ret; 1473 } 1474 1475 /* 1476 * Find a superblock for the given device / mount point. 1477 * 1478 * Note: This is based on get_sb_bdev from fs/super.c with a few additions 1479 * for multiple device setup. Make sure to keep it in sync. 1480 */ 1481 static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, 1482 const char *device_name, void *data) 1483 { 1484 struct block_device *bdev = NULL; 1485 struct super_block *s; 1486 struct btrfs_fs_devices *fs_devices = NULL; 1487 struct btrfs_fs_info *fs_info = NULL; 1488 struct security_mnt_opts new_sec_opts; 1489 fmode_t mode = FMODE_READ; 1490 char *subvol_name = NULL; 1491 u64 subvol_objectid = 0; 1492 int error = 0; 1493 1494 if (!(flags & MS_RDONLY)) 1495 mode |= FMODE_WRITE; 1496 1497 error = btrfs_parse_early_options(data, mode, fs_type, 1498 &subvol_name, &subvol_objectid, 1499 &fs_devices); 1500 if (error) { 1501 kfree(subvol_name); 1502 return ERR_PTR(error); 1503 } 1504 1505 if (subvol_name || subvol_objectid != BTRFS_FS_TREE_OBJECTID) { 1506 /* mount_subvol() will free subvol_name. */ 1507 return mount_subvol(subvol_name, subvol_objectid, flags, 1508 device_name, data); 1509 } 1510 1511 security_init_mnt_opts(&new_sec_opts); 1512 if (data) { 1513 error = parse_security_options(data, &new_sec_opts); 1514 if (error) 1515 return ERR_PTR(error); 1516 } 1517 1518 error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices); 1519 if (error) 1520 goto error_sec_opts; 1521 1522 /* 1523 * Setup a dummy root and fs_info for test/set super. This is because 1524 * we don't actually fill this stuff out until open_ctree, but we need 1525 * it for searching for existing supers, so this lets us do that and 1526 * then open_ctree will properly initialize everything later. 1527 */ 1528 fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS); 1529 if (!fs_info) { 1530 error = -ENOMEM; 1531 goto error_sec_opts; 1532 } 1533 1534 fs_info->fs_devices = fs_devices; 1535 1536 fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS); 1537 fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS); 1538 security_init_mnt_opts(&fs_info->security_opts); 1539 if (!fs_info->super_copy || !fs_info->super_for_commit) { 1540 error = -ENOMEM; 1541 goto error_fs_info; 1542 } 1543 1544 error = btrfs_open_devices(fs_devices, mode, fs_type); 1545 if (error) 1546 goto error_fs_info; 1547 1548 if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) { 1549 error = -EACCES; 1550 goto error_close_devices; 1551 } 1552 1553 bdev = fs_devices->latest_bdev; 1554 s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC, 1555 fs_info); 1556 if (IS_ERR(s)) { 1557 error = PTR_ERR(s); 1558 goto error_close_devices; 1559 } 1560 1561 if (s->s_root) { 1562 btrfs_close_devices(fs_devices); 1563 free_fs_info(fs_info); 1564 if ((flags ^ s->s_flags) & MS_RDONLY) 1565 error = -EBUSY; 1566 } else { 1567 snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev); 1568 btrfs_sb(s)->bdev_holder = fs_type; 1569 error = btrfs_fill_super(s, fs_devices, data, 1570 flags & MS_SILENT ? 1 : 0); 1571 } 1572 if (error) { 1573 deactivate_locked_super(s); 1574 goto error_sec_opts; 1575 } 1576 1577 fs_info = btrfs_sb(s); 1578 error = setup_security_options(fs_info, s, &new_sec_opts); 1579 if (error) { 1580 deactivate_locked_super(s); 1581 goto error_sec_opts; 1582 } 1583 1584 return dget(s->s_root); 1585 1586 error_close_devices: 1587 btrfs_close_devices(fs_devices); 1588 error_fs_info: 1589 free_fs_info(fs_info); 1590 error_sec_opts: 1591 security_free_mnt_opts(&new_sec_opts); 1592 return ERR_PTR(error); 1593 } 1594 1595 static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info, 1596 int new_pool_size, int old_pool_size) 1597 { 1598 if (new_pool_size == old_pool_size) 1599 return; 1600 1601 fs_info->thread_pool_size = new_pool_size; 1602 1603 btrfs_info(fs_info, "resize thread pool %d -> %d", 1604 old_pool_size, new_pool_size); 1605 1606 btrfs_workqueue_set_max(fs_info->workers, new_pool_size); 1607 btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size); 1608 btrfs_workqueue_set_max(fs_info->submit_workers, new_pool_size); 1609 btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size); 1610 btrfs_workqueue_set_max(fs_info->endio_workers, new_pool_size); 1611 btrfs_workqueue_set_max(fs_info->endio_meta_workers, new_pool_size); 1612 btrfs_workqueue_set_max(fs_info->endio_meta_write_workers, 1613 new_pool_size); 1614 btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size); 1615 btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size); 1616 btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size); 1617 btrfs_workqueue_set_max(fs_info->readahead_workers, new_pool_size); 1618 btrfs_workqueue_set_max(fs_info->scrub_wr_completion_workers, 1619 new_pool_size); 1620 } 1621 1622 static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info) 1623 { 1624 set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state); 1625 } 1626 1627 static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info, 1628 unsigned long old_opts, int flags) 1629 { 1630 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) && 1631 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || 1632 (flags & MS_RDONLY))) { 1633 /* wait for any defraggers to finish */ 1634 wait_event(fs_info->transaction_wait, 1635 (atomic_read(&fs_info->defrag_running) == 0)); 1636 if (flags & MS_RDONLY) 1637 sync_filesystem(fs_info->sb); 1638 } 1639 } 1640 1641 static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info, 1642 unsigned long old_opts) 1643 { 1644 /* 1645 * We need cleanup all defragable inodes if the autodefragment is 1646 * close or the fs is R/O. 1647 */ 1648 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) && 1649 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || 1650 (fs_info->sb->s_flags & MS_RDONLY))) { 1651 btrfs_cleanup_defrag_inodes(fs_info); 1652 } 1653 1654 clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state); 1655 } 1656 1657 static int btrfs_remount(struct super_block *sb, int *flags, char *data) 1658 { 1659 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 1660 struct btrfs_root *root = fs_info->tree_root; 1661 unsigned old_flags = sb->s_flags; 1662 unsigned long old_opts = fs_info->mount_opt; 1663 unsigned long old_compress_type = fs_info->compress_type; 1664 u64 old_max_inline = fs_info->max_inline; 1665 u64 old_alloc_start = fs_info->alloc_start; 1666 int old_thread_pool_size = fs_info->thread_pool_size; 1667 unsigned int old_metadata_ratio = fs_info->metadata_ratio; 1668 int ret; 1669 1670 sync_filesystem(sb); 1671 btrfs_remount_prepare(fs_info); 1672 1673 if (data) { 1674 struct security_mnt_opts new_sec_opts; 1675 1676 security_init_mnt_opts(&new_sec_opts); 1677 ret = parse_security_options(data, &new_sec_opts); 1678 if (ret) 1679 goto restore; 1680 ret = setup_security_options(fs_info, sb, 1681 &new_sec_opts); 1682 if (ret) { 1683 security_free_mnt_opts(&new_sec_opts); 1684 goto restore; 1685 } 1686 } 1687 1688 ret = btrfs_parse_options(root, data); 1689 if (ret) { 1690 ret = -EINVAL; 1691 goto restore; 1692 } 1693 1694 btrfs_remount_begin(fs_info, old_opts, *flags); 1695 btrfs_resize_thread_pool(fs_info, 1696 fs_info->thread_pool_size, old_thread_pool_size); 1697 1698 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) 1699 goto out; 1700 1701 if (*flags & MS_RDONLY) { 1702 /* 1703 * this also happens on 'umount -rf' or on shutdown, when 1704 * the filesystem is busy. 1705 */ 1706 cancel_work_sync(&fs_info->async_reclaim_work); 1707 1708 /* wait for the uuid_scan task to finish */ 1709 down(&fs_info->uuid_tree_rescan_sem); 1710 /* avoid complains from lockdep et al. */ 1711 up(&fs_info->uuid_tree_rescan_sem); 1712 1713 sb->s_flags |= MS_RDONLY; 1714 1715 /* 1716 * Setting MS_RDONLY will put the cleaner thread to 1717 * sleep at the next loop if it's already active. 1718 * If it's already asleep, we'll leave unused block 1719 * groups on disk until we're mounted read-write again 1720 * unless we clean them up here. 1721 */ 1722 btrfs_delete_unused_bgs(fs_info); 1723 1724 btrfs_dev_replace_suspend_for_unmount(fs_info); 1725 btrfs_scrub_cancel(fs_info); 1726 btrfs_pause_balance(fs_info); 1727 1728 ret = btrfs_commit_super(root); 1729 if (ret) 1730 goto restore; 1731 } else { 1732 if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) { 1733 btrfs_err(fs_info, 1734 "Remounting read-write after error is not allowed"); 1735 ret = -EINVAL; 1736 goto restore; 1737 } 1738 if (fs_info->fs_devices->rw_devices == 0) { 1739 ret = -EACCES; 1740 goto restore; 1741 } 1742 1743 if (fs_info->fs_devices->missing_devices > 1744 fs_info->num_tolerated_disk_barrier_failures && 1745 !(*flags & MS_RDONLY)) { 1746 btrfs_warn(fs_info, 1747 "too many missing devices, writeable remount is not allowed"); 1748 ret = -EACCES; 1749 goto restore; 1750 } 1751 1752 if (btrfs_super_log_root(fs_info->super_copy) != 0) { 1753 ret = -EINVAL; 1754 goto restore; 1755 } 1756 1757 ret = btrfs_cleanup_fs_roots(fs_info); 1758 if (ret) 1759 goto restore; 1760 1761 /* recover relocation */ 1762 mutex_lock(&fs_info->cleaner_mutex); 1763 ret = btrfs_recover_relocation(root); 1764 mutex_unlock(&fs_info->cleaner_mutex); 1765 if (ret) 1766 goto restore; 1767 1768 ret = btrfs_resume_balance_async(fs_info); 1769 if (ret) 1770 goto restore; 1771 1772 ret = btrfs_resume_dev_replace_async(fs_info); 1773 if (ret) { 1774 btrfs_warn(fs_info, "failed to resume dev_replace"); 1775 goto restore; 1776 } 1777 1778 if (!fs_info->uuid_root) { 1779 btrfs_info(fs_info, "creating UUID tree"); 1780 ret = btrfs_create_uuid_tree(fs_info); 1781 if (ret) { 1782 btrfs_warn(fs_info, "failed to create the UUID tree %d", ret); 1783 goto restore; 1784 } 1785 } 1786 sb->s_flags &= ~MS_RDONLY; 1787 } 1788 out: 1789 wake_up_process(fs_info->transaction_kthread); 1790 btrfs_remount_cleanup(fs_info, old_opts); 1791 return 0; 1792 1793 restore: 1794 /* We've hit an error - don't reset MS_RDONLY */ 1795 if (sb->s_flags & MS_RDONLY) 1796 old_flags |= MS_RDONLY; 1797 sb->s_flags = old_flags; 1798 fs_info->mount_opt = old_opts; 1799 fs_info->compress_type = old_compress_type; 1800 fs_info->max_inline = old_max_inline; 1801 mutex_lock(&fs_info->chunk_mutex); 1802 fs_info->alloc_start = old_alloc_start; 1803 mutex_unlock(&fs_info->chunk_mutex); 1804 btrfs_resize_thread_pool(fs_info, 1805 old_thread_pool_size, fs_info->thread_pool_size); 1806 fs_info->metadata_ratio = old_metadata_ratio; 1807 btrfs_remount_cleanup(fs_info, old_opts); 1808 return ret; 1809 } 1810 1811 /* Used to sort the devices by max_avail(descending sort) */ 1812 static int btrfs_cmp_device_free_bytes(const void *dev_info1, 1813 const void *dev_info2) 1814 { 1815 if (((struct btrfs_device_info *)dev_info1)->max_avail > 1816 ((struct btrfs_device_info *)dev_info2)->max_avail) 1817 return -1; 1818 else if (((struct btrfs_device_info *)dev_info1)->max_avail < 1819 ((struct btrfs_device_info *)dev_info2)->max_avail) 1820 return 1; 1821 else 1822 return 0; 1823 } 1824 1825 /* 1826 * sort the devices by max_avail, in which max free extent size of each device 1827 * is stored.(Descending Sort) 1828 */ 1829 static inline void btrfs_descending_sort_devices( 1830 struct btrfs_device_info *devices, 1831 size_t nr_devices) 1832 { 1833 sort(devices, nr_devices, sizeof(struct btrfs_device_info), 1834 btrfs_cmp_device_free_bytes, NULL); 1835 } 1836 1837 /* 1838 * The helper to calc the free space on the devices that can be used to store 1839 * file data. 1840 */ 1841 static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes) 1842 { 1843 struct btrfs_fs_info *fs_info = root->fs_info; 1844 struct btrfs_device_info *devices_info; 1845 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 1846 struct btrfs_device *device; 1847 u64 skip_space; 1848 u64 type; 1849 u64 avail_space; 1850 u64 used_space; 1851 u64 min_stripe_size; 1852 int min_stripes = 1, num_stripes = 1; 1853 int i = 0, nr_devices; 1854 int ret; 1855 1856 /* 1857 * We aren't under the device list lock, so this is racey-ish, but good 1858 * enough for our purposes. 1859 */ 1860 nr_devices = fs_info->fs_devices->open_devices; 1861 if (!nr_devices) { 1862 smp_mb(); 1863 nr_devices = fs_info->fs_devices->open_devices; 1864 ASSERT(nr_devices); 1865 if (!nr_devices) { 1866 *free_bytes = 0; 1867 return 0; 1868 } 1869 } 1870 1871 devices_info = kmalloc_array(nr_devices, sizeof(*devices_info), 1872 GFP_NOFS); 1873 if (!devices_info) 1874 return -ENOMEM; 1875 1876 /* calc min stripe number for data space alloction */ 1877 type = btrfs_get_alloc_profile(root, 1); 1878 if (type & BTRFS_BLOCK_GROUP_RAID0) { 1879 min_stripes = 2; 1880 num_stripes = nr_devices; 1881 } else if (type & BTRFS_BLOCK_GROUP_RAID1) { 1882 min_stripes = 2; 1883 num_stripes = 2; 1884 } else if (type & BTRFS_BLOCK_GROUP_RAID10) { 1885 min_stripes = 4; 1886 num_stripes = 4; 1887 } 1888 1889 if (type & BTRFS_BLOCK_GROUP_DUP) 1890 min_stripe_size = 2 * BTRFS_STRIPE_LEN; 1891 else 1892 min_stripe_size = BTRFS_STRIPE_LEN; 1893 1894 if (fs_info->alloc_start) 1895 mutex_lock(&fs_devices->device_list_mutex); 1896 rcu_read_lock(); 1897 list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) { 1898 if (!device->in_fs_metadata || !device->bdev || 1899 device->is_tgtdev_for_dev_replace) 1900 continue; 1901 1902 if (i >= nr_devices) 1903 break; 1904 1905 avail_space = device->total_bytes - device->bytes_used; 1906 1907 /* align with stripe_len */ 1908 avail_space = div_u64(avail_space, BTRFS_STRIPE_LEN); 1909 avail_space *= BTRFS_STRIPE_LEN; 1910 1911 /* 1912 * In order to avoid overwritting the superblock on the drive, 1913 * btrfs starts at an offset of at least 1MB when doing chunk 1914 * allocation. 1915 */ 1916 skip_space = SZ_1M; 1917 1918 /* user can set the offset in fs_info->alloc_start. */ 1919 if (fs_info->alloc_start && 1920 fs_info->alloc_start + BTRFS_STRIPE_LEN <= 1921 device->total_bytes) { 1922 rcu_read_unlock(); 1923 skip_space = max(fs_info->alloc_start, skip_space); 1924 1925 /* 1926 * btrfs can not use the free space in 1927 * [0, skip_space - 1], we must subtract it from the 1928 * total. In order to implement it, we account the used 1929 * space in this range first. 1930 */ 1931 ret = btrfs_account_dev_extents_size(device, 0, 1932 skip_space - 1, 1933 &used_space); 1934 if (ret) { 1935 kfree(devices_info); 1936 mutex_unlock(&fs_devices->device_list_mutex); 1937 return ret; 1938 } 1939 1940 rcu_read_lock(); 1941 1942 /* calc the free space in [0, skip_space - 1] */ 1943 skip_space -= used_space; 1944 } 1945 1946 /* 1947 * we can use the free space in [0, skip_space - 1], subtract 1948 * it from the total. 1949 */ 1950 if (avail_space && avail_space >= skip_space) 1951 avail_space -= skip_space; 1952 else 1953 avail_space = 0; 1954 1955 if (avail_space < min_stripe_size) 1956 continue; 1957 1958 devices_info[i].dev = device; 1959 devices_info[i].max_avail = avail_space; 1960 1961 i++; 1962 } 1963 rcu_read_unlock(); 1964 if (fs_info->alloc_start) 1965 mutex_unlock(&fs_devices->device_list_mutex); 1966 1967 nr_devices = i; 1968 1969 btrfs_descending_sort_devices(devices_info, nr_devices); 1970 1971 i = nr_devices - 1; 1972 avail_space = 0; 1973 while (nr_devices >= min_stripes) { 1974 if (num_stripes > nr_devices) 1975 num_stripes = nr_devices; 1976 1977 if (devices_info[i].max_avail >= min_stripe_size) { 1978 int j; 1979 u64 alloc_size; 1980 1981 avail_space += devices_info[i].max_avail * num_stripes; 1982 alloc_size = devices_info[i].max_avail; 1983 for (j = i + 1 - num_stripes; j <= i; j++) 1984 devices_info[j].max_avail -= alloc_size; 1985 } 1986 i--; 1987 nr_devices--; 1988 } 1989 1990 kfree(devices_info); 1991 *free_bytes = avail_space; 1992 return 0; 1993 } 1994 1995 /* 1996 * Calculate numbers for 'df', pessimistic in case of mixed raid profiles. 1997 * 1998 * If there's a redundant raid level at DATA block groups, use the respective 1999 * multiplier to scale the sizes. 2000 * 2001 * Unused device space usage is based on simulating the chunk allocator 2002 * algorithm that respects the device sizes, order of allocations and the 2003 * 'alloc_start' value, this is a close approximation of the actual use but 2004 * there are other factors that may change the result (like a new metadata 2005 * chunk). 2006 * 2007 * If metadata is exhausted, f_bavail will be 0. 2008 * 2009 * FIXME: not accurate for mixed block groups, total and free/used are ok, 2010 * available appears slightly larger. 2011 */ 2012 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf) 2013 { 2014 struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb); 2015 struct btrfs_super_block *disk_super = fs_info->super_copy; 2016 struct list_head *head = &fs_info->space_info; 2017 struct btrfs_space_info *found; 2018 u64 total_used = 0; 2019 u64 total_free_data = 0; 2020 u64 total_free_meta = 0; 2021 int bits = dentry->d_sb->s_blocksize_bits; 2022 __be32 *fsid = (__be32 *)fs_info->fsid; 2023 unsigned factor = 1; 2024 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 2025 int ret; 2026 u64 thresh = 0; 2027 2028 /* 2029 * holding chunk_muext to avoid allocating new chunks, holding 2030 * device_list_mutex to avoid the device being removed 2031 */ 2032 rcu_read_lock(); 2033 list_for_each_entry_rcu(found, head, list) { 2034 if (found->flags & BTRFS_BLOCK_GROUP_DATA) { 2035 int i; 2036 2037 total_free_data += found->disk_total - found->disk_used; 2038 total_free_data -= 2039 btrfs_account_ro_block_groups_free_space(found); 2040 2041 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) { 2042 if (!list_empty(&found->block_groups[i])) { 2043 switch (i) { 2044 case BTRFS_RAID_DUP: 2045 case BTRFS_RAID_RAID1: 2046 case BTRFS_RAID_RAID10: 2047 factor = 2; 2048 } 2049 } 2050 } 2051 } 2052 if (found->flags & BTRFS_BLOCK_GROUP_METADATA) 2053 total_free_meta += found->disk_total - found->disk_used; 2054 2055 total_used += found->disk_used; 2056 } 2057 2058 rcu_read_unlock(); 2059 2060 buf->f_blocks = div_u64(btrfs_super_total_bytes(disk_super), factor); 2061 buf->f_blocks >>= bits; 2062 buf->f_bfree = buf->f_blocks - (div_u64(total_used, factor) >> bits); 2063 2064 /* Account global block reserve as used, it's in logical size already */ 2065 spin_lock(&block_rsv->lock); 2066 buf->f_bfree -= block_rsv->size >> bits; 2067 spin_unlock(&block_rsv->lock); 2068 2069 buf->f_bavail = div_u64(total_free_data, factor); 2070 ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data); 2071 if (ret) 2072 return ret; 2073 buf->f_bavail += div_u64(total_free_data, factor); 2074 buf->f_bavail = buf->f_bavail >> bits; 2075 2076 /* 2077 * We calculate the remaining metadata space minus global reserve. If 2078 * this is (supposedly) smaller than zero, there's no space. But this 2079 * does not hold in practice, the exhausted state happens where's still 2080 * some positive delta. So we apply some guesswork and compare the 2081 * delta to a 4M threshold. (Practically observed delta was ~2M.) 2082 * 2083 * We probably cannot calculate the exact threshold value because this 2084 * depends on the internal reservations requested by various 2085 * operations, so some operations that consume a few metadata will 2086 * succeed even if the Avail is zero. But this is better than the other 2087 * way around. 2088 */ 2089 thresh = 4 * 1024 * 1024; 2090 2091 if (total_free_meta - thresh < block_rsv->size) 2092 buf->f_bavail = 0; 2093 2094 buf->f_type = BTRFS_SUPER_MAGIC; 2095 buf->f_bsize = dentry->d_sb->s_blocksize; 2096 buf->f_namelen = BTRFS_NAME_LEN; 2097 2098 /* We treat it as constant endianness (it doesn't matter _which_) 2099 because we want the fsid to come out the same whether mounted 2100 on a big-endian or little-endian host */ 2101 buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]); 2102 buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]); 2103 /* Mask in the root object ID too, to disambiguate subvols */ 2104 buf->f_fsid.val[0] ^= BTRFS_I(d_inode(dentry))->root->objectid >> 32; 2105 buf->f_fsid.val[1] ^= BTRFS_I(d_inode(dentry))->root->objectid; 2106 2107 return 0; 2108 } 2109 2110 static void btrfs_kill_super(struct super_block *sb) 2111 { 2112 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 2113 kill_anon_super(sb); 2114 free_fs_info(fs_info); 2115 } 2116 2117 static struct file_system_type btrfs_fs_type = { 2118 .owner = THIS_MODULE, 2119 .name = "btrfs", 2120 .mount = btrfs_mount, 2121 .kill_sb = btrfs_kill_super, 2122 .fs_flags = FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA, 2123 }; 2124 MODULE_ALIAS_FS("btrfs"); 2125 2126 static int btrfs_control_open(struct inode *inode, struct file *file) 2127 { 2128 /* 2129 * The control file's private_data is used to hold the 2130 * transaction when it is started and is used to keep 2131 * track of whether a transaction is already in progress. 2132 */ 2133 file->private_data = NULL; 2134 return 0; 2135 } 2136 2137 /* 2138 * used by btrfsctl to scan devices when no FS is mounted 2139 */ 2140 static long btrfs_control_ioctl(struct file *file, unsigned int cmd, 2141 unsigned long arg) 2142 { 2143 struct btrfs_ioctl_vol_args *vol; 2144 struct btrfs_fs_devices *fs_devices; 2145 int ret = -ENOTTY; 2146 2147 if (!capable(CAP_SYS_ADMIN)) 2148 return -EPERM; 2149 2150 vol = memdup_user((void __user *)arg, sizeof(*vol)); 2151 if (IS_ERR(vol)) 2152 return PTR_ERR(vol); 2153 2154 switch (cmd) { 2155 case BTRFS_IOC_SCAN_DEV: 2156 ret = btrfs_scan_one_device(vol->name, FMODE_READ, 2157 &btrfs_fs_type, &fs_devices); 2158 break; 2159 case BTRFS_IOC_DEVICES_READY: 2160 ret = btrfs_scan_one_device(vol->name, FMODE_READ, 2161 &btrfs_fs_type, &fs_devices); 2162 if (ret) 2163 break; 2164 ret = !(fs_devices->num_devices == fs_devices->total_devices); 2165 break; 2166 } 2167 2168 kfree(vol); 2169 return ret; 2170 } 2171 2172 static int btrfs_freeze(struct super_block *sb) 2173 { 2174 struct btrfs_trans_handle *trans; 2175 struct btrfs_root *root = btrfs_sb(sb)->tree_root; 2176 2177 trans = btrfs_attach_transaction_barrier(root); 2178 if (IS_ERR(trans)) { 2179 /* no transaction, don't bother */ 2180 if (PTR_ERR(trans) == -ENOENT) 2181 return 0; 2182 return PTR_ERR(trans); 2183 } 2184 return btrfs_commit_transaction(trans, root); 2185 } 2186 2187 static int btrfs_show_devname(struct seq_file *m, struct dentry *root) 2188 { 2189 struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb); 2190 struct btrfs_fs_devices *cur_devices; 2191 struct btrfs_device *dev, *first_dev = NULL; 2192 struct list_head *head; 2193 struct rcu_string *name; 2194 2195 mutex_lock(&fs_info->fs_devices->device_list_mutex); 2196 cur_devices = fs_info->fs_devices; 2197 while (cur_devices) { 2198 head = &cur_devices->devices; 2199 list_for_each_entry(dev, head, dev_list) { 2200 if (dev->missing) 2201 continue; 2202 if (!dev->name) 2203 continue; 2204 if (!first_dev || dev->devid < first_dev->devid) 2205 first_dev = dev; 2206 } 2207 cur_devices = cur_devices->seed; 2208 } 2209 2210 if (first_dev) { 2211 rcu_read_lock(); 2212 name = rcu_dereference(first_dev->name); 2213 seq_escape(m, name->str, " \t\n\\"); 2214 rcu_read_unlock(); 2215 } else { 2216 WARN_ON(1); 2217 } 2218 mutex_unlock(&fs_info->fs_devices->device_list_mutex); 2219 return 0; 2220 } 2221 2222 static const struct super_operations btrfs_super_ops = { 2223 .drop_inode = btrfs_drop_inode, 2224 .evict_inode = btrfs_evict_inode, 2225 .put_super = btrfs_put_super, 2226 .sync_fs = btrfs_sync_fs, 2227 .show_options = btrfs_show_options, 2228 .show_devname = btrfs_show_devname, 2229 .write_inode = btrfs_write_inode, 2230 .alloc_inode = btrfs_alloc_inode, 2231 .destroy_inode = btrfs_destroy_inode, 2232 .statfs = btrfs_statfs, 2233 .remount_fs = btrfs_remount, 2234 .freeze_fs = btrfs_freeze, 2235 }; 2236 2237 static const struct file_operations btrfs_ctl_fops = { 2238 .open = btrfs_control_open, 2239 .unlocked_ioctl = btrfs_control_ioctl, 2240 .compat_ioctl = btrfs_control_ioctl, 2241 .owner = THIS_MODULE, 2242 .llseek = noop_llseek, 2243 }; 2244 2245 static struct miscdevice btrfs_misc = { 2246 .minor = BTRFS_MINOR, 2247 .name = "btrfs-control", 2248 .fops = &btrfs_ctl_fops 2249 }; 2250 2251 MODULE_ALIAS_MISCDEV(BTRFS_MINOR); 2252 MODULE_ALIAS("devname:btrfs-control"); 2253 2254 static int btrfs_interface_init(void) 2255 { 2256 return misc_register(&btrfs_misc); 2257 } 2258 2259 static void btrfs_interface_exit(void) 2260 { 2261 misc_deregister(&btrfs_misc); 2262 } 2263 2264 static void btrfs_print_info(void) 2265 { 2266 printk(KERN_INFO "Btrfs loaded" 2267 #ifdef CONFIG_BTRFS_DEBUG 2268 ", debug=on" 2269 #endif 2270 #ifdef CONFIG_BTRFS_ASSERT 2271 ", assert=on" 2272 #endif 2273 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY 2274 ", integrity-checker=on" 2275 #endif 2276 "\n"); 2277 } 2278 2279 static int btrfs_run_sanity_tests(void) 2280 { 2281 int ret; 2282 2283 ret = btrfs_init_test_fs(); 2284 if (ret) 2285 return ret; 2286 2287 ret = btrfs_test_free_space_cache(); 2288 if (ret) 2289 goto out; 2290 ret = btrfs_test_extent_buffer_operations(); 2291 if (ret) 2292 goto out; 2293 ret = btrfs_test_extent_io(); 2294 if (ret) 2295 goto out; 2296 ret = btrfs_test_inodes(); 2297 if (ret) 2298 goto out; 2299 ret = btrfs_test_qgroups(); 2300 if (ret) 2301 goto out; 2302 ret = btrfs_test_free_space_tree(); 2303 out: 2304 btrfs_destroy_test_fs(); 2305 return ret; 2306 } 2307 2308 static int __init init_btrfs_fs(void) 2309 { 2310 int err; 2311 2312 err = btrfs_hash_init(); 2313 if (err) 2314 return err; 2315 2316 btrfs_props_init(); 2317 2318 err = btrfs_init_sysfs(); 2319 if (err) 2320 goto free_hash; 2321 2322 btrfs_init_compress(); 2323 2324 err = btrfs_init_cachep(); 2325 if (err) 2326 goto free_compress; 2327 2328 err = extent_io_init(); 2329 if (err) 2330 goto free_cachep; 2331 2332 err = extent_map_init(); 2333 if (err) 2334 goto free_extent_io; 2335 2336 err = ordered_data_init(); 2337 if (err) 2338 goto free_extent_map; 2339 2340 err = btrfs_delayed_inode_init(); 2341 if (err) 2342 goto free_ordered_data; 2343 2344 err = btrfs_auto_defrag_init(); 2345 if (err) 2346 goto free_delayed_inode; 2347 2348 err = btrfs_delayed_ref_init(); 2349 if (err) 2350 goto free_auto_defrag; 2351 2352 err = btrfs_prelim_ref_init(); 2353 if (err) 2354 goto free_delayed_ref; 2355 2356 err = btrfs_end_io_wq_init(); 2357 if (err) 2358 goto free_prelim_ref; 2359 2360 err = btrfs_interface_init(); 2361 if (err) 2362 goto free_end_io_wq; 2363 2364 btrfs_init_lockdep(); 2365 2366 btrfs_print_info(); 2367 2368 err = btrfs_run_sanity_tests(); 2369 if (err) 2370 goto unregister_ioctl; 2371 2372 err = register_filesystem(&btrfs_fs_type); 2373 if (err) 2374 goto unregister_ioctl; 2375 2376 return 0; 2377 2378 unregister_ioctl: 2379 btrfs_interface_exit(); 2380 free_end_io_wq: 2381 btrfs_end_io_wq_exit(); 2382 free_prelim_ref: 2383 btrfs_prelim_ref_exit(); 2384 free_delayed_ref: 2385 btrfs_delayed_ref_exit(); 2386 free_auto_defrag: 2387 btrfs_auto_defrag_exit(); 2388 free_delayed_inode: 2389 btrfs_delayed_inode_exit(); 2390 free_ordered_data: 2391 ordered_data_exit(); 2392 free_extent_map: 2393 extent_map_exit(); 2394 free_extent_io: 2395 extent_io_exit(); 2396 free_cachep: 2397 btrfs_destroy_cachep(); 2398 free_compress: 2399 btrfs_exit_compress(); 2400 btrfs_exit_sysfs(); 2401 free_hash: 2402 btrfs_hash_exit(); 2403 return err; 2404 } 2405 2406 static void __exit exit_btrfs_fs(void) 2407 { 2408 btrfs_destroy_cachep(); 2409 btrfs_delayed_ref_exit(); 2410 btrfs_auto_defrag_exit(); 2411 btrfs_delayed_inode_exit(); 2412 btrfs_prelim_ref_exit(); 2413 ordered_data_exit(); 2414 extent_map_exit(); 2415 extent_io_exit(); 2416 btrfs_interface_exit(); 2417 btrfs_end_io_wq_exit(); 2418 unregister_filesystem(&btrfs_fs_type); 2419 btrfs_exit_sysfs(); 2420 btrfs_cleanup_fs_uuids(); 2421 btrfs_exit_compress(); 2422 btrfs_hash_exit(); 2423 } 2424 2425 late_initcall(init_btrfs_fs); 2426 module_exit(exit_btrfs_fs) 2427 2428 MODULE_LICENSE("GPL"); 2429