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