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