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