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