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/memcontrol.h> 26 #include <linux/slab.h> 27 #include <linux/ratelimit.h> 28 #include <linux/crc32c.h> 29 #include <linux/btrfs.h> 30 #include <linux/security.h> 31 #include <linux/fs_parser.h> 32 #include "messages.h" 33 #include "delayed-inode.h" 34 #include "ctree.h" 35 #include "disk-io.h" 36 #include "transaction.h" 37 #include "btrfs_inode.h" 38 #include "direct-io.h" 39 #include "props.h" 40 #include "xattr.h" 41 #include "bio.h" 42 #include "export.h" 43 #include "compression.h" 44 #include "dev-replace.h" 45 #include "free-space-cache.h" 46 #include "backref.h" 47 #include "space-info.h" 48 #include "sysfs.h" 49 #include "zoned.h" 50 #include "tests/btrfs-tests.h" 51 #include "block-group.h" 52 #include "discard.h" 53 #include "qgroup.h" 54 #include "raid56.h" 55 #include "fs.h" 56 #include "accessors.h" 57 #include "defrag.h" 58 #include "dir-item.h" 59 #include "ioctl.h" 60 #include "scrub.h" 61 #include "verity.h" 62 #include "super.h" 63 #include "extent-tree.h" 64 #include "tree-log.h" 65 #define CREATE_TRACE_POINTS 66 #include <trace/events/btrfs.h> 67 68 static const struct super_operations btrfs_super_ops; 69 static struct file_system_type btrfs_fs_type; 70 71 static void btrfs_put_super(struct super_block *sb) 72 { 73 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 74 75 btrfs_info(fs_info, "last unmount of filesystem %pU", fs_info->fs_devices->fsid); 76 close_ctree(fs_info); 77 } 78 79 /* Store the mount options related information. */ 80 struct btrfs_fs_context { 81 char *subvol_name; 82 u64 subvol_objectid; 83 u64 max_inline; 84 u32 commit_interval; 85 u32 metadata_ratio; 86 u32 thread_pool_size; 87 unsigned long long mount_opt; 88 unsigned long compress_type:4; 89 int compress_level; 90 refcount_t refs; 91 }; 92 93 static void btrfs_emit_options(struct btrfs_fs_info *info, 94 struct btrfs_fs_context *old); 95 96 enum { 97 Opt_acl, 98 Opt_clear_cache, 99 Opt_commit_interval, 100 Opt_compress, 101 Opt_compress_force, 102 Opt_compress_force_type, 103 Opt_compress_type, 104 Opt_degraded, 105 Opt_device, 106 Opt_fatal_errors, 107 Opt_flushoncommit, 108 Opt_max_inline, 109 Opt_barrier, 110 Opt_datacow, 111 Opt_datasum, 112 Opt_defrag, 113 Opt_discard, 114 Opt_discard_mode, 115 Opt_ratio, 116 Opt_rescan_uuid_tree, 117 Opt_skip_balance, 118 Opt_space_cache, 119 Opt_space_cache_version, 120 Opt_ssd, 121 Opt_ssd_spread, 122 Opt_subvol, 123 Opt_subvol_empty, 124 Opt_subvolid, 125 Opt_thread_pool, 126 Opt_treelog, 127 Opt_user_subvol_rm_allowed, 128 Opt_norecovery, 129 130 /* Rescue options */ 131 Opt_rescue, 132 133 /* Debugging options */ 134 Opt_enospc_debug, 135 #ifdef CONFIG_BTRFS_DEBUG 136 Opt_fragment, Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all, 137 Opt_ref_verify, 138 Opt_ref_tracker, 139 #endif 140 Opt_err, 141 }; 142 143 enum { 144 Opt_fatal_errors_panic, 145 Opt_fatal_errors_bug, 146 }; 147 148 static const struct constant_table btrfs_parameter_fatal_errors[] = { 149 { "panic", Opt_fatal_errors_panic }, 150 { "bug", Opt_fatal_errors_bug }, 151 {} 152 }; 153 154 enum { 155 Opt_discard_sync, 156 Opt_discard_async, 157 }; 158 159 static const struct constant_table btrfs_parameter_discard[] = { 160 { "sync", Opt_discard_sync }, 161 { "async", Opt_discard_async }, 162 {} 163 }; 164 165 enum { 166 Opt_space_cache_v1, 167 Opt_space_cache_v2, 168 }; 169 170 static const struct constant_table btrfs_parameter_space_cache[] = { 171 { "v1", Opt_space_cache_v1 }, 172 { "v2", Opt_space_cache_v2 }, 173 {} 174 }; 175 176 enum { 177 Opt_rescue_usebackuproot, 178 Opt_rescue_nologreplay, 179 Opt_rescue_ignorebadroots, 180 Opt_rescue_ignoredatacsums, 181 Opt_rescue_ignoremetacsums, 182 Opt_rescue_ignoresuperflags, 183 Opt_rescue_parameter_all, 184 }; 185 186 static const struct constant_table btrfs_parameter_rescue[] = { 187 { "usebackuproot", Opt_rescue_usebackuproot }, 188 { "nologreplay", Opt_rescue_nologreplay }, 189 { "ignorebadroots", Opt_rescue_ignorebadroots }, 190 { "ibadroots", Opt_rescue_ignorebadroots }, 191 { "ignoredatacsums", Opt_rescue_ignoredatacsums }, 192 { "ignoremetacsums", Opt_rescue_ignoremetacsums}, 193 { "ignoresuperflags", Opt_rescue_ignoresuperflags}, 194 { "idatacsums", Opt_rescue_ignoredatacsums }, 195 { "imetacsums", Opt_rescue_ignoremetacsums}, 196 { "isuperflags", Opt_rescue_ignoresuperflags}, 197 { "all", Opt_rescue_parameter_all }, 198 {} 199 }; 200 201 #ifdef CONFIG_BTRFS_DEBUG 202 enum { 203 Opt_fragment_parameter_data, 204 Opt_fragment_parameter_metadata, 205 Opt_fragment_parameter_all, 206 }; 207 208 static const struct constant_table btrfs_parameter_fragment[] = { 209 { "data", Opt_fragment_parameter_data }, 210 { "metadata", Opt_fragment_parameter_metadata }, 211 { "all", Opt_fragment_parameter_all }, 212 {} 213 }; 214 #endif 215 216 static const struct fs_parameter_spec btrfs_fs_parameters[] = { 217 fsparam_flag_no("acl", Opt_acl), 218 fsparam_flag_no("autodefrag", Opt_defrag), 219 fsparam_flag_no("barrier", Opt_barrier), 220 fsparam_flag("clear_cache", Opt_clear_cache), 221 fsparam_u32("commit", Opt_commit_interval), 222 fsparam_flag("compress", Opt_compress), 223 fsparam_string("compress", Opt_compress_type), 224 fsparam_flag("compress-force", Opt_compress_force), 225 fsparam_string("compress-force", Opt_compress_force_type), 226 fsparam_flag_no("datacow", Opt_datacow), 227 fsparam_flag_no("datasum", Opt_datasum), 228 fsparam_flag("degraded", Opt_degraded), 229 fsparam_string("device", Opt_device), 230 fsparam_flag_no("discard", Opt_discard), 231 fsparam_enum("discard", Opt_discard_mode, btrfs_parameter_discard), 232 fsparam_enum("fatal_errors", Opt_fatal_errors, btrfs_parameter_fatal_errors), 233 fsparam_flag_no("flushoncommit", Opt_flushoncommit), 234 fsparam_string("max_inline", Opt_max_inline), 235 fsparam_u32("metadata_ratio", Opt_ratio), 236 fsparam_flag("rescan_uuid_tree", Opt_rescan_uuid_tree), 237 fsparam_flag("skip_balance", Opt_skip_balance), 238 fsparam_flag_no("space_cache", Opt_space_cache), 239 fsparam_enum("space_cache", Opt_space_cache_version, btrfs_parameter_space_cache), 240 fsparam_flag_no("ssd", Opt_ssd), 241 fsparam_flag_no("ssd_spread", Opt_ssd_spread), 242 fsparam_string("subvol", Opt_subvol), 243 fsparam_flag("subvol=", Opt_subvol_empty), 244 fsparam_u64("subvolid", Opt_subvolid), 245 fsparam_u32("thread_pool", Opt_thread_pool), 246 fsparam_flag_no("treelog", Opt_treelog), 247 fsparam_flag("user_subvol_rm_allowed", Opt_user_subvol_rm_allowed), 248 249 /* Rescue options. */ 250 fsparam_enum("rescue", Opt_rescue, btrfs_parameter_rescue), 251 /* For compatibility only, alias for "rescue=nologreplay". */ 252 fsparam_flag("norecovery", Opt_norecovery), 253 254 /* Debugging options. */ 255 fsparam_flag_no("enospc_debug", Opt_enospc_debug), 256 #ifdef CONFIG_BTRFS_DEBUG 257 fsparam_enum("fragment", Opt_fragment, btrfs_parameter_fragment), 258 fsparam_flag("ref_tracker", Opt_ref_tracker), 259 fsparam_flag("ref_verify", Opt_ref_verify), 260 #endif 261 {} 262 }; 263 264 static bool btrfs_match_compress_type(const char *string, const char *type, bool may_have_level) 265 { 266 const int len = strlen(type); 267 268 return (strncmp(string, type, len) == 0) && 269 ((may_have_level && string[len] == ':') || string[len] == '\0'); 270 } 271 272 static int btrfs_parse_compress(struct btrfs_fs_context *ctx, 273 const struct fs_parameter *param, int opt) 274 { 275 const char *string = param->string; 276 int ret; 277 278 /* 279 * Provide the same semantics as older kernels that don't use fs 280 * context, specifying the "compress" option clears "force-compress" 281 * without the need to pass "compress-force=[no|none]" before 282 * specifying "compress". 283 */ 284 if (opt != Opt_compress_force && opt != Opt_compress_force_type) 285 btrfs_clear_opt(ctx->mount_opt, FORCE_COMPRESS); 286 287 if (opt == Opt_compress || opt == Opt_compress_force) { 288 ctx->compress_type = BTRFS_COMPRESS_ZLIB; 289 ctx->compress_level = BTRFS_ZLIB_DEFAULT_LEVEL; 290 btrfs_set_opt(ctx->mount_opt, COMPRESS); 291 btrfs_clear_opt(ctx->mount_opt, NODATACOW); 292 btrfs_clear_opt(ctx->mount_opt, NODATASUM); 293 } else if (btrfs_match_compress_type(string, "zlib", true)) { 294 ctx->compress_type = BTRFS_COMPRESS_ZLIB; 295 ret = btrfs_compress_str2level(BTRFS_COMPRESS_ZLIB, string + 4, 296 &ctx->compress_level); 297 if (ret < 0) 298 goto error; 299 btrfs_set_opt(ctx->mount_opt, COMPRESS); 300 btrfs_clear_opt(ctx->mount_opt, NODATACOW); 301 btrfs_clear_opt(ctx->mount_opt, NODATASUM); 302 } else if (btrfs_match_compress_type(string, "lzo", true)) { 303 ctx->compress_type = BTRFS_COMPRESS_LZO; 304 ret = btrfs_compress_str2level(BTRFS_COMPRESS_LZO, string + 3, 305 &ctx->compress_level); 306 if (ret < 0) 307 goto error; 308 if (string[3] == ':' && string[4]) 309 btrfs_warn(NULL, "Compression level ignored for LZO"); 310 btrfs_set_opt(ctx->mount_opt, COMPRESS); 311 btrfs_clear_opt(ctx->mount_opt, NODATACOW); 312 btrfs_clear_opt(ctx->mount_opt, NODATASUM); 313 } else if (btrfs_match_compress_type(string, "zstd", true)) { 314 ctx->compress_type = BTRFS_COMPRESS_ZSTD; 315 ret = btrfs_compress_str2level(BTRFS_COMPRESS_ZSTD, string + 4, 316 &ctx->compress_level); 317 if (ret < 0) 318 goto error; 319 btrfs_set_opt(ctx->mount_opt, COMPRESS); 320 btrfs_clear_opt(ctx->mount_opt, NODATACOW); 321 btrfs_clear_opt(ctx->mount_opt, NODATASUM); 322 } else if (btrfs_match_compress_type(string, "no", false) || 323 btrfs_match_compress_type(string, "none", false)) { 324 ctx->compress_level = 0; 325 ctx->compress_type = 0; 326 btrfs_clear_opt(ctx->mount_opt, COMPRESS); 327 btrfs_clear_opt(ctx->mount_opt, FORCE_COMPRESS); 328 } else { 329 ret = -EINVAL; 330 goto error; 331 } 332 return 0; 333 error: 334 btrfs_err(NULL, "failed to parse compression option '%s'", string); 335 return ret; 336 337 } 338 339 static int btrfs_parse_param(struct fs_context *fc, struct fs_parameter *param) 340 { 341 struct btrfs_fs_context *ctx = fc->fs_private; 342 struct fs_parse_result result; 343 int opt; 344 345 opt = fs_parse(fc, btrfs_fs_parameters, param, &result); 346 if (opt < 0) 347 return opt; 348 349 switch (opt) { 350 case Opt_degraded: 351 btrfs_set_opt(ctx->mount_opt, DEGRADED); 352 break; 353 case Opt_subvol_empty: 354 /* 355 * This exists because we used to allow it on accident, so we're 356 * keeping it to maintain ABI. See 37becec95ac3 ("Btrfs: allow 357 * empty subvol= again"). 358 */ 359 break; 360 case Opt_subvol: 361 kfree(ctx->subvol_name); 362 ctx->subvol_name = kstrdup(param->string, GFP_KERNEL); 363 if (!ctx->subvol_name) 364 return -ENOMEM; 365 break; 366 case Opt_subvolid: 367 ctx->subvol_objectid = result.uint_64; 368 369 /* subvolid=0 means give me the original fs_tree. */ 370 if (!ctx->subvol_objectid) 371 ctx->subvol_objectid = BTRFS_FS_TREE_OBJECTID; 372 break; 373 case Opt_device: { 374 struct btrfs_device *device; 375 376 mutex_lock(&uuid_mutex); 377 device = btrfs_scan_one_device(param->string, false); 378 mutex_unlock(&uuid_mutex); 379 if (IS_ERR(device)) 380 return PTR_ERR(device); 381 break; 382 } 383 case Opt_datasum: 384 if (result.negated) { 385 btrfs_set_opt(ctx->mount_opt, NODATASUM); 386 } else { 387 btrfs_clear_opt(ctx->mount_opt, NODATACOW); 388 btrfs_clear_opt(ctx->mount_opt, NODATASUM); 389 } 390 break; 391 case Opt_datacow: 392 if (result.negated) { 393 btrfs_clear_opt(ctx->mount_opt, COMPRESS); 394 btrfs_clear_opt(ctx->mount_opt, FORCE_COMPRESS); 395 btrfs_set_opt(ctx->mount_opt, NODATACOW); 396 btrfs_set_opt(ctx->mount_opt, NODATASUM); 397 } else { 398 btrfs_clear_opt(ctx->mount_opt, NODATACOW); 399 } 400 break; 401 case Opt_compress_force: 402 case Opt_compress_force_type: 403 btrfs_set_opt(ctx->mount_opt, FORCE_COMPRESS); 404 fallthrough; 405 case Opt_compress: 406 case Opt_compress_type: 407 if (btrfs_parse_compress(ctx, param, opt)) 408 return -EINVAL; 409 break; 410 case Opt_ssd: 411 if (result.negated) { 412 btrfs_set_opt(ctx->mount_opt, NOSSD); 413 btrfs_clear_opt(ctx->mount_opt, SSD); 414 btrfs_clear_opt(ctx->mount_opt, SSD_SPREAD); 415 } else { 416 btrfs_set_opt(ctx->mount_opt, SSD); 417 btrfs_clear_opt(ctx->mount_opt, NOSSD); 418 } 419 break; 420 case Opt_ssd_spread: 421 if (result.negated) { 422 btrfs_clear_opt(ctx->mount_opt, SSD_SPREAD); 423 } else { 424 btrfs_set_opt(ctx->mount_opt, SSD); 425 btrfs_set_opt(ctx->mount_opt, SSD_SPREAD); 426 btrfs_clear_opt(ctx->mount_opt, NOSSD); 427 } 428 break; 429 case Opt_barrier: 430 if (result.negated) 431 btrfs_set_opt(ctx->mount_opt, NOBARRIER); 432 else 433 btrfs_clear_opt(ctx->mount_opt, NOBARRIER); 434 break; 435 case Opt_thread_pool: 436 if (result.uint_32 == 0) { 437 btrfs_err(NULL, "invalid value 0 for thread_pool"); 438 return -EINVAL; 439 } 440 ctx->thread_pool_size = result.uint_32; 441 break; 442 case Opt_max_inline: 443 ctx->max_inline = memparse(param->string, NULL); 444 break; 445 case Opt_acl: 446 if (result.negated) { 447 fc->sb_flags &= ~SB_POSIXACL; 448 } else { 449 #ifdef CONFIG_BTRFS_FS_POSIX_ACL 450 fc->sb_flags |= SB_POSIXACL; 451 #else 452 btrfs_err(NULL, "support for ACL not compiled in"); 453 return -EINVAL; 454 #endif 455 } 456 /* 457 * VFS limits the ability to toggle ACL on and off via remount, 458 * despite every file system allowing this. This seems to be 459 * an oversight since we all do, but it'll fail if we're 460 * remounting. So don't set the mask here, we'll check it in 461 * btrfs_reconfigure and do the toggling ourselves. 462 */ 463 if (fc->purpose != FS_CONTEXT_FOR_RECONFIGURE) 464 fc->sb_flags_mask |= SB_POSIXACL; 465 break; 466 case Opt_treelog: 467 if (result.negated) 468 btrfs_set_opt(ctx->mount_opt, NOTREELOG); 469 else 470 btrfs_clear_opt(ctx->mount_opt, NOTREELOG); 471 break; 472 case Opt_norecovery: 473 btrfs_info(NULL, 474 "'norecovery' is for compatibility only, recommended to use 'rescue=nologreplay'"); 475 btrfs_set_opt(ctx->mount_opt, NOLOGREPLAY); 476 break; 477 case Opt_flushoncommit: 478 if (result.negated) 479 btrfs_clear_opt(ctx->mount_opt, FLUSHONCOMMIT); 480 else 481 btrfs_set_opt(ctx->mount_opt, FLUSHONCOMMIT); 482 break; 483 case Opt_ratio: 484 ctx->metadata_ratio = result.uint_32; 485 break; 486 case Opt_discard: 487 if (result.negated) { 488 btrfs_clear_opt(ctx->mount_opt, DISCARD_SYNC); 489 btrfs_clear_opt(ctx->mount_opt, DISCARD_ASYNC); 490 btrfs_set_opt(ctx->mount_opt, NODISCARD); 491 } else { 492 btrfs_set_opt(ctx->mount_opt, DISCARD_SYNC); 493 btrfs_clear_opt(ctx->mount_opt, DISCARD_ASYNC); 494 } 495 break; 496 case Opt_discard_mode: 497 switch (result.uint_32) { 498 case Opt_discard_sync: 499 btrfs_clear_opt(ctx->mount_opt, DISCARD_ASYNC); 500 btrfs_set_opt(ctx->mount_opt, DISCARD_SYNC); 501 break; 502 case Opt_discard_async: 503 btrfs_clear_opt(ctx->mount_opt, DISCARD_SYNC); 504 btrfs_set_opt(ctx->mount_opt, DISCARD_ASYNC); 505 break; 506 default: 507 btrfs_err(NULL, "unrecognized discard mode value %s", 508 param->key); 509 return -EINVAL; 510 } 511 btrfs_clear_opt(ctx->mount_opt, NODISCARD); 512 break; 513 case Opt_space_cache: 514 if (!result.negated) 515 btrfs_warn(NULL, 516 "v1 space cache is deprecated, falling back to no space cache"); 517 btrfs_set_opt(ctx->mount_opt, NOSPACECACHE); 518 btrfs_clear_opt(ctx->mount_opt, SPACE_CACHE); 519 btrfs_clear_opt(ctx->mount_opt, FREE_SPACE_TREE); 520 break; 521 case Opt_space_cache_version: 522 switch (result.uint_32) { 523 case Opt_space_cache_v1: 524 btrfs_warn(NULL, 525 "v1 space cache is deprecated, falling back to no space cache"); 526 btrfs_set_opt(ctx->mount_opt, NOSPACECACHE); 527 btrfs_clear_opt(ctx->mount_opt, SPACE_CACHE); 528 btrfs_clear_opt(ctx->mount_opt, FREE_SPACE_TREE); 529 break; 530 case Opt_space_cache_v2: 531 btrfs_clear_opt(ctx->mount_opt, SPACE_CACHE); 532 btrfs_set_opt(ctx->mount_opt, FREE_SPACE_TREE); 533 break; 534 default: 535 btrfs_err(NULL, "unrecognized space_cache value %s", 536 param->key); 537 return -EINVAL; 538 } 539 break; 540 case Opt_rescan_uuid_tree: 541 btrfs_set_opt(ctx->mount_opt, RESCAN_UUID_TREE); 542 break; 543 case Opt_clear_cache: 544 btrfs_set_opt(ctx->mount_opt, CLEAR_CACHE); 545 break; 546 case Opt_user_subvol_rm_allowed: 547 btrfs_set_opt(ctx->mount_opt, USER_SUBVOL_RM_ALLOWED); 548 break; 549 case Opt_enospc_debug: 550 if (result.negated) 551 btrfs_clear_opt(ctx->mount_opt, ENOSPC_DEBUG); 552 else 553 btrfs_set_opt(ctx->mount_opt, ENOSPC_DEBUG); 554 break; 555 case Opt_defrag: 556 if (result.negated) 557 btrfs_clear_opt(ctx->mount_opt, AUTO_DEFRAG); 558 else 559 btrfs_set_opt(ctx->mount_opt, AUTO_DEFRAG); 560 break; 561 case Opt_skip_balance: 562 btrfs_set_opt(ctx->mount_opt, SKIP_BALANCE); 563 break; 564 case Opt_fatal_errors: 565 switch (result.uint_32) { 566 case Opt_fatal_errors_panic: 567 btrfs_set_opt(ctx->mount_opt, PANIC_ON_FATAL_ERROR); 568 break; 569 case Opt_fatal_errors_bug: 570 btrfs_clear_opt(ctx->mount_opt, PANIC_ON_FATAL_ERROR); 571 break; 572 default: 573 btrfs_err(NULL, "unrecognized fatal_errors value %s", 574 param->key); 575 return -EINVAL; 576 } 577 break; 578 case Opt_commit_interval: 579 ctx->commit_interval = result.uint_32; 580 if (ctx->commit_interval > BTRFS_WARNING_COMMIT_INTERVAL) { 581 btrfs_warn(NULL, "excessive commit interval %u, use with care", 582 ctx->commit_interval); 583 } 584 if (ctx->commit_interval == 0) 585 ctx->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL; 586 break; 587 case Opt_rescue: 588 switch (result.uint_32) { 589 case Opt_rescue_usebackuproot: 590 btrfs_set_opt(ctx->mount_opt, USEBACKUPROOT); 591 break; 592 case Opt_rescue_nologreplay: 593 btrfs_set_opt(ctx->mount_opt, NOLOGREPLAY); 594 break; 595 case Opt_rescue_ignorebadroots: 596 btrfs_set_opt(ctx->mount_opt, IGNOREBADROOTS); 597 break; 598 case Opt_rescue_ignoredatacsums: 599 btrfs_set_opt(ctx->mount_opt, IGNOREDATACSUMS); 600 break; 601 case Opt_rescue_ignoremetacsums: 602 btrfs_set_opt(ctx->mount_opt, IGNOREMETACSUMS); 603 break; 604 case Opt_rescue_ignoresuperflags: 605 btrfs_set_opt(ctx->mount_opt, IGNORESUPERFLAGS); 606 break; 607 case Opt_rescue_parameter_all: 608 btrfs_set_opt(ctx->mount_opt, IGNOREDATACSUMS); 609 btrfs_set_opt(ctx->mount_opt, IGNOREMETACSUMS); 610 btrfs_set_opt(ctx->mount_opt, IGNORESUPERFLAGS); 611 btrfs_set_opt(ctx->mount_opt, IGNOREBADROOTS); 612 btrfs_set_opt(ctx->mount_opt, NOLOGREPLAY); 613 btrfs_set_opt(ctx->mount_opt, USEBACKUPROOT); 614 break; 615 default: 616 btrfs_info(NULL, "unrecognized rescue option '%s'", 617 param->key); 618 return -EINVAL; 619 } 620 break; 621 #ifdef CONFIG_BTRFS_DEBUG 622 case Opt_fragment: 623 switch (result.uint_32) { 624 case Opt_fragment_parameter_all: 625 btrfs_set_opt(ctx->mount_opt, FRAGMENT_DATA); 626 btrfs_set_opt(ctx->mount_opt, FRAGMENT_METADATA); 627 break; 628 case Opt_fragment_parameter_metadata: 629 btrfs_set_opt(ctx->mount_opt, FRAGMENT_METADATA); 630 break; 631 case Opt_fragment_parameter_data: 632 btrfs_set_opt(ctx->mount_opt, FRAGMENT_DATA); 633 break; 634 default: 635 btrfs_info(NULL, "unrecognized fragment option '%s'", 636 param->key); 637 return -EINVAL; 638 } 639 break; 640 case Opt_ref_verify: 641 btrfs_set_opt(ctx->mount_opt, REF_VERIFY); 642 break; 643 case Opt_ref_tracker: 644 btrfs_set_opt(ctx->mount_opt, REF_TRACKER); 645 break; 646 #endif 647 default: 648 btrfs_err(NULL, "unrecognized mount option '%s'", param->key); 649 return -EINVAL; 650 } 651 652 return 0; 653 } 654 655 /* 656 * Some options only have meaning at mount time and shouldn't persist across 657 * remounts, or be displayed. Clear these at the end of mount and remount code 658 * paths. 659 */ 660 static void btrfs_clear_oneshot_options(struct btrfs_fs_info *fs_info) 661 { 662 btrfs_clear_opt(fs_info->mount_opt, CLEAR_CACHE); 663 btrfs_clear_opt(fs_info->mount_opt, NOSPACECACHE); 664 } 665 666 static bool check_ro_option(const struct btrfs_fs_info *fs_info, 667 unsigned long long mount_opt, unsigned long long opt, 668 const char *opt_name) 669 { 670 if (mount_opt & opt) { 671 btrfs_err(fs_info, "%s must be used with ro mount option", 672 opt_name); 673 return true; 674 } 675 return false; 676 } 677 678 bool btrfs_check_options(const struct btrfs_fs_info *info, 679 unsigned long long *mount_opt, 680 unsigned long flags) 681 { 682 bool ret = true; 683 684 if (!(flags & SB_RDONLY) && 685 (check_ro_option(info, *mount_opt, BTRFS_MOUNT_USEBACKUPROOT, "usebackuproot") || 686 check_ro_option(info, *mount_opt, BTRFS_MOUNT_NOLOGREPLAY, "nologreplay") || 687 check_ro_option(info, *mount_opt, BTRFS_MOUNT_IGNOREBADROOTS, "ignorebadroots") || 688 check_ro_option(info, *mount_opt, BTRFS_MOUNT_IGNOREDATACSUMS, "ignoredatacsums") || 689 check_ro_option(info, *mount_opt, BTRFS_MOUNT_IGNOREMETACSUMS, "ignoremetacsums") || 690 check_ro_option(info, *mount_opt, BTRFS_MOUNT_IGNORESUPERFLAGS, "ignoresuperflags"))) 691 ret = false; 692 693 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE) && 694 !btrfs_raw_test_opt(*mount_opt, FREE_SPACE_TREE) && 695 !btrfs_raw_test_opt(*mount_opt, CLEAR_CACHE)) { 696 btrfs_err(info, "cannot disable free-space-tree"); 697 ret = false; 698 } 699 if (btrfs_fs_compat_ro(info, BLOCK_GROUP_TREE) && 700 !btrfs_raw_test_opt(*mount_opt, FREE_SPACE_TREE)) { 701 btrfs_err(info, "cannot disable free-space-tree with block-group-tree feature"); 702 ret = false; 703 } 704 705 if (btrfs_check_mountopts_zoned(info, mount_opt)) 706 ret = false; 707 708 if (!test_bit(BTRFS_FS_STATE_REMOUNTING, &info->fs_state)) { 709 if (btrfs_raw_test_opt(*mount_opt, SPACE_CACHE)) { 710 btrfs_warn(info, 711 "space cache v1 is being deprecated and will be removed in a future release, please use -o space_cache=v2"); 712 } 713 } 714 715 return ret; 716 } 717 718 /* 719 * This is subtle, we only call this during open_ctree(). We need to pre-load 720 * the mount options with the on-disk settings. Before the new mount API took 721 * effect we would do this on mount and remount. With the new mount API we'll 722 * only do this on the initial mount. 723 * 724 * This isn't a change in behavior, because we're using the current state of the 725 * file system to set the current mount options. If you mounted with special 726 * options to disable these features and then remounted we wouldn't revert the 727 * settings, because mounting without these features cleared the on-disk 728 * settings, so this being called on re-mount is not needed. 729 */ 730 void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info) 731 { 732 if (fs_info->sectorsize != PAGE_SIZE && btrfs_test_opt(fs_info, SPACE_CACHE)) { 733 btrfs_info(fs_info, 734 "forcing free space tree for sector size %u with page size %lu", 735 fs_info->sectorsize, PAGE_SIZE); 736 btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE); 737 btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE); 738 } 739 740 /* 741 * At this point our mount options are populated, so we only mess with 742 * these settings if we don't have any settings already. 743 */ 744 if (btrfs_test_opt(fs_info, FREE_SPACE_TREE)) 745 return; 746 747 if (btrfs_is_zoned(fs_info) && 748 btrfs_free_space_cache_v1_active(fs_info)) { 749 btrfs_info(fs_info, "zoned: clearing existing space cache"); 750 btrfs_set_super_cache_generation(fs_info->super_copy, 0); 751 return; 752 } 753 754 if (btrfs_test_opt(fs_info, SPACE_CACHE)) 755 return; 756 757 if (btrfs_test_opt(fs_info, NOSPACECACHE)) 758 return; 759 760 /* 761 * At this point we don't have explicit options set by the user, set 762 * them ourselves based on the state of the file system. 763 */ 764 if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) 765 btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE); 766 else if (btrfs_free_space_cache_v1_active(fs_info)) 767 btrfs_set_opt(fs_info->mount_opt, SPACE_CACHE); 768 } 769 770 static void set_device_specific_options(struct btrfs_fs_info *fs_info) 771 { 772 if (!btrfs_test_opt(fs_info, NOSSD) && 773 !fs_info->fs_devices->rotating) 774 btrfs_set_opt(fs_info->mount_opt, SSD); 775 776 /* 777 * For devices supporting discard turn on discard=async automatically, 778 * unless it's already set or disabled. This could be turned off by 779 * nodiscard for the same mount. 780 * 781 * The zoned mode piggy backs on the discard functionality for 782 * resetting a zone. There is no reason to delay the zone reset as it is 783 * fast enough. So, do not enable async discard for zoned mode. 784 */ 785 if (!(btrfs_test_opt(fs_info, DISCARD_SYNC) || 786 btrfs_test_opt(fs_info, DISCARD_ASYNC) || 787 btrfs_test_opt(fs_info, NODISCARD)) && 788 fs_info->fs_devices->discardable && 789 !btrfs_is_zoned(fs_info)) 790 btrfs_set_opt(fs_info->mount_opt, DISCARD_ASYNC); 791 } 792 793 char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, 794 u64 subvol_objectid) 795 { 796 struct btrfs_root *root = fs_info->tree_root; 797 struct btrfs_root *fs_root = NULL; 798 struct btrfs_root_ref *root_ref; 799 struct btrfs_inode_ref *inode_ref; 800 struct btrfs_key key; 801 BTRFS_PATH_AUTO_FREE(path); 802 char *name = NULL, *ptr; 803 u64 dirid; 804 int len; 805 int ret; 806 807 path = btrfs_alloc_path(); 808 if (!path) 809 return ERR_PTR(-ENOMEM); 810 811 name = kmalloc(PATH_MAX, GFP_KERNEL); 812 if (!name) { 813 ret = -ENOMEM; 814 goto err; 815 } 816 ptr = name + PATH_MAX - 1; 817 ptr[0] = '\0'; 818 819 /* 820 * Walk up the subvolume trees in the tree of tree roots by root 821 * backrefs until we hit the top-level subvolume. 822 */ 823 while (subvol_objectid != BTRFS_FS_TREE_OBJECTID) { 824 key.objectid = subvol_objectid; 825 key.type = BTRFS_ROOT_BACKREF_KEY; 826 key.offset = (u64)-1; 827 828 ret = btrfs_search_backwards(root, &key, path); 829 if (ret < 0) { 830 goto err; 831 } else if (ret > 0) { 832 ret = -ENOENT; 833 goto err; 834 } 835 836 subvol_objectid = key.offset; 837 838 root_ref = btrfs_item_ptr(path->nodes[0], path->slots[0], 839 struct btrfs_root_ref); 840 len = btrfs_root_ref_name_len(path->nodes[0], root_ref); 841 ptr -= len + 1; 842 if (ptr < name) { 843 ret = -ENAMETOOLONG; 844 goto err; 845 } 846 read_extent_buffer(path->nodes[0], ptr + 1, 847 (unsigned long)(root_ref + 1), len); 848 ptr[0] = '/'; 849 dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref); 850 btrfs_release_path(path); 851 852 fs_root = btrfs_get_fs_root(fs_info, subvol_objectid, true); 853 if (IS_ERR(fs_root)) { 854 ret = PTR_ERR(fs_root); 855 fs_root = NULL; 856 goto err; 857 } 858 859 /* 860 * Walk up the filesystem tree by inode refs until we hit the 861 * root directory. 862 */ 863 while (dirid != BTRFS_FIRST_FREE_OBJECTID) { 864 key.objectid = dirid; 865 key.type = BTRFS_INODE_REF_KEY; 866 key.offset = (u64)-1; 867 868 ret = btrfs_search_backwards(fs_root, &key, path); 869 if (ret < 0) { 870 goto err; 871 } else if (ret > 0) { 872 ret = -ENOENT; 873 goto err; 874 } 875 876 dirid = key.offset; 877 878 inode_ref = btrfs_item_ptr(path->nodes[0], 879 path->slots[0], 880 struct btrfs_inode_ref); 881 len = btrfs_inode_ref_name_len(path->nodes[0], 882 inode_ref); 883 ptr -= len + 1; 884 if (ptr < name) { 885 ret = -ENAMETOOLONG; 886 goto err; 887 } 888 read_extent_buffer(path->nodes[0], ptr + 1, 889 (unsigned long)(inode_ref + 1), len); 890 ptr[0] = '/'; 891 btrfs_release_path(path); 892 } 893 btrfs_put_root(fs_root); 894 fs_root = NULL; 895 } 896 897 if (ptr == name + PATH_MAX - 1) { 898 name[0] = '/'; 899 name[1] = '\0'; 900 } else { 901 memmove(name, ptr, name + PATH_MAX - ptr); 902 } 903 return name; 904 905 err: 906 btrfs_put_root(fs_root); 907 kfree(name); 908 return ERR_PTR(ret); 909 } 910 911 static int get_default_subvol_objectid(struct btrfs_fs_info *fs_info, u64 *objectid) 912 { 913 struct btrfs_root *root = fs_info->tree_root; 914 struct btrfs_dir_item *di; 915 BTRFS_PATH_AUTO_FREE(path); 916 struct btrfs_key location; 917 struct fscrypt_str name = FSTR_INIT("default", 7); 918 u64 dir_id; 919 920 path = btrfs_alloc_path(); 921 if (!path) 922 return -ENOMEM; 923 924 /* 925 * Find the "default" dir item which points to the root item that we 926 * will mount by default if we haven't been given a specific subvolume 927 * to mount. 928 */ 929 dir_id = btrfs_super_root_dir(fs_info->super_copy); 930 di = btrfs_lookup_dir_item(NULL, root, path, dir_id, &name, 0); 931 if (IS_ERR(di)) { 932 return PTR_ERR(di); 933 } 934 if (!di) { 935 /* 936 * Ok the default dir item isn't there. This is weird since 937 * it's always been there, but don't freak out, just try and 938 * mount the top-level subvolume. 939 */ 940 *objectid = BTRFS_FS_TREE_OBJECTID; 941 return 0; 942 } 943 944 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location); 945 *objectid = location.objectid; 946 return 0; 947 } 948 949 static int btrfs_fill_super(struct super_block *sb, 950 struct btrfs_fs_devices *fs_devices) 951 { 952 struct btrfs_inode *inode; 953 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 954 int ret; 955 956 sb->s_maxbytes = MAX_LFS_FILESIZE; 957 sb->s_magic = BTRFS_SUPER_MAGIC; 958 sb->s_op = &btrfs_super_ops; 959 set_default_d_op(sb, &btrfs_dentry_operations); 960 sb->s_export_op = &btrfs_export_ops; 961 #ifdef CONFIG_FS_VERITY 962 sb->s_vop = &btrfs_verityops; 963 #endif 964 sb->s_xattr = btrfs_xattr_handlers; 965 sb->s_time_gran = 1; 966 sb->s_iflags |= SB_I_CGROUPWB | SB_I_ALLOW_HSM; 967 968 ret = super_setup_bdi(sb); 969 if (ret) { 970 btrfs_err(fs_info, "super_setup_bdi failed"); 971 return ret; 972 } 973 974 ret = open_ctree(sb, fs_devices); 975 if (ret) { 976 btrfs_err(fs_info, "open_ctree failed: %pe", ERR_PTR(ret)); 977 return ret; 978 } 979 980 btrfs_emit_options(fs_info, NULL); 981 982 inode = btrfs_iget(BTRFS_FIRST_FREE_OBJECTID, fs_info->fs_root); 983 if (IS_ERR(inode)) { 984 ret = PTR_ERR(inode); 985 btrfs_handle_fs_error(fs_info, ret, NULL); 986 goto fail_close; 987 } 988 989 sb->s_root = d_make_root(&inode->vfs_inode); 990 if (!sb->s_root) { 991 ret = -ENOMEM; 992 goto fail_close; 993 } 994 995 sb->s_flags |= SB_ACTIVE; 996 return 0; 997 998 fail_close: 999 close_ctree(fs_info); 1000 return ret; 1001 } 1002 1003 int btrfs_sync_fs(struct super_block *sb, int wait) 1004 { 1005 struct btrfs_trans_handle *trans; 1006 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 1007 struct btrfs_root *root = fs_info->tree_root; 1008 1009 trace_btrfs_sync_fs(fs_info, wait); 1010 1011 if (!wait) { 1012 filemap_flush(fs_info->btree_inode->i_mapping); 1013 return 0; 1014 } 1015 1016 btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL); 1017 1018 trans = btrfs_attach_transaction_barrier(root); 1019 if (IS_ERR(trans)) { 1020 /* no transaction, don't bother */ 1021 if (PTR_ERR(trans) == -ENOENT) { 1022 /* 1023 * Exit unless we have some pending changes 1024 * that need to go through commit 1025 */ 1026 if (!test_bit(BTRFS_FS_NEED_TRANS_COMMIT, 1027 &fs_info->flags)) 1028 return 0; 1029 /* 1030 * A non-blocking test if the fs is frozen. We must not 1031 * start a new transaction here otherwise a deadlock 1032 * happens. The pending operations are delayed to the 1033 * next commit after thawing. 1034 */ 1035 if (sb_start_write_trylock(sb)) 1036 sb_end_write(sb); 1037 else 1038 return 0; 1039 trans = btrfs_start_transaction(root, 0); 1040 } 1041 if (IS_ERR(trans)) 1042 return PTR_ERR(trans); 1043 } 1044 return btrfs_commit_transaction(trans); 1045 } 1046 1047 static void print_rescue_option(struct seq_file *seq, const char *s, bool *printed) 1048 { 1049 seq_printf(seq, "%s%s", (*printed) ? ":" : ",rescue=", s); 1050 *printed = true; 1051 } 1052 1053 static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry) 1054 { 1055 struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb); 1056 const char *compress_type; 1057 const char *subvol_name; 1058 bool printed = false; 1059 1060 if (btrfs_test_opt(info, DEGRADED)) 1061 seq_puts(seq, ",degraded"); 1062 if (btrfs_test_opt(info, NODATASUM)) 1063 seq_puts(seq, ",nodatasum"); 1064 if (btrfs_test_opt(info, NODATACOW)) 1065 seq_puts(seq, ",nodatacow"); 1066 if (btrfs_test_opt(info, NOBARRIER)) 1067 seq_puts(seq, ",nobarrier"); 1068 if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE) 1069 seq_printf(seq, ",max_inline=%llu", info->max_inline); 1070 if (info->thread_pool_size != min_t(unsigned long, 1071 num_online_cpus() + 2, 8)) 1072 seq_printf(seq, ",thread_pool=%u", info->thread_pool_size); 1073 if (btrfs_test_opt(info, COMPRESS)) { 1074 compress_type = btrfs_compress_type2str(info->compress_type); 1075 if (btrfs_test_opt(info, FORCE_COMPRESS)) 1076 seq_printf(seq, ",compress-force=%s", compress_type); 1077 else 1078 seq_printf(seq, ",compress=%s", compress_type); 1079 if (info->compress_level && info->compress_type != BTRFS_COMPRESS_LZO) 1080 seq_printf(seq, ":%d", info->compress_level); 1081 } 1082 if (btrfs_test_opt(info, NOSSD)) 1083 seq_puts(seq, ",nossd"); 1084 if (btrfs_test_opt(info, SSD_SPREAD)) 1085 seq_puts(seq, ",ssd_spread"); 1086 else if (btrfs_test_opt(info, SSD)) 1087 seq_puts(seq, ",ssd"); 1088 if (btrfs_test_opt(info, NOTREELOG)) 1089 seq_puts(seq, ",notreelog"); 1090 if (btrfs_test_opt(info, NOLOGREPLAY)) 1091 print_rescue_option(seq, "nologreplay", &printed); 1092 if (btrfs_test_opt(info, USEBACKUPROOT)) 1093 print_rescue_option(seq, "usebackuproot", &printed); 1094 if (btrfs_test_opt(info, IGNOREBADROOTS)) 1095 print_rescue_option(seq, "ignorebadroots", &printed); 1096 if (btrfs_test_opt(info, IGNOREDATACSUMS)) 1097 print_rescue_option(seq, "ignoredatacsums", &printed); 1098 if (btrfs_test_opt(info, IGNOREMETACSUMS)) 1099 print_rescue_option(seq, "ignoremetacsums", &printed); 1100 if (btrfs_test_opt(info, IGNORESUPERFLAGS)) 1101 print_rescue_option(seq, "ignoresuperflags", &printed); 1102 if (btrfs_test_opt(info, FLUSHONCOMMIT)) 1103 seq_puts(seq, ",flushoncommit"); 1104 if (btrfs_test_opt(info, DISCARD_SYNC)) 1105 seq_puts(seq, ",discard"); 1106 if (btrfs_test_opt(info, DISCARD_ASYNC)) 1107 seq_puts(seq, ",discard=async"); 1108 if (!(info->sb->s_flags & SB_POSIXACL)) 1109 seq_puts(seq, ",noacl"); 1110 if (btrfs_free_space_cache_v1_active(info)) 1111 seq_puts(seq, ",space_cache"); 1112 else if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) 1113 seq_puts(seq, ",space_cache=v2"); 1114 else 1115 seq_puts(seq, ",nospace_cache"); 1116 if (btrfs_test_opt(info, RESCAN_UUID_TREE)) 1117 seq_puts(seq, ",rescan_uuid_tree"); 1118 if (btrfs_test_opt(info, CLEAR_CACHE)) 1119 seq_puts(seq, ",clear_cache"); 1120 if (btrfs_test_opt(info, USER_SUBVOL_RM_ALLOWED)) 1121 seq_puts(seq, ",user_subvol_rm_allowed"); 1122 if (btrfs_test_opt(info, ENOSPC_DEBUG)) 1123 seq_puts(seq, ",enospc_debug"); 1124 if (btrfs_test_opt(info, AUTO_DEFRAG)) 1125 seq_puts(seq, ",autodefrag"); 1126 if (btrfs_test_opt(info, SKIP_BALANCE)) 1127 seq_puts(seq, ",skip_balance"); 1128 if (info->metadata_ratio) 1129 seq_printf(seq, ",metadata_ratio=%u", info->metadata_ratio); 1130 if (btrfs_test_opt(info, PANIC_ON_FATAL_ERROR)) 1131 seq_puts(seq, ",fatal_errors=panic"); 1132 if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL) 1133 seq_printf(seq, ",commit=%u", info->commit_interval); 1134 #ifdef CONFIG_BTRFS_DEBUG 1135 if (btrfs_test_opt(info, FRAGMENT_DATA)) 1136 seq_puts(seq, ",fragment=data"); 1137 if (btrfs_test_opt(info, FRAGMENT_METADATA)) 1138 seq_puts(seq, ",fragment=metadata"); 1139 #endif 1140 if (btrfs_test_opt(info, REF_VERIFY)) 1141 seq_puts(seq, ",ref_verify"); 1142 if (btrfs_test_opt(info, REF_TRACKER)) 1143 seq_puts(seq, ",ref_tracker"); 1144 seq_printf(seq, ",subvolid=%llu", btrfs_root_id(BTRFS_I(d_inode(dentry))->root)); 1145 subvol_name = btrfs_get_subvol_name_from_objectid(info, 1146 btrfs_root_id(BTRFS_I(d_inode(dentry))->root)); 1147 if (!IS_ERR(subvol_name)) { 1148 seq_show_option(seq, "subvol", subvol_name); 1149 kfree(subvol_name); 1150 } 1151 return 0; 1152 } 1153 1154 /* 1155 * subvolumes are identified by ino 256 1156 */ 1157 static inline bool is_subvolume_inode(struct inode *inode) 1158 { 1159 if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID) 1160 return true; 1161 return false; 1162 } 1163 1164 static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid, 1165 struct vfsmount *mnt) 1166 { 1167 struct dentry *root; 1168 int ret; 1169 1170 if (!subvol_name) { 1171 if (!subvol_objectid) { 1172 ret = get_default_subvol_objectid(btrfs_sb(mnt->mnt_sb), 1173 &subvol_objectid); 1174 if (ret) { 1175 root = ERR_PTR(ret); 1176 goto out; 1177 } 1178 } 1179 subvol_name = btrfs_get_subvol_name_from_objectid( 1180 btrfs_sb(mnt->mnt_sb), subvol_objectid); 1181 if (IS_ERR(subvol_name)) { 1182 root = ERR_CAST(subvol_name); 1183 subvol_name = NULL; 1184 goto out; 1185 } 1186 1187 } 1188 1189 root = mount_subtree(mnt, subvol_name); 1190 /* mount_subtree() drops our reference on the vfsmount. */ 1191 mnt = NULL; 1192 1193 if (!IS_ERR(root)) { 1194 struct super_block *s = root->d_sb; 1195 struct btrfs_fs_info *fs_info = btrfs_sb(s); 1196 struct inode *root_inode = d_inode(root); 1197 u64 root_objectid = btrfs_root_id(BTRFS_I(root_inode)->root); 1198 1199 ret = 0; 1200 if (!is_subvolume_inode(root_inode)) { 1201 btrfs_err(fs_info, "'%s' is not a valid subvolume", 1202 subvol_name); 1203 ret = -EINVAL; 1204 } 1205 if (subvol_objectid && root_objectid != subvol_objectid) { 1206 /* 1207 * This will also catch a race condition where a 1208 * subvolume which was passed by ID is renamed and 1209 * another subvolume is renamed over the old location. 1210 */ 1211 btrfs_err(fs_info, 1212 "subvol '%s' does not match subvolid %llu", 1213 subvol_name, subvol_objectid); 1214 ret = -EINVAL; 1215 } 1216 if (ret) { 1217 dput(root); 1218 root = ERR_PTR(ret); 1219 deactivate_locked_super(s); 1220 } 1221 } 1222 1223 out: 1224 mntput(mnt); 1225 kfree(subvol_name); 1226 return root; 1227 } 1228 1229 static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info, 1230 u32 new_pool_size, u32 old_pool_size) 1231 { 1232 if (new_pool_size == old_pool_size) 1233 return; 1234 1235 fs_info->thread_pool_size = new_pool_size; 1236 1237 btrfs_info(fs_info, "resize thread pool %d -> %d", 1238 old_pool_size, new_pool_size); 1239 1240 btrfs_workqueue_set_max(fs_info->workers, new_pool_size); 1241 btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size); 1242 btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size); 1243 workqueue_set_max_active(fs_info->endio_workers, new_pool_size); 1244 workqueue_set_max_active(fs_info->endio_meta_workers, new_pool_size); 1245 btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size); 1246 btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size); 1247 btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size); 1248 } 1249 1250 static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info, 1251 unsigned long long old_opts, int flags) 1252 { 1253 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) && 1254 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || 1255 (flags & SB_RDONLY))) { 1256 /* wait for any defraggers to finish */ 1257 wait_event(fs_info->transaction_wait, 1258 (atomic_read(&fs_info->defrag_running) == 0)); 1259 if (flags & SB_RDONLY) 1260 sync_filesystem(fs_info->sb); 1261 } 1262 } 1263 1264 static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info, 1265 unsigned long long old_opts) 1266 { 1267 const bool cache_opt = btrfs_test_opt(fs_info, SPACE_CACHE); 1268 1269 /* 1270 * We need to cleanup all defraggable inodes if the autodefragment is 1271 * close or the filesystem is read only. 1272 */ 1273 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) && 1274 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || sb_rdonly(fs_info->sb))) { 1275 btrfs_cleanup_defrag_inodes(fs_info); 1276 } 1277 1278 /* If we toggled discard async */ 1279 if (!btrfs_raw_test_opt(old_opts, DISCARD_ASYNC) && 1280 btrfs_test_opt(fs_info, DISCARD_ASYNC)) 1281 btrfs_discard_resume(fs_info); 1282 else if (btrfs_raw_test_opt(old_opts, DISCARD_ASYNC) && 1283 !btrfs_test_opt(fs_info, DISCARD_ASYNC)) 1284 btrfs_discard_cleanup(fs_info); 1285 1286 /* If we toggled space cache */ 1287 if (cache_opt != btrfs_free_space_cache_v1_active(fs_info)) 1288 btrfs_set_free_space_cache_v1_active(fs_info, cache_opt); 1289 } 1290 1291 static int btrfs_remount_rw(struct btrfs_fs_info *fs_info) 1292 { 1293 int ret; 1294 1295 if (unlikely(BTRFS_FS_ERROR(fs_info))) { 1296 btrfs_err(fs_info, 1297 "remounting read-write after error is not allowed"); 1298 return -EINVAL; 1299 } 1300 1301 if (fs_info->fs_devices->rw_devices == 0) 1302 return -EACCES; 1303 1304 if (!btrfs_check_rw_degradable(fs_info, NULL)) { 1305 btrfs_warn(fs_info, 1306 "too many missing devices, writable remount is not allowed"); 1307 return -EACCES; 1308 } 1309 1310 if (btrfs_super_log_root(fs_info->super_copy) != 0) { 1311 btrfs_warn(fs_info, 1312 "mount required to replay tree-log, cannot remount read-write"); 1313 return -EINVAL; 1314 } 1315 1316 /* 1317 * NOTE: when remounting with a change that does writes, don't put it 1318 * anywhere above this point, as we are not sure to be safe to write 1319 * until we pass the above checks. 1320 */ 1321 ret = btrfs_start_pre_rw_mount(fs_info); 1322 if (ret) 1323 return ret; 1324 1325 btrfs_clear_sb_rdonly(fs_info->sb); 1326 1327 set_bit(BTRFS_FS_OPEN, &fs_info->flags); 1328 1329 /* 1330 * If we've gone from readonly -> read-write, we need to get our 1331 * sync/async discard lists in the right state. 1332 */ 1333 btrfs_discard_resume(fs_info); 1334 1335 return 0; 1336 } 1337 1338 static int btrfs_remount_ro(struct btrfs_fs_info *fs_info) 1339 { 1340 /* 1341 * This also happens on 'umount -rf' or on shutdown, when the 1342 * filesystem is busy. 1343 */ 1344 cancel_work_sync(&fs_info->async_reclaim_work); 1345 cancel_work_sync(&fs_info->async_data_reclaim_work); 1346 1347 btrfs_discard_cleanup(fs_info); 1348 1349 /* Wait for the uuid_scan task to finish */ 1350 down(&fs_info->uuid_tree_rescan_sem); 1351 /* Avoid complains from lockdep et al. */ 1352 up(&fs_info->uuid_tree_rescan_sem); 1353 1354 btrfs_set_sb_rdonly(fs_info->sb); 1355 1356 /* 1357 * Setting SB_RDONLY will put the cleaner thread to sleep at the next 1358 * loop if it's already active. If it's already asleep, we'll leave 1359 * unused block groups on disk until we're mounted read-write again 1360 * unless we clean them up here. 1361 */ 1362 btrfs_delete_unused_bgs(fs_info); 1363 1364 /* 1365 * The cleaner task could be already running before we set the flag 1366 * BTRFS_FS_STATE_RO (and SB_RDONLY in the superblock). We must make 1367 * sure that after we finish the remount, i.e. after we call 1368 * btrfs_commit_super(), the cleaner can no longer start a transaction 1369 * - either because it was dropping a dead root, running delayed iputs 1370 * or deleting an unused block group (the cleaner picked a block 1371 * group from the list of unused block groups before we were able to 1372 * in the previous call to btrfs_delete_unused_bgs()). 1373 */ 1374 wait_on_bit(&fs_info->flags, BTRFS_FS_CLEANER_RUNNING, TASK_UNINTERRUPTIBLE); 1375 1376 /* 1377 * We've set the superblock to RO mode, so we might have made the 1378 * cleaner task sleep without running all pending delayed iputs. Go 1379 * through all the delayed iputs here, so that if an unmount happens 1380 * without remounting RW we don't end up at finishing close_ctree() 1381 * with a non-empty list of delayed iputs. 1382 */ 1383 btrfs_run_delayed_iputs(fs_info); 1384 1385 btrfs_dev_replace_suspend_for_unmount(fs_info); 1386 btrfs_scrub_cancel(fs_info); 1387 btrfs_pause_balance(fs_info); 1388 1389 /* 1390 * Pause the qgroup rescan worker if it is running. We don't want it to 1391 * be still running after we are in RO mode, as after that, by the time 1392 * we unmount, it might have left a transaction open, so we would leak 1393 * the transaction and/or crash. 1394 */ 1395 btrfs_qgroup_wait_for_completion(fs_info, false); 1396 1397 return btrfs_commit_super(fs_info); 1398 } 1399 1400 static void btrfs_ctx_to_info(struct btrfs_fs_info *fs_info, struct btrfs_fs_context *ctx) 1401 { 1402 fs_info->max_inline = ctx->max_inline; 1403 fs_info->commit_interval = ctx->commit_interval; 1404 fs_info->metadata_ratio = ctx->metadata_ratio; 1405 fs_info->thread_pool_size = ctx->thread_pool_size; 1406 fs_info->mount_opt = ctx->mount_opt; 1407 fs_info->compress_type = ctx->compress_type; 1408 fs_info->compress_level = ctx->compress_level; 1409 } 1410 1411 static void btrfs_info_to_ctx(struct btrfs_fs_info *fs_info, struct btrfs_fs_context *ctx) 1412 { 1413 ctx->max_inline = fs_info->max_inline; 1414 ctx->commit_interval = fs_info->commit_interval; 1415 ctx->metadata_ratio = fs_info->metadata_ratio; 1416 ctx->thread_pool_size = fs_info->thread_pool_size; 1417 ctx->mount_opt = fs_info->mount_opt; 1418 ctx->compress_type = fs_info->compress_type; 1419 ctx->compress_level = fs_info->compress_level; 1420 } 1421 1422 #define btrfs_info_if_set(fs_info, old_ctx, opt, fmt, args...) \ 1423 do { \ 1424 if ((!old_ctx || !btrfs_raw_test_opt(old_ctx->mount_opt, opt)) && \ 1425 btrfs_raw_test_opt(fs_info->mount_opt, opt)) \ 1426 btrfs_info(fs_info, fmt, ##args); \ 1427 } while (0) 1428 1429 #define btrfs_info_if_unset(fs_info, old_ctx, opt, fmt, args...) \ 1430 do { \ 1431 if ((old_ctx && btrfs_raw_test_opt(old_ctx->mount_opt, opt)) && \ 1432 !btrfs_raw_test_opt(fs_info->mount_opt, opt)) \ 1433 btrfs_info(fs_info, fmt, ##args); \ 1434 } while (0) 1435 1436 static void btrfs_emit_options(struct btrfs_fs_info *info, 1437 struct btrfs_fs_context *old) 1438 { 1439 btrfs_info_if_set(info, old, NODATASUM, "setting nodatasum"); 1440 btrfs_info_if_set(info, old, DEGRADED, "allowing degraded mounts"); 1441 btrfs_info_if_set(info, old, NODATACOW, "setting nodatacow"); 1442 btrfs_info_if_set(info, old, SSD, "enabling ssd optimizations"); 1443 btrfs_info_if_set(info, old, SSD_SPREAD, "using spread ssd allocation scheme"); 1444 btrfs_info_if_set(info, old, NOBARRIER, "turning off barriers"); 1445 btrfs_info_if_set(info, old, NOTREELOG, "disabling tree log"); 1446 btrfs_info_if_set(info, old, NOLOGREPLAY, "disabling log replay at mount time"); 1447 btrfs_info_if_set(info, old, FLUSHONCOMMIT, "turning on flush-on-commit"); 1448 btrfs_info_if_set(info, old, DISCARD_SYNC, "turning on sync discard"); 1449 btrfs_info_if_set(info, old, DISCARD_ASYNC, "turning on async discard"); 1450 btrfs_info_if_set(info, old, FREE_SPACE_TREE, "enabling free space tree"); 1451 btrfs_info_if_set(info, old, SPACE_CACHE, "enabling disk space caching"); 1452 btrfs_info_if_set(info, old, CLEAR_CACHE, "force clearing of disk cache"); 1453 btrfs_info_if_set(info, old, AUTO_DEFRAG, "enabling auto defrag"); 1454 btrfs_info_if_set(info, old, FRAGMENT_DATA, "fragmenting data"); 1455 btrfs_info_if_set(info, old, FRAGMENT_METADATA, "fragmenting metadata"); 1456 btrfs_info_if_set(info, old, REF_VERIFY, "doing ref verification"); 1457 btrfs_info_if_set(info, old, USEBACKUPROOT, "trying to use backup root at mount time"); 1458 btrfs_info_if_set(info, old, IGNOREBADROOTS, "ignoring bad roots"); 1459 btrfs_info_if_set(info, old, IGNOREDATACSUMS, "ignoring data csums"); 1460 btrfs_info_if_set(info, old, IGNOREMETACSUMS, "ignoring meta csums"); 1461 btrfs_info_if_set(info, old, IGNORESUPERFLAGS, "ignoring unknown super block flags"); 1462 1463 btrfs_info_if_unset(info, old, NODATASUM, "setting datasum"); 1464 btrfs_info_if_unset(info, old, NODATACOW, "setting datacow"); 1465 btrfs_info_if_unset(info, old, SSD, "not using ssd optimizations"); 1466 btrfs_info_if_unset(info, old, SSD_SPREAD, "not using spread ssd allocation scheme"); 1467 btrfs_info_if_unset(info, old, NOBARRIER, "turning on barriers"); 1468 btrfs_info_if_unset(info, old, NOTREELOG, "enabling tree log"); 1469 btrfs_info_if_unset(info, old, SPACE_CACHE, "disabling disk space caching"); 1470 btrfs_info_if_unset(info, old, FREE_SPACE_TREE, "disabling free space tree"); 1471 btrfs_info_if_unset(info, old, AUTO_DEFRAG, "disabling auto defrag"); 1472 btrfs_info_if_unset(info, old, COMPRESS, "use no compression"); 1473 1474 /* Did the compression settings change? */ 1475 if (btrfs_test_opt(info, COMPRESS) && 1476 (!old || 1477 old->compress_type != info->compress_type || 1478 old->compress_level != info->compress_level || 1479 (!btrfs_raw_test_opt(old->mount_opt, FORCE_COMPRESS) && 1480 btrfs_raw_test_opt(info->mount_opt, FORCE_COMPRESS)))) { 1481 const char *compress_type = btrfs_compress_type2str(info->compress_type); 1482 1483 btrfs_info(info, "%s %s compression, level %d", 1484 btrfs_test_opt(info, FORCE_COMPRESS) ? "force" : "use", 1485 compress_type, info->compress_level); 1486 } 1487 1488 if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE) 1489 btrfs_info(info, "max_inline set to %llu", info->max_inline); 1490 } 1491 1492 static int btrfs_reconfigure(struct fs_context *fc) 1493 { 1494 struct super_block *sb = fc->root->d_sb; 1495 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 1496 struct btrfs_fs_context *ctx = fc->fs_private; 1497 struct btrfs_fs_context old_ctx; 1498 int ret = 0; 1499 bool mount_reconfigure = (fc->s_fs_info != NULL); 1500 1501 btrfs_info_to_ctx(fs_info, &old_ctx); 1502 1503 /* 1504 * This is our "bind mount" trick, we don't want to allow the user to do 1505 * anything other than mount a different ro/rw and a different subvol, 1506 * all of the mount options should be maintained. 1507 */ 1508 if (mount_reconfigure) 1509 ctx->mount_opt = old_ctx.mount_opt; 1510 1511 sync_filesystem(sb); 1512 set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state); 1513 1514 if (!btrfs_check_options(fs_info, &ctx->mount_opt, fc->sb_flags)) { 1515 ret = -EINVAL; 1516 goto restore; 1517 } 1518 1519 ret = btrfs_check_features(fs_info, !(fc->sb_flags & SB_RDONLY)); 1520 if (ret < 0) 1521 goto restore; 1522 1523 btrfs_ctx_to_info(fs_info, ctx); 1524 btrfs_remount_begin(fs_info, old_ctx.mount_opt, fc->sb_flags); 1525 btrfs_resize_thread_pool(fs_info, fs_info->thread_pool_size, 1526 old_ctx.thread_pool_size); 1527 1528 if ((bool)btrfs_test_opt(fs_info, FREE_SPACE_TREE) != 1529 (bool)btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) && 1530 (!sb_rdonly(sb) || (fc->sb_flags & SB_RDONLY))) { 1531 btrfs_warn(fs_info, 1532 "remount supports changing free space tree only from RO to RW"); 1533 /* Make sure free space cache options match the state on disk. */ 1534 if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) { 1535 btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE); 1536 btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE); 1537 } 1538 if (btrfs_free_space_cache_v1_active(fs_info)) { 1539 btrfs_clear_opt(fs_info->mount_opt, FREE_SPACE_TREE); 1540 btrfs_set_opt(fs_info->mount_opt, SPACE_CACHE); 1541 } 1542 } 1543 1544 ret = 0; 1545 if (!sb_rdonly(sb) && (fc->sb_flags & SB_RDONLY)) 1546 ret = btrfs_remount_ro(fs_info); 1547 else if (sb_rdonly(sb) && !(fc->sb_flags & SB_RDONLY)) 1548 ret = btrfs_remount_rw(fs_info); 1549 if (ret) 1550 goto restore; 1551 1552 /* 1553 * If we set the mask during the parameter parsing VFS would reject the 1554 * remount. Here we can set the mask and the value will be updated 1555 * appropriately. 1556 */ 1557 if ((fc->sb_flags & SB_POSIXACL) != (sb->s_flags & SB_POSIXACL)) 1558 fc->sb_flags_mask |= SB_POSIXACL; 1559 1560 btrfs_emit_options(fs_info, &old_ctx); 1561 wake_up_process(fs_info->transaction_kthread); 1562 btrfs_remount_cleanup(fs_info, old_ctx.mount_opt); 1563 btrfs_clear_oneshot_options(fs_info); 1564 clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state); 1565 1566 return 0; 1567 restore: 1568 btrfs_ctx_to_info(fs_info, &old_ctx); 1569 btrfs_remount_cleanup(fs_info, old_ctx.mount_opt); 1570 clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state); 1571 return ret; 1572 } 1573 1574 /* Used to sort the devices by max_avail(descending sort) */ 1575 static int btrfs_cmp_device_free_bytes(const void *a, const void *b) 1576 { 1577 const struct btrfs_device_info *dev_info1 = a; 1578 const struct btrfs_device_info *dev_info2 = b; 1579 1580 if (dev_info1->max_avail > dev_info2->max_avail) 1581 return -1; 1582 else if (dev_info1->max_avail < dev_info2->max_avail) 1583 return 1; 1584 return 0; 1585 } 1586 1587 /* 1588 * sort the devices by max_avail, in which max free extent size of each device 1589 * is stored.(Descending Sort) 1590 */ 1591 static inline void btrfs_descending_sort_devices( 1592 struct btrfs_device_info *devices, 1593 size_t nr_devices) 1594 { 1595 sort(devices, nr_devices, sizeof(struct btrfs_device_info), 1596 btrfs_cmp_device_free_bytes, NULL); 1597 } 1598 1599 /* 1600 * The helper to calc the free space on the devices that can be used to store 1601 * file data. 1602 */ 1603 static inline int btrfs_calc_avail_data_space(struct btrfs_fs_info *fs_info, 1604 u64 *free_bytes) 1605 { 1606 struct btrfs_device_info AUTO_KFREE(devices_info); 1607 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 1608 struct btrfs_device *device; 1609 u64 type; 1610 u64 avail_space; 1611 u64 min_stripe_size; 1612 int num_stripes = 1; 1613 int i = 0, nr_devices; 1614 const struct btrfs_raid_attr *rattr; 1615 1616 /* 1617 * We aren't under the device list lock, so this is racy-ish, but good 1618 * enough for our purposes. 1619 */ 1620 nr_devices = fs_info->fs_devices->open_devices; 1621 if (!nr_devices) { 1622 smp_mb(); 1623 nr_devices = fs_info->fs_devices->open_devices; 1624 ASSERT(nr_devices); 1625 if (!nr_devices) { 1626 *free_bytes = 0; 1627 return 0; 1628 } 1629 } 1630 1631 devices_info = kmalloc_objs(*devices_info, nr_devices); 1632 if (!devices_info) 1633 return -ENOMEM; 1634 1635 /* calc min stripe number for data space allocation */ 1636 type = btrfs_data_alloc_profile(fs_info); 1637 rattr = &btrfs_raid_array[btrfs_bg_flags_to_raid_index(type)]; 1638 1639 if (type & BTRFS_BLOCK_GROUP_RAID0) 1640 num_stripes = nr_devices; 1641 else if (type & BTRFS_BLOCK_GROUP_RAID1_MASK) 1642 num_stripes = rattr->ncopies; 1643 else if (type & BTRFS_BLOCK_GROUP_RAID10) 1644 num_stripes = 4; 1645 1646 /* Adjust for more than 1 stripe per device */ 1647 min_stripe_size = rattr->dev_stripes * BTRFS_STRIPE_LEN; 1648 1649 rcu_read_lock(); 1650 list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) { 1651 if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, 1652 &device->dev_state) || 1653 !device->bdev || 1654 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) 1655 continue; 1656 1657 if (i >= nr_devices) 1658 break; 1659 1660 avail_space = device->total_bytes - device->bytes_used; 1661 1662 /* align with stripe_len */ 1663 avail_space = rounddown(avail_space, BTRFS_STRIPE_LEN); 1664 1665 /* 1666 * Ensure we have at least min_stripe_size on top of the 1667 * reserved space on the device. 1668 */ 1669 if (avail_space <= BTRFS_DEVICE_RANGE_RESERVED + min_stripe_size) 1670 continue; 1671 1672 avail_space -= BTRFS_DEVICE_RANGE_RESERVED; 1673 1674 devices_info[i].dev = device; 1675 devices_info[i].max_avail = avail_space; 1676 1677 i++; 1678 } 1679 rcu_read_unlock(); 1680 1681 nr_devices = i; 1682 1683 btrfs_descending_sort_devices(devices_info, nr_devices); 1684 1685 i = nr_devices - 1; 1686 avail_space = 0; 1687 while (nr_devices >= rattr->devs_min) { 1688 num_stripes = min(num_stripes, nr_devices); 1689 1690 if (devices_info[i].max_avail >= min_stripe_size) { 1691 int j; 1692 u64 alloc_size; 1693 1694 avail_space += devices_info[i].max_avail * num_stripes; 1695 alloc_size = devices_info[i].max_avail; 1696 for (j = i + 1 - num_stripes; j <= i; j++) 1697 devices_info[j].max_avail -= alloc_size; 1698 } 1699 i--; 1700 nr_devices--; 1701 } 1702 1703 *free_bytes = avail_space; 1704 return 0; 1705 } 1706 1707 /* 1708 * Calculate numbers for 'df', pessimistic in case of mixed raid profiles. 1709 * 1710 * If there's a redundant raid level at DATA block groups, use the respective 1711 * multiplier to scale the sizes. 1712 * 1713 * Unused device space usage is based on simulating the chunk allocator 1714 * algorithm that respects the device sizes and order of allocations. This is 1715 * a close approximation of the actual use but there are other factors that may 1716 * change the result (like a new metadata chunk). 1717 * 1718 * If metadata is exhausted, f_bavail will be 0. 1719 */ 1720 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf) 1721 { 1722 struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb); 1723 struct btrfs_super_block *disk_super = fs_info->super_copy; 1724 struct btrfs_space_info *found; 1725 u64 total_used = 0; 1726 u64 total_free_data = 0; 1727 u64 total_free_meta = 0; 1728 u32 bits = fs_info->sectorsize_bits; 1729 __be32 *fsid; 1730 unsigned factor = 1; 1731 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 1732 int ret; 1733 u64 thresh = 0; 1734 bool mixed = false; 1735 __kernel_fsid_t f_fsid; 1736 1737 list_for_each_entry(found, &fs_info->space_info, list) { 1738 if (found->flags & BTRFS_BLOCK_GROUP_DATA && 1739 found->subgroup_id != BTRFS_SUB_GROUP_DATA_RELOC) { 1740 int i; 1741 1742 total_free_data += found->disk_total - found->disk_used; 1743 total_free_data -= 1744 btrfs_account_ro_block_groups_free_space(found); 1745 1746 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) { 1747 if (!list_empty(&found->block_groups[i])) 1748 factor = btrfs_bg_type_to_factor( 1749 btrfs_raid_array[i].bg_flag); 1750 } 1751 } 1752 1753 /* 1754 * Metadata in mixed block group profiles are accounted in data 1755 */ 1756 if (!mixed && found->flags & BTRFS_BLOCK_GROUP_METADATA) { 1757 if (found->flags & BTRFS_BLOCK_GROUP_DATA) 1758 mixed = true; 1759 else 1760 total_free_meta += found->disk_total - 1761 found->disk_used; 1762 } 1763 1764 total_used += found->disk_used; 1765 } 1766 1767 buf->f_blocks = div_u64(btrfs_super_total_bytes(disk_super), factor); 1768 buf->f_blocks >>= bits; 1769 buf->f_bfree = buf->f_blocks - (div_u64(total_used, factor) >> bits); 1770 1771 /* Account global block reserve as used, it's in logical size already */ 1772 spin_lock(&block_rsv->lock); 1773 /* Mixed block groups accounting is not byte-accurate, avoid overflow */ 1774 if (buf->f_bfree >= block_rsv->size >> bits) 1775 buf->f_bfree -= block_rsv->size >> bits; 1776 else 1777 buf->f_bfree = 0; 1778 spin_unlock(&block_rsv->lock); 1779 1780 buf->f_bavail = div_u64(total_free_data, factor); 1781 ret = btrfs_calc_avail_data_space(fs_info, &total_free_data); 1782 if (ret) 1783 return ret; 1784 buf->f_bavail += div_u64(total_free_data, factor); 1785 buf->f_bavail = buf->f_bavail >> bits; 1786 1787 /* 1788 * We calculate the remaining metadata space minus global reserve. If 1789 * this is (supposedly) smaller than zero, there's no space. But this 1790 * does not hold in practice, the exhausted state happens where's still 1791 * some positive delta. So we apply some guesswork and compare the 1792 * delta to a 4M threshold. (Practically observed delta was ~2M.) 1793 * 1794 * We probably cannot calculate the exact threshold value because this 1795 * depends on the internal reservations requested by various 1796 * operations, so some operations that consume a few metadata will 1797 * succeed even if the Avail is zero. But this is better than the other 1798 * way around. 1799 */ 1800 thresh = SZ_4M; 1801 1802 /* 1803 * We only want to claim there's no available space if we can no longer 1804 * allocate chunks for our metadata profile and our global reserve will 1805 * not fit in the free metadata space. If we aren't ->full then we 1806 * still can allocate chunks and thus are fine using the currently 1807 * calculated f_bavail. 1808 */ 1809 if (!mixed && block_rsv->space_info->full && 1810 (total_free_meta < thresh || total_free_meta - thresh < block_rsv->size)) 1811 buf->f_bavail = 0; 1812 1813 buf->f_type = BTRFS_SUPER_MAGIC; 1814 buf->f_bsize = fs_info->sectorsize; 1815 buf->f_namelen = BTRFS_NAME_LEN; 1816 1817 /* 1818 * fs_devices->fsid is dynamically generated when temp_fsid is active 1819 * to support cloned filesystems. Use the original on-disk fsid instead, 1820 * as it remains consistent across mount cycles. 1821 */ 1822 if (fs_info->fs_devices->temp_fsid) 1823 fsid = (__be32 *)fs_info->super_copy->fsid; 1824 else 1825 fsid = (__be32 *)fs_info->fs_devices->fsid; 1826 1827 /* 1828 * We treat it as constant endianness (it doesn't matter _which_) 1829 * because we want the fsid to come out the same whether mounted 1830 * on a big-endian or little-endian host. 1831 */ 1832 f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]); 1833 f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]); 1834 1835 /* Mask in the root object ID too, to disambiguate subvols */ 1836 f_fsid.val[0] ^= btrfs_root_id(BTRFS_I(d_inode(dentry))->root) >> 32; 1837 f_fsid.val[1] ^= btrfs_root_id(BTRFS_I(d_inode(dentry))->root); 1838 1839 /* 1840 * Hash dev_t to avoid f_fsid collisions with cloned filesystems. 1841 * Only do this when a clone is present so the original filesystem 1842 * (mounted first) maintains backward-compatible f_fsid behavior. 1843 */ 1844 if (fs_info->fs_devices->temp_fsid) { 1845 __kernel_fsid_t dev_fsid = 1846 u64_to_fsid(huge_encode_dev(fs_info->fs_devices->latest_dev->bdev->bd_dev)); 1847 1848 f_fsid.val[0] ^= dev_fsid.val[1]; 1849 f_fsid.val[1] ^= dev_fsid.val[0]; 1850 } 1851 1852 memcpy(&buf->f_fsid, &f_fsid, sizeof(f_fsid)); 1853 1854 return 0; 1855 } 1856 1857 static int btrfs_fc_test_super(struct super_block *sb, struct fs_context *fc) 1858 { 1859 struct btrfs_fs_info *p = fc->s_fs_info; 1860 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 1861 1862 return fs_info->fs_devices == p->fs_devices; 1863 } 1864 1865 static int btrfs_get_tree_super(struct fs_context *fc) 1866 { 1867 struct btrfs_fs_info *fs_info = fc->s_fs_info; 1868 struct btrfs_fs_context *ctx = fc->fs_private; 1869 struct btrfs_fs_devices *fs_devices = NULL; 1870 struct btrfs_device *device; 1871 struct super_block *sb; 1872 blk_mode_t mode = sb_open_mode(fc->sb_flags); 1873 int ret; 1874 1875 btrfs_ctx_to_info(fs_info, ctx); 1876 mutex_lock(&uuid_mutex); 1877 1878 /* 1879 * With 'true' passed to btrfs_scan_one_device() (mount time) we expect 1880 * either a valid device or an error. 1881 */ 1882 device = btrfs_scan_one_device(fc->source, true); 1883 ASSERT(device != NULL); 1884 if (IS_ERR(device)) { 1885 mutex_unlock(&uuid_mutex); 1886 return PTR_ERR(device); 1887 } 1888 fs_devices = device->fs_devices; 1889 /* 1890 * We cannot hold uuid_mutex calling sget_fc(), it will lead to a 1891 * locking order reversal with s_umount. 1892 * 1893 * So here we increase the holding number of fs_devices, this will ensure 1894 * the fs_devices itself won't be freed. 1895 */ 1896 btrfs_fs_devices_inc_holding(fs_devices); 1897 fs_info->fs_devices = fs_devices; 1898 mutex_unlock(&uuid_mutex); 1899 1900 fc->sb_flags |= SB_NOSEC; 1901 1902 sb = sget_fc(fc, btrfs_fc_test_super, set_anon_super_fc); 1903 if (IS_ERR(sb)) { 1904 mutex_lock(&uuid_mutex); 1905 btrfs_fs_devices_dec_holding(fs_devices); 1906 /* 1907 * Since the fs_devices is not opened, it can be freed at any 1908 * time after unlocking uuid_mutex. We need to avoid double 1909 * free through put_fs_context()->btrfs_free_fs_info(). 1910 * So here we reset fs_info->fs_devices to NULL, and let the 1911 * regular fs_devices reclaim path to handle it. 1912 * 1913 * This applies to all later branches where no fs_devices is 1914 * opened. 1915 */ 1916 fs_info->fs_devices = NULL; 1917 mutex_unlock(&uuid_mutex); 1918 return PTR_ERR(sb); 1919 } 1920 1921 if (sb->s_root) { 1922 /* 1923 * Not the first mount of the fs thus got an existing super block. 1924 * Will reuse the returned super block, fs_info and fs_devices. 1925 * 1926 * fc->s_fs_info is not touched and will be later freed by 1927 * put_fs_context() through btrfs_free_fs_context(). 1928 */ 1929 ASSERT(fc->s_fs_info == fs_info); 1930 1931 mutex_lock(&uuid_mutex); 1932 btrfs_fs_devices_dec_holding(fs_devices); 1933 fs_info->fs_devices = NULL; 1934 mutex_unlock(&uuid_mutex); 1935 /* 1936 * At this stage we may have RO flag mismatch between 1937 * fc->sb_flags and sb->s_flags. Caller should detect such 1938 * mismatch and reconfigure with sb->s_umount rwsem held if 1939 * needed. 1940 */ 1941 } else { 1942 struct block_device *bdev; 1943 1944 /* 1945 * The first mount of the fs thus a new superblock, fc->s_fs_info 1946 * must be NULL, and the ownership of our fs_info and fs_devices is 1947 * transferred to the super block. 1948 */ 1949 ASSERT(fc->s_fs_info == NULL); 1950 1951 mutex_lock(&uuid_mutex); 1952 btrfs_fs_devices_dec_holding(fs_devices); 1953 ret = btrfs_open_devices(fs_devices, mode, sb); 1954 if (ret < 0) 1955 fs_info->fs_devices = NULL; 1956 mutex_unlock(&uuid_mutex); 1957 if (ret < 0) { 1958 deactivate_locked_super(sb); 1959 return ret; 1960 } 1961 if (!(fc->sb_flags & SB_RDONLY) && fs_devices->rw_devices == 0) { 1962 deactivate_locked_super(sb); 1963 return -EACCES; 1964 } 1965 set_device_specific_options(fs_info); 1966 bdev = fs_devices->latest_dev->bdev; 1967 snprintf(sb->s_id, sizeof(sb->s_id), "%pg", bdev); 1968 shrinker_debugfs_rename(sb->s_shrink, "sb-btrfs:%s", sb->s_id); 1969 ret = btrfs_fill_super(sb, fs_devices); 1970 if (ret) { 1971 deactivate_locked_super(sb); 1972 return ret; 1973 } 1974 } 1975 1976 btrfs_clear_oneshot_options(fs_info); 1977 1978 fc->root = dget(sb->s_root); 1979 return 0; 1980 } 1981 1982 /* 1983 * Ever since commit 0723a0473fb4 ("btrfs: allow mounting btrfs subvolumes 1984 * with different ro/rw options") the following works: 1985 * 1986 * (i) mount /dev/sda3 -o subvol=foo,ro /mnt/foo 1987 * (ii) mount /dev/sda3 -o subvol=bar,rw /mnt/bar 1988 * 1989 * which looks nice and innocent but is actually pretty intricate and deserves 1990 * a long comment. 1991 * 1992 * On another filesystem a subvolume mount is close to something like: 1993 * 1994 * (iii) # create rw superblock + initial mount 1995 * mount -t xfs /dev/sdb /opt/ 1996 * 1997 * # create ro bind mount 1998 * mount --bind -o ro /opt/foo /mnt/foo 1999 * 2000 * # unmount initial mount 2001 * umount /opt 2002 * 2003 * Of course, there's some special subvolume sauce and there's the fact that the 2004 * sb->s_root dentry is really swapped after mount_subtree(). But conceptually 2005 * it's very close and will help us understand the issue. 2006 * 2007 * The old mount API didn't cleanly distinguish between a mount being made ro 2008 * and a superblock being made ro. The only way to change the ro state of 2009 * either object was by passing ms_rdonly. If a new mount was created via 2010 * mount(2) such as: 2011 * 2012 * mount("/dev/sdb", "/mnt", "xfs", ms_rdonly, null); 2013 * 2014 * the MS_RDONLY flag being specified had two effects: 2015 * 2016 * (1) MNT_READONLY was raised -> the resulting mount got 2017 * @mnt->mnt_flags |= MNT_READONLY raised. 2018 * 2019 * (2) MS_RDONLY was passed to the filesystem's mount method and the filesystems 2020 * made the superblock ro. Note, how SB_RDONLY has the same value as 2021 * ms_rdonly and is raised whenever MS_RDONLY is passed through mount(2). 2022 * 2023 * Creating a subtree mount via (iii) ends up leaving a rw superblock with a 2024 * subtree mounted ro. 2025 * 2026 * But consider the effect on the old mount API on btrfs subvolume mounting 2027 * which combines the distinct step in (iii) into a single step. 2028 * 2029 * By issuing (i) both the mount and the superblock are turned ro. Now when (ii) 2030 * is issued the superblock is ro and thus even if the mount created for (ii) is 2031 * rw it wouldn't help. Hence, btrfs needed to transition the superblock from ro 2032 * to rw for (ii) which it did using an internal remount call. 2033 * 2034 * IOW, subvolume mounting was inherently complicated due to the ambiguity of 2035 * MS_RDONLY in mount(2). Note, this ambiguity has mount(8) always translate 2036 * "ro" to MS_RDONLY. IOW, in both (i) and (ii) "ro" becomes MS_RDONLY when 2037 * passed by mount(8) to mount(2). 2038 * 2039 * Enter the new mount API. The new mount API disambiguates making a mount ro 2040 * and making a superblock ro. 2041 * 2042 * (3) To turn a mount ro the MOUNT_ATTR_ONLY flag can be used with either 2043 * fsmount() or mount_setattr() this is a pure VFS level change for a 2044 * specific mount or mount tree that is never seen by the filesystem itself. 2045 * 2046 * (4) To turn a superblock ro the "ro" flag must be used with 2047 * fsconfig(FSCONFIG_SET_FLAG, "ro"). This option is seen by the filesystem 2048 * in fc->sb_flags. 2049 * 2050 * But, currently the util-linux mount command already utilizes the new mount 2051 * API and is still setting fsconfig(FSCONFIG_SET_FLAG, "ro") no matter if it's 2052 * btrfs or not, setting the whole super block RO. To make per-subvolume mounting 2053 * work with different options work we need to keep backward compatibility. 2054 */ 2055 static int btrfs_reconfigure_for_mount(struct fs_context *fc) 2056 { 2057 int ret = 0; 2058 2059 if (!(fc->sb_flags & SB_RDONLY) && (fc->root->d_sb->s_flags & SB_RDONLY)) 2060 ret = btrfs_reconfigure(fc); 2061 2062 return ret; 2063 } 2064 2065 static int btrfs_get_tree_subvol(struct fs_context *fc) 2066 { 2067 struct btrfs_fs_info *fs_info = NULL; 2068 struct btrfs_fs_context *ctx = fc->fs_private; 2069 struct fs_context *dup_fc; 2070 struct dentry *dentry; 2071 struct vfsmount *mnt; 2072 int ret = 0; 2073 2074 /* 2075 * Setup a dummy root and fs_info for test/set super. This is because 2076 * we don't actually fill this stuff out until open_ctree, but we need 2077 * then open_ctree will properly initialize the file system specific 2078 * settings later. btrfs_init_fs_info initializes the static elements 2079 * of the fs_info (locks and such) to make cleanup easier if we find a 2080 * superblock with our given fs_devices later on at sget_fc() time. 2081 */ 2082 fs_info = kvzalloc_obj(struct btrfs_fs_info); 2083 if (!fs_info) 2084 return -ENOMEM; 2085 2086 fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL); 2087 fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL); 2088 if (!fs_info->super_copy || !fs_info->super_for_commit) { 2089 /* 2090 * Dont call btrfs_free_fs_info() to free it as it's still 2091 * initialized partially. 2092 */ 2093 kfree(fs_info->super_copy); 2094 kfree(fs_info->super_for_commit); 2095 kvfree(fs_info); 2096 return -ENOMEM; 2097 } 2098 btrfs_init_fs_info(fs_info); 2099 2100 dup_fc = vfs_dup_fs_context(fc); 2101 if (IS_ERR(dup_fc)) { 2102 btrfs_free_fs_info(fs_info); 2103 return PTR_ERR(dup_fc); 2104 } 2105 2106 /* 2107 * When we do the sget_fc this gets transferred to the sb, so we only 2108 * need to set it on the dup_fc as this is what creates the super block. 2109 */ 2110 dup_fc->s_fs_info = fs_info; 2111 2112 ret = btrfs_get_tree_super(dup_fc); 2113 if (ret) 2114 goto error; 2115 2116 ret = btrfs_reconfigure_for_mount(dup_fc); 2117 up_write(&dup_fc->root->d_sb->s_umount); 2118 if (ret) 2119 goto error; 2120 mnt = vfs_create_mount(dup_fc); 2121 put_fs_context(dup_fc); 2122 if (IS_ERR(mnt)) 2123 return PTR_ERR(mnt); 2124 2125 /* 2126 * This free's ->subvol_name, because if it isn't set we have to 2127 * allocate a buffer to hold the subvol_name, so we just drop our 2128 * reference to it here. 2129 */ 2130 dentry = mount_subvol(ctx->subvol_name, ctx->subvol_objectid, mnt); 2131 ctx->subvol_name = NULL; 2132 if (IS_ERR(dentry)) 2133 return PTR_ERR(dentry); 2134 2135 fc->root = dentry; 2136 return 0; 2137 error: 2138 put_fs_context(dup_fc); 2139 return ret; 2140 } 2141 2142 static int btrfs_get_tree(struct fs_context *fc) 2143 { 2144 ASSERT(fc->s_fs_info == NULL); 2145 2146 return btrfs_get_tree_subvol(fc); 2147 } 2148 2149 static void btrfs_kill_super(struct super_block *sb) 2150 { 2151 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 2152 kill_anon_super(sb); 2153 btrfs_free_fs_info(fs_info); 2154 } 2155 2156 static void btrfs_free_fs_context(struct fs_context *fc) 2157 { 2158 struct btrfs_fs_context *ctx = fc->fs_private; 2159 struct btrfs_fs_info *fs_info = fc->s_fs_info; 2160 2161 if (fs_info) 2162 btrfs_free_fs_info(fs_info); 2163 2164 if (ctx && refcount_dec_and_test(&ctx->refs)) { 2165 kfree(ctx->subvol_name); 2166 kfree(ctx); 2167 } 2168 } 2169 2170 static int btrfs_dup_fs_context(struct fs_context *fc, struct fs_context *src_fc) 2171 { 2172 struct btrfs_fs_context *ctx = src_fc->fs_private; 2173 2174 /* 2175 * Give a ref to our ctx to this dup, as we want to keep it around for 2176 * our original fc so we can have the subvolume name or objectid. 2177 * 2178 * We unset ->source in the original fc because the dup needs it for 2179 * mounting, and then once we free the dup it'll free ->source, so we 2180 * need to make sure we're only pointing to it in one fc. 2181 */ 2182 refcount_inc(&ctx->refs); 2183 fc->fs_private = ctx; 2184 fc->source = src_fc->source; 2185 src_fc->source = NULL; 2186 return 0; 2187 } 2188 2189 static const struct fs_context_operations btrfs_fs_context_ops = { 2190 .parse_param = btrfs_parse_param, 2191 .reconfigure = btrfs_reconfigure, 2192 .get_tree = btrfs_get_tree, 2193 .dup = btrfs_dup_fs_context, 2194 .free = btrfs_free_fs_context, 2195 }; 2196 2197 static int btrfs_init_fs_context(struct fs_context *fc) 2198 { 2199 struct btrfs_fs_context *ctx; 2200 2201 ctx = kzalloc_obj(struct btrfs_fs_context); 2202 if (!ctx) 2203 return -ENOMEM; 2204 2205 refcount_set(&ctx->refs, 1); 2206 fc->fs_private = ctx; 2207 fc->ops = &btrfs_fs_context_ops; 2208 2209 if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) { 2210 btrfs_info_to_ctx(btrfs_sb(fc->root->d_sb), ctx); 2211 } else { 2212 ctx->thread_pool_size = 2213 min_t(unsigned long, num_online_cpus() + 2, 8); 2214 ctx->max_inline = BTRFS_DEFAULT_MAX_INLINE; 2215 ctx->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL; 2216 } 2217 2218 #ifdef CONFIG_BTRFS_FS_POSIX_ACL 2219 fc->sb_flags |= SB_POSIXACL; 2220 #endif 2221 fc->sb_flags |= SB_I_VERSION; 2222 2223 return 0; 2224 } 2225 2226 static struct file_system_type btrfs_fs_type = { 2227 .owner = THIS_MODULE, 2228 .name = "btrfs", 2229 .init_fs_context = btrfs_init_fs_context, 2230 .parameters = btrfs_fs_parameters, 2231 .kill_sb = btrfs_kill_super, 2232 .fs_flags = FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA | 2233 FS_ALLOW_IDMAP | FS_MGTIME, 2234 }; 2235 2236 MODULE_ALIAS_FS("btrfs"); 2237 2238 static int btrfs_control_open(struct inode *inode, struct file *file) 2239 { 2240 /* 2241 * The control file's private_data is used to hold the 2242 * transaction when it is started and is used to keep 2243 * track of whether a transaction is already in progress. 2244 */ 2245 file->private_data = NULL; 2246 return 0; 2247 } 2248 2249 /* 2250 * Used by /dev/btrfs-control for devices ioctls. 2251 */ 2252 static long btrfs_control_ioctl(struct file *file, unsigned int cmd, 2253 unsigned long arg) 2254 { 2255 struct btrfs_ioctl_vol_args *vol; 2256 struct btrfs_device *device = NULL; 2257 dev_t devt = 0; 2258 int ret = -ENOTTY; 2259 2260 if (!capable(CAP_SYS_ADMIN)) 2261 return -EPERM; 2262 2263 vol = memdup_user((void __user *)arg, sizeof(*vol)); 2264 if (IS_ERR(vol)) 2265 return PTR_ERR(vol); 2266 ret = btrfs_check_ioctl_vol_args_path(vol); 2267 if (ret < 0) 2268 goto out; 2269 2270 switch (cmd) { 2271 case BTRFS_IOC_SCAN_DEV: 2272 mutex_lock(&uuid_mutex); 2273 /* 2274 * Scanning outside of mount can return NULL which would turn 2275 * into 0 error code. 2276 */ 2277 device = btrfs_scan_one_device(vol->name, false); 2278 ret = PTR_ERR_OR_ZERO(device); 2279 mutex_unlock(&uuid_mutex); 2280 break; 2281 case BTRFS_IOC_FORGET_DEV: 2282 if (vol->name[0] != 0) { 2283 ret = lookup_bdev(vol->name, &devt); 2284 if (ret) 2285 break; 2286 } 2287 ret = btrfs_forget_devices(devt); 2288 break; 2289 case BTRFS_IOC_DEVICES_READY: 2290 mutex_lock(&uuid_mutex); 2291 /* 2292 * Scanning outside of mount can return NULL which would turn 2293 * into 0 error code. 2294 */ 2295 device = btrfs_scan_one_device(vol->name, false); 2296 if (IS_ERR_OR_NULL(device)) { 2297 mutex_unlock(&uuid_mutex); 2298 ret = PTR_ERR_OR_ZERO(device); 2299 break; 2300 } 2301 ret = !(device->fs_devices->num_devices == 2302 device->fs_devices->total_devices); 2303 mutex_unlock(&uuid_mutex); 2304 break; 2305 case BTRFS_IOC_GET_SUPPORTED_FEATURES: 2306 ret = btrfs_ioctl_get_supported_features((void __user*)arg); 2307 break; 2308 } 2309 2310 out: 2311 kfree(vol); 2312 return ret; 2313 } 2314 2315 static int btrfs_freeze(struct super_block *sb) 2316 { 2317 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 2318 2319 set_bit(BTRFS_FS_FROZEN, &fs_info->flags); 2320 /* 2321 * We don't need a barrier here, we'll wait for any transaction that 2322 * could be in progress on other threads (and do delayed iputs that 2323 * we want to avoid on a frozen filesystem), or do the commit 2324 * ourselves. 2325 */ 2326 return btrfs_commit_current_transaction(fs_info->tree_root); 2327 } 2328 2329 static int check_dev_super(struct btrfs_device *dev) 2330 { 2331 struct btrfs_fs_info *fs_info = dev->fs_info; 2332 struct btrfs_super_block *sb; 2333 u64 last_trans; 2334 u16 csum_type; 2335 int ret = 0; 2336 2337 /* This should be called with fs still frozen. */ 2338 ASSERT(test_bit(BTRFS_FS_FROZEN, &fs_info->flags)); 2339 2340 /* Missing dev, no need to check. */ 2341 if (!dev->bdev) 2342 return 0; 2343 2344 /* Only need to check the primary super block. */ 2345 sb = btrfs_read_disk_super(dev->bdev, 0, true); 2346 if (IS_ERR(sb)) 2347 return PTR_ERR(sb); 2348 2349 /* Verify the checksum. */ 2350 csum_type = btrfs_super_csum_type(sb); 2351 if (unlikely(csum_type != btrfs_super_csum_type(fs_info->super_copy))) { 2352 btrfs_err(fs_info, "csum type changed, has %u expect %u", 2353 csum_type, btrfs_super_csum_type(fs_info->super_copy)); 2354 ret = -EUCLEAN; 2355 goto out; 2356 } 2357 2358 if (unlikely(btrfs_check_super_csum(fs_info, sb))) { 2359 btrfs_err(fs_info, "csum for on-disk super block no longer matches"); 2360 ret = -EUCLEAN; 2361 goto out; 2362 } 2363 2364 /* Btrfs_validate_super() includes fsid check against super->fsid. */ 2365 ret = btrfs_validate_super(fs_info, sb, 0); 2366 if (ret < 0) 2367 goto out; 2368 2369 last_trans = btrfs_get_last_trans_committed(fs_info); 2370 if (unlikely(btrfs_super_generation(sb) != last_trans)) { 2371 btrfs_err(fs_info, "transid mismatch, has %llu expect %llu", 2372 btrfs_super_generation(sb), last_trans); 2373 ret = -EUCLEAN; 2374 goto out; 2375 } 2376 out: 2377 btrfs_release_disk_super(sb); 2378 return ret; 2379 } 2380 2381 static int btrfs_unfreeze(struct super_block *sb) 2382 { 2383 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 2384 struct btrfs_device *device; 2385 int ret = 0; 2386 2387 /* 2388 * Make sure the fs is not changed by accident (like hibernation then 2389 * modified by other OS). 2390 * If we found anything wrong, we mark the fs error immediately. 2391 * 2392 * And since the fs is frozen, no one can modify the fs yet, thus 2393 * we don't need to hold device_list_mutex. 2394 */ 2395 list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) { 2396 ret = check_dev_super(device); 2397 if (ret < 0) { 2398 btrfs_handle_fs_error(fs_info, ret, 2399 "super block on devid %llu got modified unexpectedly", 2400 device->devid); 2401 break; 2402 } 2403 } 2404 clear_bit(BTRFS_FS_FROZEN, &fs_info->flags); 2405 2406 /* 2407 * We still return 0, to allow VFS layer to unfreeze the fs even the 2408 * above checks failed. Since the fs is either fine or read-only, we're 2409 * safe to continue, without causing further damage. 2410 */ 2411 return 0; 2412 } 2413 2414 static int btrfs_show_devname(struct seq_file *m, struct dentry *root) 2415 { 2416 struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb); 2417 2418 /* 2419 * There should be always a valid pointer in latest_dev, it may be stale 2420 * for a short moment in case it's being deleted but still valid until 2421 * the end of RCU grace period. 2422 */ 2423 rcu_read_lock(); 2424 seq_escape(m, btrfs_dev_name(fs_info->fs_devices->latest_dev), " \t\n\\"); 2425 rcu_read_unlock(); 2426 2427 return 0; 2428 } 2429 2430 static long btrfs_nr_cached_objects(struct super_block *sb, struct shrink_control *sc) 2431 { 2432 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 2433 const s64 nr = percpu_counter_read_positive(&fs_info->evictable_extent_maps); 2434 2435 /* 2436 * The evictable extent map counter is filesystem-global and does not 2437 * honour sc->memcg, so it is only meaningful on the global (kswapd or 2438 * root direct reclaim) shrink path. Skip the per-memcg iterations of 2439 * shrink_slab_memcg() to avoid queueing duplicate global work. 2440 */ 2441 if (!mem_cgroup_shrink_is_root(sc)) 2442 return 0; 2443 2444 trace_btrfs_extent_map_shrinker_count(fs_info, nr); 2445 2446 return nr; 2447 } 2448 2449 static long btrfs_free_cached_objects(struct super_block *sb, struct shrink_control *sc) 2450 { 2451 const long nr_to_scan = min_t(unsigned long, LONG_MAX, sc->nr_to_scan); 2452 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 2453 2454 btrfs_free_extent_maps(fs_info, nr_to_scan); 2455 2456 /* The extent map shrinker runs asynchronously, so always return 0. */ 2457 return 0; 2458 } 2459 2460 static int btrfs_remove_bdev(struct super_block *sb, struct block_device *bdev) 2461 { 2462 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 2463 struct btrfs_device *device; 2464 struct btrfs_dev_lookup_args lookup_args = { .devt = bdev->bd_dev }; 2465 bool can_rw; 2466 2467 mutex_lock(&fs_info->fs_devices->device_list_mutex); 2468 device = btrfs_find_device(fs_info->fs_devices, &lookup_args); 2469 if (!device) { 2470 mutex_unlock(&fs_info->fs_devices->device_list_mutex); 2471 /* Device not found, should not affect the running fs, just give a warning. */ 2472 btrfs_warn(fs_info, "unable to find btrfs device for block device '%pg'", bdev); 2473 return 0; 2474 } 2475 /* 2476 * The to-be-removed device is already missing? 2477 * 2478 * That's weird but no special handling needed and can exit right now. 2479 */ 2480 if (unlikely(test_and_set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state))) { 2481 mutex_unlock(&fs_info->fs_devices->device_list_mutex); 2482 btrfs_warn(fs_info, "btrfs device id %llu is already missing", device->devid); 2483 return 0; 2484 } 2485 2486 device->fs_devices->missing_devices++; 2487 if (test_and_clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { 2488 list_del_init(&device->dev_alloc_list); 2489 WARN_ON(device->fs_devices->rw_devices < 1); 2490 device->fs_devices->rw_devices--; 2491 } 2492 can_rw = btrfs_check_rw_degradable(fs_info, device); 2493 mutex_unlock(&fs_info->fs_devices->device_list_mutex); 2494 /* 2495 * Now device is considered missing, btrfs_device_name() won't give a 2496 * meaningful result anymore, so only output the devid. 2497 */ 2498 if (unlikely(!can_rw)) { 2499 btrfs_crit(fs_info, 2500 "btrfs device id %llu has gone missing, can not maintain read-write", 2501 device->devid); 2502 return -EIO; 2503 } 2504 btrfs_warn(fs_info, 2505 "btrfs device id %llu has gone missing, continue as degraded", 2506 device->devid); 2507 btrfs_set_opt(fs_info->mount_opt, DEGRADED); 2508 return 0; 2509 } 2510 2511 static void btrfs_shutdown(struct super_block *sb) 2512 { 2513 struct btrfs_fs_info *fs_info = btrfs_sb(sb); 2514 2515 btrfs_force_shutdown(fs_info); 2516 } 2517 2518 static int btrfs_show_stats(struct seq_file *seq, struct dentry *root) 2519 { 2520 struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb); 2521 2522 if (btrfs_is_zoned(fs_info)) { 2523 btrfs_show_zoned_stats(fs_info, seq); 2524 return 0; 2525 } 2526 2527 return 0; 2528 } 2529 2530 static const struct super_operations btrfs_super_ops = { 2531 .drop_inode = btrfs_drop_inode, 2532 .evict_inode = btrfs_evict_inode, 2533 .put_super = btrfs_put_super, 2534 .sync_fs = btrfs_sync_fs, 2535 .show_options = btrfs_show_options, 2536 .show_devname = btrfs_show_devname, 2537 .alloc_inode = btrfs_alloc_inode, 2538 .destroy_inode = btrfs_destroy_inode, 2539 .free_inode = btrfs_free_inode, 2540 .statfs = btrfs_statfs, 2541 .freeze_fs = btrfs_freeze, 2542 .unfreeze_fs = btrfs_unfreeze, 2543 .nr_cached_objects = btrfs_nr_cached_objects, 2544 .free_cached_objects = btrfs_free_cached_objects, 2545 .show_stats = btrfs_show_stats, 2546 .remove_bdev = btrfs_remove_bdev, 2547 .shutdown = btrfs_shutdown, 2548 }; 2549 2550 static const struct file_operations btrfs_ctl_fops = { 2551 .open = btrfs_control_open, 2552 .unlocked_ioctl = btrfs_control_ioctl, 2553 .compat_ioctl = compat_ptr_ioctl, 2554 .owner = THIS_MODULE, 2555 .llseek = noop_llseek, 2556 }; 2557 2558 static struct miscdevice btrfs_misc = { 2559 .minor = BTRFS_MINOR, 2560 .name = "btrfs-control", 2561 .fops = &btrfs_ctl_fops 2562 }; 2563 2564 MODULE_ALIAS_MISCDEV(BTRFS_MINOR); 2565 MODULE_ALIAS("devname:btrfs-control"); 2566 2567 static int __init btrfs_interface_init(void) 2568 { 2569 return misc_register(&btrfs_misc); 2570 } 2571 2572 static __cold void btrfs_interface_exit(void) 2573 { 2574 misc_deregister(&btrfs_misc); 2575 } 2576 2577 static int __init btrfs_print_mod_info(void) 2578 { 2579 static const char options[] = "" 2580 #ifdef CONFIG_BTRFS_EXPERIMENTAL 2581 ", experimental=on" 2582 #endif 2583 #ifdef CONFIG_BTRFS_DEBUG 2584 ", debug=on" 2585 #endif 2586 #ifdef CONFIG_BTRFS_ASSERT 2587 ", assert=on" 2588 #endif 2589 #ifdef CONFIG_BLK_DEV_ZONED 2590 ", zoned=yes" 2591 #else 2592 ", zoned=no" 2593 #endif 2594 #ifdef CONFIG_FS_VERITY 2595 ", fsverity=yes" 2596 #else 2597 ", fsverity=no" 2598 #endif 2599 ; 2600 2601 #ifdef CONFIG_BTRFS_EXPERIMENTAL 2602 if (btrfs_get_mod_read_policy() == NULL) 2603 pr_info("Btrfs loaded%s\n", options); 2604 else 2605 pr_info("Btrfs loaded%s, read_policy=%s\n", 2606 options, btrfs_get_mod_read_policy()); 2607 #else 2608 pr_info("Btrfs loaded%s\n", options); 2609 #endif 2610 2611 return 0; 2612 } 2613 2614 static int register_btrfs(void) 2615 { 2616 return register_filesystem(&btrfs_fs_type); 2617 } 2618 2619 static void unregister_btrfs(void) 2620 { 2621 unregister_filesystem(&btrfs_fs_type); 2622 } 2623 2624 /* Helper structure for long init/exit functions. */ 2625 struct init_sequence { 2626 int (*init_func)(void); 2627 /* Can be NULL if the init_func doesn't need cleanup. */ 2628 void (*exit_func)(void); 2629 }; 2630 2631 static const struct init_sequence mod_init_seq[] = { 2632 { 2633 .init_func = btrfs_props_init, 2634 .exit_func = NULL, 2635 }, { 2636 .init_func = btrfs_init_sysfs, 2637 .exit_func = btrfs_exit_sysfs, 2638 }, { 2639 .init_func = btrfs_init_compress, 2640 .exit_func = btrfs_exit_compress, 2641 }, { 2642 .init_func = btrfs_init_block_group, 2643 .exit_func = btrfs_exit_block_group, 2644 }, { 2645 .init_func = btrfs_init_cachep, 2646 .exit_func = btrfs_destroy_cachep, 2647 }, { 2648 .init_func = btrfs_init_dio, 2649 .exit_func = btrfs_destroy_dio, 2650 }, { 2651 .init_func = btrfs_transaction_init, 2652 .exit_func = btrfs_transaction_exit, 2653 }, { 2654 .init_func = btrfs_ctree_init, 2655 .exit_func = btrfs_ctree_exit, 2656 }, { 2657 .init_func = btrfs_free_space_init, 2658 .exit_func = btrfs_free_space_exit, 2659 }, { 2660 .init_func = btrfs_extent_state_init_cachep, 2661 .exit_func = btrfs_extent_state_free_cachep, 2662 }, { 2663 .init_func = extent_buffer_init_cachep, 2664 .exit_func = extent_buffer_free_cachep, 2665 }, { 2666 .init_func = btrfs_bioset_init, 2667 .exit_func = btrfs_bioset_exit, 2668 }, { 2669 .init_func = btrfs_extent_map_init, 2670 .exit_func = btrfs_extent_map_exit, 2671 #ifdef CONFIG_BTRFS_EXPERIMENTAL 2672 }, { 2673 .init_func = btrfs_read_policy_init, 2674 .exit_func = NULL, 2675 #endif 2676 }, { 2677 .init_func = ordered_data_init, 2678 .exit_func = ordered_data_exit, 2679 }, { 2680 .init_func = btrfs_delayed_inode_init, 2681 .exit_func = btrfs_delayed_inode_exit, 2682 }, { 2683 .init_func = btrfs_auto_defrag_init, 2684 .exit_func = btrfs_auto_defrag_exit, 2685 }, { 2686 .init_func = btrfs_delayed_ref_init, 2687 .exit_func = btrfs_delayed_ref_exit, 2688 }, { 2689 .init_func = btrfs_prelim_ref_init, 2690 .exit_func = btrfs_prelim_ref_exit, 2691 }, { 2692 .init_func = btrfs_interface_init, 2693 .exit_func = btrfs_interface_exit, 2694 }, { 2695 .init_func = btrfs_print_mod_info, 2696 .exit_func = NULL, 2697 }, { 2698 .init_func = btrfs_run_sanity_tests, 2699 .exit_func = NULL, 2700 }, { 2701 .init_func = register_btrfs, 2702 .exit_func = unregister_btrfs, 2703 } 2704 }; 2705 2706 static bool mod_init_result[ARRAY_SIZE(mod_init_seq)]; 2707 2708 static __always_inline void btrfs_exit_btrfs_fs(void) 2709 { 2710 int i; 2711 2712 for (i = ARRAY_SIZE(mod_init_seq) - 1; i >= 0; i--) { 2713 if (!mod_init_result[i]) 2714 continue; 2715 if (mod_init_seq[i].exit_func) 2716 mod_init_seq[i].exit_func(); 2717 mod_init_result[i] = false; 2718 } 2719 } 2720 2721 static void __exit exit_btrfs_fs(void) 2722 { 2723 btrfs_exit_btrfs_fs(); 2724 btrfs_cleanup_fs_uuids(); 2725 } 2726 2727 static int __init init_btrfs_fs(void) 2728 { 2729 int ret; 2730 int i; 2731 2732 for (i = 0; i < ARRAY_SIZE(mod_init_seq); i++) { 2733 ASSERT(!mod_init_result[i]); 2734 ret = mod_init_seq[i].init_func(); 2735 if (ret < 0) { 2736 btrfs_exit_btrfs_fs(); 2737 return ret; 2738 } 2739 mod_init_result[i] = true; 2740 } 2741 return 0; 2742 } 2743 2744 late_initcall(init_btrfs_fs); 2745 module_exit(exit_btrfs_fs) 2746 2747 MODULE_DESCRIPTION("B-Tree File System (BTRFS)"); 2748 MODULE_LICENSE("GPL"); 2749