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