1c1d7c514SDavid Sterba // SPDX-License-Identifier: GPL-2.0 26cbd5570SChris Mason /* 36cbd5570SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 46cbd5570SChris Mason */ 56cbd5570SChris Mason 64b82d6e4SYan #include <linux/blkdev.h> 72e635a27SChris Mason #include <linux/module.h> 82e635a27SChris Mason #include <linux/fs.h> 92e635a27SChris Mason #include <linux/pagemap.h> 102e635a27SChris Mason #include <linux/highmem.h> 112e635a27SChris Mason #include <linux/time.h> 122e635a27SChris Mason #include <linux/init.h> 13a9572a15SEric Paris #include <linux/seq_file.h> 142e635a27SChris Mason #include <linux/string.h> 152e635a27SChris Mason #include <linux/backing-dev.h> 164b82d6e4SYan #include <linux/mount.h> 1775dfe396SChris Mason #include <linux/writeback.h> 188fd17795SChris Mason #include <linux/statfs.h> 1908607c1bSChris Mason #include <linux/compat.h> 2095e05289SChris Mason #include <linux/parser.h> 21c59f8951SChris Mason #include <linux/ctype.h> 226da6abaeSChris Mason #include <linux/namei.h> 23a9218f6bSChris Mason #include <linux/miscdevice.h> 241bcbf313SQinghuang Feng #include <linux/magic.h> 255a0e3ad6STejun Heo #include <linux/slab.h> 2690a887c9SDan Magenheimer #include <linux/cleancache.h> 2722c44fe6SJosef Bacik #include <linux/ratelimit.h> 289678c543SNikolay Borisov #include <linux/crc32c.h> 2955e301fdSFilipe Brandenburger #include <linux/btrfs.h> 3016cdcec7SMiao Xie #include "delayed-inode.h" 312e635a27SChris Mason #include "ctree.h" 32e20d96d6SChris Mason #include "disk-io.h" 33d5719762SChris Mason #include "transaction.h" 342c90e5d6SChris Mason #include "btrfs_inode.h" 353a686375SChris Mason #include "print-tree.h" 3663541927SFilipe David Borba Manana #include "props.h" 375103e947SJosef Bacik #include "xattr.h" 388a4b83ccSChris Mason #include "volumes.h" 39be6e8dc0SBalaji Rao #include "export.h" 40c8b97818SChris Mason #include "compression.h" 419c5085c1SJosef Bacik #include "rcu-string.h" 428dabb742SStefan Behrens #include "dev-replace.h" 4374255aa0SJosef Bacik #include "free-space-cache.h" 44b9e9a6cbSWang Shilong #include "backref.h" 458719aaaeSJosef Bacik #include "space-info.h" 4689439109SDavid Sterba #include "sysfs.h" 47dc11dd5dSJosef Bacik #include "tests/btrfs-tests.h" 48aac0023cSJosef Bacik #include "block-group.h" 49b0643e59SDennis Zhou #include "discard.h" 502e635a27SChris Mason 51d3982100SMark Fasheh #include "qgroup.h" 521abe9b8aSliubo #define CREATE_TRACE_POINTS 531abe9b8aSliubo #include <trace/events/btrfs.h> 541abe9b8aSliubo 55b87221deSAlexey Dobriyan static const struct super_operations btrfs_super_ops; 5672fa39f5SMisono, Tomohiro 5772fa39f5SMisono, Tomohiro /* 5872fa39f5SMisono, Tomohiro * Types for mounting the default subvolume and a subvolume explicitly 5972fa39f5SMisono, Tomohiro * requested by subvol=/path. That way the callchain is straightforward and we 6072fa39f5SMisono, Tomohiro * don't have to play tricks with the mount options and recursive calls to 6172fa39f5SMisono, Tomohiro * btrfs_mount. 62312c89fbSMisono, Tomohiro * 63312c89fbSMisono, Tomohiro * The new btrfs_root_fs_type also servers as a tag for the bdev_holder. 6472fa39f5SMisono, Tomohiro */ 65830c4adbSJosef Bacik static struct file_system_type btrfs_fs_type; 6672fa39f5SMisono, Tomohiro static struct file_system_type btrfs_root_fs_type; 67e20d96d6SChris Mason 680723a047SHarald Hoyer static int btrfs_remount(struct super_block *sb, int *flags, char *data); 690723a047SHarald Hoyer 7059131393SJosef Bacik /* 7159131393SJosef Bacik * Generally the error codes correspond to their respective errors, but there 7259131393SJosef Bacik * are a few special cases. 7359131393SJosef Bacik * 7459131393SJosef Bacik * EUCLEAN: Any sort of corruption that we encounter. The tree-checker for 7559131393SJosef Bacik * instance will return EUCLEAN if any of the blocks are corrupted in 7659131393SJosef Bacik * a way that is problematic. We want to reserve EUCLEAN for these 7759131393SJosef Bacik * sort of corruptions. 7859131393SJosef Bacik * 7959131393SJosef Bacik * EROFS: If we check BTRFS_FS_STATE_ERROR and fail out with a return error, we 8059131393SJosef Bacik * need to use EROFS for this case. We will have no idea of the 8159131393SJosef Bacik * original failure, that will have been reported at the time we tripped 8259131393SJosef Bacik * over the error. Each subsequent error that doesn't have any context 8359131393SJosef Bacik * of the original error should use EROFS when handling BTRFS_FS_STATE_ERROR. 8459131393SJosef Bacik */ 854143cb8bSDavid Sterba const char * __attribute_const__ btrfs_decode_error(int errno) 86acce952bSliubo { 8708748810SDavid Sterba char *errstr = "unknown"; 88acce952bSliubo 89acce952bSliubo switch (errno) { 90d54f8144SDavid Sterba case -ENOENT: /* -2 */ 91d54f8144SDavid Sterba errstr = "No such entry"; 92d54f8144SDavid Sterba break; 93d54f8144SDavid Sterba case -EIO: /* -5 */ 94acce952bSliubo errstr = "IO failure"; 95acce952bSliubo break; 96d54f8144SDavid Sterba case -ENOMEM: /* -12*/ 97acce952bSliubo errstr = "Out of memory"; 98acce952bSliubo break; 99d54f8144SDavid Sterba case -EEXIST: /* -17 */ 1008c342930SJeff Mahoney errstr = "Object already exists"; 1018c342930SJeff Mahoney break; 102d54f8144SDavid Sterba case -ENOSPC: /* -28 */ 10394ef7280SDavid Sterba errstr = "No space left"; 10494ef7280SDavid Sterba break; 105d54f8144SDavid Sterba case -EROFS: /* -30 */ 106d54f8144SDavid Sterba errstr = "Readonly filesystem"; 10794ef7280SDavid Sterba break; 108fb8521caSDavid Sterba case -EOPNOTSUPP: /* -95 */ 109fb8521caSDavid Sterba errstr = "Operation not supported"; 110fb8521caSDavid Sterba break; 111fb8521caSDavid Sterba case -EUCLEAN: /* -117 */ 112fb8521caSDavid Sterba errstr = "Filesystem corrupted"; 113fb8521caSDavid Sterba break; 114fb8521caSDavid Sterba case -EDQUOT: /* -122 */ 115fb8521caSDavid Sterba errstr = "Quota exceeded"; 116fb8521caSDavid Sterba break; 117acce952bSliubo } 118acce952bSliubo 119acce952bSliubo return errstr; 120acce952bSliubo } 121acce952bSliubo 122acce952bSliubo /* 12334d97007SAnand Jain * __btrfs_handle_fs_error decodes expected errors from the caller and 12452042d8eSAndrea Gelmini * invokes the appropriate error response. 125acce952bSliubo */ 126c0d19e2bSDavid Sterba __cold 12734d97007SAnand Jain void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function, 1284da35113SJeff Mahoney unsigned int line, int errno, const char *fmt, ...) 129acce952bSliubo { 130acce952bSliubo struct super_block *sb = fs_info->sb; 13157d816a1SAnand Jain #ifdef CONFIG_PRINTK 132acce952bSliubo const char *errstr; 13357d816a1SAnand Jain #endif 134acce952bSliubo 135acce952bSliubo /* 136acce952bSliubo * Special case: if the error is EROFS, and we're already 1371751e8a6SLinus Torvalds * under SB_RDONLY, then it is safe here. 138acce952bSliubo */ 139bc98a42cSDavid Howells if (errno == -EROFS && sb_rdonly(sb)) 140acce952bSliubo return; 141acce952bSliubo 14257d816a1SAnand Jain #ifdef CONFIG_PRINTK 14308748810SDavid Sterba errstr = btrfs_decode_error(errno); 1444da35113SJeff Mahoney if (fmt) { 14537252a66SEric Sandeen struct va_format vaf; 14637252a66SEric Sandeen va_list args; 14737252a66SEric Sandeen 14837252a66SEric Sandeen va_start(args, fmt); 14937252a66SEric Sandeen vaf.fmt = fmt; 15037252a66SEric Sandeen vaf.va = &args; 1514da35113SJeff Mahoney 15262e85577SJeff Mahoney pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s (%pV)\n", 15308748810SDavid Sterba sb->s_id, function, line, errno, errstr, &vaf); 15437252a66SEric Sandeen va_end(args); 1554da35113SJeff Mahoney } else { 15662e85577SJeff Mahoney pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s\n", 15708748810SDavid Sterba sb->s_id, function, line, errno, errstr); 1584da35113SJeff Mahoney } 15957d816a1SAnand Jain #endif 160acce952bSliubo 1610713d90cSAnand Jain /* 1620713d90cSAnand Jain * Today we only save the error info to memory. Long term we'll 1630713d90cSAnand Jain * also send it down to the disk 1640713d90cSAnand Jain */ 1650713d90cSAnand Jain set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state); 1660713d90cSAnand Jain 1674da35113SJeff Mahoney /* Don't go through full error handling during mount */ 168922ea899SAnand Jain if (!(sb->s_flags & SB_BORN)) 169922ea899SAnand Jain return; 170922ea899SAnand Jain 171922ea899SAnand Jain if (sb_rdonly(sb)) 172922ea899SAnand Jain return; 173922ea899SAnand Jain 174b0643e59SDennis Zhou btrfs_discard_stop(fs_info); 175b0643e59SDennis Zhou 176922ea899SAnand Jain /* btrfs handle error by forcing the filesystem readonly */ 177922ea899SAnand Jain sb->s_flags |= SB_RDONLY; 178922ea899SAnand Jain btrfs_info(fs_info, "forced readonly"); 179922ea899SAnand Jain /* 180922ea899SAnand Jain * Note that a running device replace operation is not canceled here 181922ea899SAnand Jain * although there is no way to update the progress. It would add the 182922ea899SAnand Jain * risk of a deadlock, therefore the canceling is omitted. The only 183922ea899SAnand Jain * penalty is that some I/O remains active until the procedure 18452042d8eSAndrea Gelmini * completes. The next time when the filesystem is mounted writable 185922ea899SAnand Jain * again, the device replace operation continues. 186922ea899SAnand Jain */ 187acce952bSliubo } 1884da35113SJeff Mahoney 18957d816a1SAnand Jain #ifdef CONFIG_PRINTK 190533574c6SJoe Perches static const char * const logtypes[] = { 1914da35113SJeff Mahoney "emergency", 1924da35113SJeff Mahoney "alert", 1934da35113SJeff Mahoney "critical", 1944da35113SJeff Mahoney "error", 1954da35113SJeff Mahoney "warning", 1964da35113SJeff Mahoney "notice", 1974da35113SJeff Mahoney "info", 1984da35113SJeff Mahoney "debug", 1994da35113SJeff Mahoney }; 2004da35113SJeff Mahoney 20135f4e5e6SNikolay Borisov 20235f4e5e6SNikolay Borisov /* 20335f4e5e6SNikolay Borisov * Use one ratelimit state per log level so that a flood of less important 20435f4e5e6SNikolay Borisov * messages doesn't cause more important ones to be dropped. 20535f4e5e6SNikolay Borisov */ 20635f4e5e6SNikolay Borisov static struct ratelimit_state printk_limits[] = { 20735f4e5e6SNikolay Borisov RATELIMIT_STATE_INIT(printk_limits[0], DEFAULT_RATELIMIT_INTERVAL, 100), 20835f4e5e6SNikolay Borisov RATELIMIT_STATE_INIT(printk_limits[1], DEFAULT_RATELIMIT_INTERVAL, 100), 20935f4e5e6SNikolay Borisov RATELIMIT_STATE_INIT(printk_limits[2], DEFAULT_RATELIMIT_INTERVAL, 100), 21035f4e5e6SNikolay Borisov RATELIMIT_STATE_INIT(printk_limits[3], DEFAULT_RATELIMIT_INTERVAL, 100), 21135f4e5e6SNikolay Borisov RATELIMIT_STATE_INIT(printk_limits[4], DEFAULT_RATELIMIT_INTERVAL, 100), 21235f4e5e6SNikolay Borisov RATELIMIT_STATE_INIT(printk_limits[5], DEFAULT_RATELIMIT_INTERVAL, 100), 21335f4e5e6SNikolay Borisov RATELIMIT_STATE_INIT(printk_limits[6], DEFAULT_RATELIMIT_INTERVAL, 100), 21435f4e5e6SNikolay Borisov RATELIMIT_STATE_INIT(printk_limits[7], DEFAULT_RATELIMIT_INTERVAL, 100), 21535f4e5e6SNikolay Borisov }; 21635f4e5e6SNikolay Borisov 217b105e927SDavid Sterba void __cold btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...) 2184da35113SJeff Mahoney { 21940f7828bSPetr Mladek char lvl[PRINTK_MAX_SINGLE_HEADER_LEN + 1] = "\0"; 2204da35113SJeff Mahoney struct va_format vaf; 2214da35113SJeff Mahoney va_list args; 222533574c6SJoe Perches int kern_level; 22340f7828bSPetr Mladek const char *type = logtypes[4]; 22440f7828bSPetr Mladek struct ratelimit_state *ratelimit = &printk_limits[4]; 2254da35113SJeff Mahoney 2264da35113SJeff Mahoney va_start(args, fmt); 2274da35113SJeff Mahoney 228262c5e86SPetr Mladek while ((kern_level = printk_get_level(fmt)) != 0) { 229533574c6SJoe Perches size_t size = printk_skip_level(fmt) - fmt; 230262c5e86SPetr Mladek 231262c5e86SPetr Mladek if (kern_level >= '0' && kern_level <= '7') { 232533574c6SJoe Perches memcpy(lvl, fmt, size); 233533574c6SJoe Perches lvl[size] = '\0'; 234533574c6SJoe Perches type = logtypes[kern_level - '0']; 23535f4e5e6SNikolay Borisov ratelimit = &printk_limits[kern_level - '0']; 236262c5e86SPetr Mladek } 237262c5e86SPetr Mladek fmt += size; 238262c5e86SPetr Mladek } 239262c5e86SPetr Mladek 2404da35113SJeff Mahoney vaf.fmt = fmt; 2414da35113SJeff Mahoney vaf.va = &args; 242533574c6SJoe Perches 24335f4e5e6SNikolay Borisov if (__ratelimit(ratelimit)) 2443993b112SColin Ian King printk("%sBTRFS %s (device %s): %pV\n", lvl, type, 2453993b112SColin Ian King fs_info ? fs_info->sb->s_id : "<unknown>", &vaf); 246533574c6SJoe Perches 247533574c6SJoe Perches va_end(args); 2484da35113SJeff Mahoney } 249533574c6SJoe Perches #endif 250533574c6SJoe Perches 2518c342930SJeff Mahoney /* 25249b25e05SJeff Mahoney * We only mark the transaction aborted and then set the file system read-only. 25349b25e05SJeff Mahoney * This will prevent new transactions from starting or trying to join this 25449b25e05SJeff Mahoney * one. 25549b25e05SJeff Mahoney * 25649b25e05SJeff Mahoney * This means that error recovery at the call site is limited to freeing 25749b25e05SJeff Mahoney * any local memory allocations and passing the error code up without 25849b25e05SJeff Mahoney * further cleanup. The transaction should complete as it normally would 25949b25e05SJeff Mahoney * in the call path but will return -EIO. 26049b25e05SJeff Mahoney * 26149b25e05SJeff Mahoney * We'll complete the cleanup in btrfs_end_transaction and 26249b25e05SJeff Mahoney * btrfs_commit_transaction. 26349b25e05SJeff Mahoney */ 264c0d19e2bSDavid Sterba __cold 26549b25e05SJeff Mahoney void __btrfs_abort_transaction(struct btrfs_trans_handle *trans, 26666642832SJeff Mahoney const char *function, 26749b25e05SJeff Mahoney unsigned int line, int errno) 26849b25e05SJeff Mahoney { 26966642832SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 27066642832SJeff Mahoney 271bf31f87fSDavid Sterba WRITE_ONCE(trans->aborted, errno); 27249b25e05SJeff Mahoney /* Nothing used. The other threads that have joined this 27349b25e05SJeff Mahoney * transaction may be able to continue. */ 27464c12921SJeff Mahoney if (!trans->dirty && list_empty(&trans->new_bgs)) { 27569ce977aSMiao Xie const char *errstr; 27669ce977aSMiao Xie 27708748810SDavid Sterba errstr = btrfs_decode_error(errno); 27866642832SJeff Mahoney btrfs_warn(fs_info, 279c2cf52ebSSimon Kirby "%s:%d: Aborting unused transaction(%s).", 28069ce977aSMiao Xie function, line, errstr); 28149b25e05SJeff Mahoney return; 28249b25e05SJeff Mahoney } 28320c7bcecSSeraphime Kirkovski WRITE_ONCE(trans->transaction->aborted, errno); 284501407aaSJosef Bacik /* Wake up anybody who may be waiting on this transaction */ 28566642832SJeff Mahoney wake_up(&fs_info->transaction_wait); 28666642832SJeff Mahoney wake_up(&fs_info->transaction_blocked_wait); 28766642832SJeff Mahoney __btrfs_handle_fs_error(fs_info, function, line, errno, NULL); 28849b25e05SJeff Mahoney } 28949b25e05SJeff Mahoney /* 2908c342930SJeff Mahoney * __btrfs_panic decodes unexpected, fatal errors from the caller, 2918c342930SJeff Mahoney * issues an alert, and either panics or BUGs, depending on mount options. 2928c342930SJeff Mahoney */ 293c0d19e2bSDavid Sterba __cold 2948c342930SJeff Mahoney void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function, 2958c342930SJeff Mahoney unsigned int line, int errno, const char *fmt, ...) 2968c342930SJeff Mahoney { 2978c342930SJeff Mahoney char *s_id = "<unknown>"; 2988c342930SJeff Mahoney const char *errstr; 2998c342930SJeff Mahoney struct va_format vaf = { .fmt = fmt }; 3008c342930SJeff Mahoney va_list args; 3018c342930SJeff Mahoney 3028c342930SJeff Mahoney if (fs_info) 3038c342930SJeff Mahoney s_id = fs_info->sb->s_id; 3048c342930SJeff Mahoney 3058c342930SJeff Mahoney va_start(args, fmt); 3068c342930SJeff Mahoney vaf.va = &args; 3078c342930SJeff Mahoney 30808748810SDavid Sterba errstr = btrfs_decode_error(errno); 309d8953d69SSatoru Takeuchi if (fs_info && (btrfs_test_opt(fs_info, PANIC_ON_FATAL_ERROR))) 31008748810SDavid Sterba panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n", 31108748810SDavid Sterba s_id, function, line, &vaf, errno, errstr); 3128c342930SJeff Mahoney 313efe120a0SFrank Holton btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)", 314efe120a0SFrank Holton function, line, &vaf, errno, errstr); 3158c342930SJeff Mahoney va_end(args); 3168c342930SJeff Mahoney /* Caller calls BUG() */ 3178c342930SJeff Mahoney } 318acce952bSliubo 319e20d96d6SChris Mason static void btrfs_put_super(struct super_block *sb) 320e20d96d6SChris Mason { 3216bccf3abSJeff Mahoney close_ctree(btrfs_sb(sb)); 322e20d96d6SChris Mason } 3232e635a27SChris Mason 32495e05289SChris Mason enum { 325416a7202SDavid Sterba Opt_acl, Opt_noacl, 326416a7202SDavid Sterba Opt_clear_cache, 327416a7202SDavid Sterba Opt_commit_interval, 328416a7202SDavid Sterba Opt_compress, 329416a7202SDavid Sterba Opt_compress_force, 330416a7202SDavid Sterba Opt_compress_force_type, 331416a7202SDavid Sterba Opt_compress_type, 332416a7202SDavid Sterba Opt_degraded, 333416a7202SDavid Sterba Opt_device, 334416a7202SDavid Sterba Opt_fatal_errors, 335416a7202SDavid Sterba Opt_flushoncommit, Opt_noflushoncommit, 336416a7202SDavid Sterba Opt_inode_cache, Opt_noinode_cache, 337416a7202SDavid Sterba Opt_max_inline, 338416a7202SDavid Sterba Opt_barrier, Opt_nobarrier, 339416a7202SDavid Sterba Opt_datacow, Opt_nodatacow, 340416a7202SDavid Sterba Opt_datasum, Opt_nodatasum, 341416a7202SDavid Sterba Opt_defrag, Opt_nodefrag, 342416a7202SDavid Sterba Opt_discard, Opt_nodiscard, 343b0643e59SDennis Zhou Opt_discard_mode, 344416a7202SDavid Sterba Opt_norecovery, 345416a7202SDavid Sterba Opt_ratio, 346416a7202SDavid Sterba Opt_rescan_uuid_tree, 347416a7202SDavid Sterba Opt_skip_balance, 348416a7202SDavid Sterba Opt_space_cache, Opt_no_space_cache, 349416a7202SDavid Sterba Opt_space_cache_version, 350416a7202SDavid Sterba Opt_ssd, Opt_nossd, 351416a7202SDavid Sterba Opt_ssd_spread, Opt_nossd_spread, 352416a7202SDavid Sterba Opt_subvol, 35337becec9SOmar Sandoval Opt_subvol_empty, 354416a7202SDavid Sterba Opt_subvolid, 355416a7202SDavid Sterba Opt_thread_pool, 356416a7202SDavid Sterba Opt_treelog, Opt_notreelog, 357416a7202SDavid Sterba Opt_user_subvol_rm_allowed, 358416a7202SDavid Sterba 35974ef0018SQu Wenruo /* Rescue options */ 36074ef0018SQu Wenruo Opt_rescue, 36174ef0018SQu Wenruo Opt_usebackuproot, 36274ef0018SQu Wenruo Opt_nologreplay, 36374ef0018SQu Wenruo 364416a7202SDavid Sterba /* Deprecated options */ 365416a7202SDavid Sterba Opt_recovery, 366416a7202SDavid Sterba 367416a7202SDavid Sterba /* Debugging options */ 368416a7202SDavid Sterba Opt_check_integrity, 36970f6d82eSOmar Sandoval Opt_check_integrity_including_extent_data, 370416a7202SDavid Sterba Opt_check_integrity_print_mask, 371416a7202SDavid Sterba Opt_enospc_debug, Opt_noenospc_debug, 372d0bd4560SJosef Bacik #ifdef CONFIG_BTRFS_DEBUG 373d0bd4560SJosef Bacik Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all, 374d0bd4560SJosef Bacik #endif 375fb592373SJosef Bacik #ifdef CONFIG_BTRFS_FS_REF_VERIFY 376fb592373SJosef Bacik Opt_ref_verify, 377fb592373SJosef Bacik #endif 3789555c6c1SIlya Dryomov Opt_err, 37995e05289SChris Mason }; 38095e05289SChris Mason 3814d4ab6d6SDavid Sterba static const match_table_t tokens = { 382416a7202SDavid Sterba {Opt_acl, "acl"}, 383416a7202SDavid Sterba {Opt_noacl, "noacl"}, 384416a7202SDavid Sterba {Opt_clear_cache, "clear_cache"}, 385416a7202SDavid Sterba {Opt_commit_interval, "commit=%u"}, 386c8b97818SChris Mason {Opt_compress, "compress"}, 387261507a0SLi Zefan {Opt_compress_type, "compress=%s"}, 388a555f810SChris Mason {Opt_compress_force, "compress-force"}, 389261507a0SLi Zefan {Opt_compress_force_type, "compress-force=%s"}, 390416a7202SDavid Sterba {Opt_degraded, "degraded"}, 391416a7202SDavid Sterba {Opt_device, "device=%s"}, 392416a7202SDavid Sterba {Opt_fatal_errors, "fatal_errors=%s"}, 393dccae999SSage Weil {Opt_flushoncommit, "flushoncommit"}, 3942c9ee856SQu Wenruo {Opt_noflushoncommit, "noflushoncommit"}, 3954b9465cbSChris Mason {Opt_inode_cache, "inode_cache"}, 3963818aea2SQu Wenruo {Opt_noinode_cache, "noinode_cache"}, 397416a7202SDavid Sterba {Opt_max_inline, "max_inline=%s"}, 398416a7202SDavid Sterba {Opt_barrier, "barrier"}, 399416a7202SDavid Sterba {Opt_nobarrier, "nobarrier"}, 400416a7202SDavid Sterba {Opt_datacow, "datacow"}, 401416a7202SDavid Sterba {Opt_nodatacow, "nodatacow"}, 402416a7202SDavid Sterba {Opt_datasum, "datasum"}, 403416a7202SDavid Sterba {Opt_nodatasum, "nodatasum"}, 404416a7202SDavid Sterba {Opt_defrag, "autodefrag"}, 405416a7202SDavid Sterba {Opt_nodefrag, "noautodefrag"}, 406416a7202SDavid Sterba {Opt_discard, "discard"}, 407b0643e59SDennis Zhou {Opt_discard_mode, "discard=%s"}, 408416a7202SDavid Sterba {Opt_nodiscard, "nodiscard"}, 409416a7202SDavid Sterba {Opt_norecovery, "norecovery"}, 410416a7202SDavid Sterba {Opt_ratio, "metadata_ratio=%u"}, 411416a7202SDavid Sterba {Opt_rescan_uuid_tree, "rescan_uuid_tree"}, 4129555c6c1SIlya Dryomov {Opt_skip_balance, "skip_balance"}, 413416a7202SDavid Sterba {Opt_space_cache, "space_cache"}, 414416a7202SDavid Sterba {Opt_no_space_cache, "nospace_cache"}, 415416a7202SDavid Sterba {Opt_space_cache_version, "space_cache=%s"}, 416416a7202SDavid Sterba {Opt_ssd, "ssd"}, 417416a7202SDavid Sterba {Opt_nossd, "nossd"}, 418416a7202SDavid Sterba {Opt_ssd_spread, "ssd_spread"}, 419416a7202SDavid Sterba {Opt_nossd_spread, "nossd_spread"}, 420416a7202SDavid Sterba {Opt_subvol, "subvol=%s"}, 42137becec9SOmar Sandoval {Opt_subvol_empty, "subvol="}, 422416a7202SDavid Sterba {Opt_subvolid, "subvolid=%s"}, 423416a7202SDavid Sterba {Opt_thread_pool, "thread_pool=%u"}, 424416a7202SDavid Sterba {Opt_treelog, "treelog"}, 425416a7202SDavid Sterba {Opt_notreelog, "notreelog"}, 426416a7202SDavid Sterba {Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"}, 427416a7202SDavid Sterba 42874ef0018SQu Wenruo /* Rescue options */ 42974ef0018SQu Wenruo {Opt_rescue, "rescue=%s"}, 43074ef0018SQu Wenruo /* Deprecated, with alias rescue=nologreplay */ 43174ef0018SQu Wenruo {Opt_nologreplay, "nologreplay"}, 43274ef0018SQu Wenruo /* Deprecated, with alias rescue=usebackuproot */ 43374ef0018SQu Wenruo {Opt_usebackuproot, "usebackuproot"}, 43474ef0018SQu Wenruo 435416a7202SDavid Sterba /* Deprecated options */ 436416a7202SDavid Sterba {Opt_recovery, "recovery"}, 437416a7202SDavid Sterba 438416a7202SDavid Sterba /* Debugging options */ 43921adbd5cSStefan Behrens {Opt_check_integrity, "check_int"}, 44021adbd5cSStefan Behrens {Opt_check_integrity_including_extent_data, "check_int_data"}, 44102453bdeSAnand Jain {Opt_check_integrity_print_mask, "check_int_print_mask=%u"}, 442416a7202SDavid Sterba {Opt_enospc_debug, "enospc_debug"}, 443416a7202SDavid Sterba {Opt_noenospc_debug, "noenospc_debug"}, 444d0bd4560SJosef Bacik #ifdef CONFIG_BTRFS_DEBUG 445d0bd4560SJosef Bacik {Opt_fragment_data, "fragment=data"}, 446d0bd4560SJosef Bacik {Opt_fragment_metadata, "fragment=metadata"}, 447d0bd4560SJosef Bacik {Opt_fragment_all, "fragment=all"}, 448d0bd4560SJosef Bacik #endif 449fb592373SJosef Bacik #ifdef CONFIG_BTRFS_FS_REF_VERIFY 450fb592373SJosef Bacik {Opt_ref_verify, "ref_verify"}, 451fb592373SJosef Bacik #endif 45233268eafSJosef Bacik {Opt_err, NULL}, 45395e05289SChris Mason }; 45495e05289SChris Mason 45574ef0018SQu Wenruo static const match_table_t rescue_tokens = { 45674ef0018SQu Wenruo {Opt_usebackuproot, "usebackuproot"}, 45774ef0018SQu Wenruo {Opt_nologreplay, "nologreplay"}, 45874ef0018SQu Wenruo {Opt_err, NULL}, 45974ef0018SQu Wenruo }; 46074ef0018SQu Wenruo 46174ef0018SQu Wenruo static int parse_rescue_options(struct btrfs_fs_info *info, const char *options) 46274ef0018SQu Wenruo { 46374ef0018SQu Wenruo char *opts; 46474ef0018SQu Wenruo char *orig; 46574ef0018SQu Wenruo char *p; 46674ef0018SQu Wenruo substring_t args[MAX_OPT_ARGS]; 46774ef0018SQu Wenruo int ret = 0; 46874ef0018SQu Wenruo 46974ef0018SQu Wenruo opts = kstrdup(options, GFP_KERNEL); 47074ef0018SQu Wenruo if (!opts) 47174ef0018SQu Wenruo return -ENOMEM; 47274ef0018SQu Wenruo orig = opts; 47374ef0018SQu Wenruo 47474ef0018SQu Wenruo while ((p = strsep(&opts, ":")) != NULL) { 47574ef0018SQu Wenruo int token; 47674ef0018SQu Wenruo 47774ef0018SQu Wenruo if (!*p) 47874ef0018SQu Wenruo continue; 47974ef0018SQu Wenruo token = match_token(p, rescue_tokens, args); 48074ef0018SQu Wenruo switch (token){ 48174ef0018SQu Wenruo case Opt_usebackuproot: 48274ef0018SQu Wenruo btrfs_info(info, 48374ef0018SQu Wenruo "trying to use backup root at mount time"); 48474ef0018SQu Wenruo btrfs_set_opt(info->mount_opt, USEBACKUPROOT); 48574ef0018SQu Wenruo break; 48674ef0018SQu Wenruo case Opt_nologreplay: 48774ef0018SQu Wenruo btrfs_set_and_info(info, NOLOGREPLAY, 48874ef0018SQu Wenruo "disabling log replay at mount time"); 48974ef0018SQu Wenruo break; 49074ef0018SQu Wenruo case Opt_err: 49174ef0018SQu Wenruo btrfs_info(info, "unrecognized rescue option '%s'", p); 49274ef0018SQu Wenruo ret = -EINVAL; 49374ef0018SQu Wenruo goto out; 49474ef0018SQu Wenruo default: 49574ef0018SQu Wenruo break; 49674ef0018SQu Wenruo } 49774ef0018SQu Wenruo 49874ef0018SQu Wenruo } 49974ef0018SQu Wenruo out: 50074ef0018SQu Wenruo kfree(orig); 50174ef0018SQu Wenruo return ret; 50274ef0018SQu Wenruo } 50374ef0018SQu Wenruo 504edf24abeSChristoph Hellwig /* 505edf24abeSChristoph Hellwig * Regular mount options parser. Everything that is needed only when 506edf24abeSChristoph Hellwig * reading in a new superblock is parsed here. 50749b25e05SJeff Mahoney * XXX JDM: This needs to be cleaned up for remount. 508edf24abeSChristoph Hellwig */ 5092ff7e61eSJeff Mahoney int btrfs_parse_options(struct btrfs_fs_info *info, char *options, 51096da0919SQu Wenruo unsigned long new_flags) 51195e05289SChris Mason { 51295e05289SChris Mason substring_t args[MAX_OPT_ARGS]; 513e215772cSMisono, Tomohiro char *p, *num; 51473bc1876SJosef Bacik u64 cache_gen; 5154543df7eSChris Mason int intarg; 516a7a3f7caSSage Weil int ret = 0; 517261507a0SLi Zefan char *compress_type; 518261507a0SLi Zefan bool compress_force = false; 519b7c47bbbSTsutomu Itoh enum btrfs_compression_type saved_compress_type; 52027942c99SDavid Sterba int saved_compress_level; 521b7c47bbbSTsutomu Itoh bool saved_compress_force; 522b7c47bbbSTsutomu Itoh int no_compress = 0; 523b6cda9bcSChris Mason 5240b246afaSJeff Mahoney cache_gen = btrfs_super_cache_generation(info->super_copy); 5250b246afaSJeff Mahoney if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) 52670f6d82eSOmar Sandoval btrfs_set_opt(info->mount_opt, FREE_SPACE_TREE); 52770f6d82eSOmar Sandoval else if (cache_gen) 52873bc1876SJosef Bacik btrfs_set_opt(info->mount_opt, SPACE_CACHE); 52973bc1876SJosef Bacik 53096da0919SQu Wenruo /* 53196da0919SQu Wenruo * Even the options are empty, we still need to do extra check 53296da0919SQu Wenruo * against new flags 53396da0919SQu Wenruo */ 53495e05289SChris Mason if (!options) 53596da0919SQu Wenruo goto check; 53695e05289SChris Mason 53795e05289SChris Mason while ((p = strsep(&options, ",")) != NULL) { 53895e05289SChris Mason int token; 53995e05289SChris Mason if (!*p) 54095e05289SChris Mason continue; 54195e05289SChris Mason 54295e05289SChris Mason token = match_token(p, tokens, args); 54395e05289SChris Mason switch (token) { 544dfe25020SChris Mason case Opt_degraded: 5450b246afaSJeff Mahoney btrfs_info(info, "allowing degraded mounts"); 546dfe25020SChris Mason btrfs_set_opt(info->mount_opt, DEGRADED); 547dfe25020SChris Mason break; 54895e05289SChris Mason case Opt_subvol: 54937becec9SOmar Sandoval case Opt_subvol_empty: 55073f73415SJosef Bacik case Opt_subvolid: 55143e570b0SChristoph Hellwig case Opt_device: 552edf24abeSChristoph Hellwig /* 553fa59f27cSAnand Jain * These are parsed by btrfs_parse_subvol_options or 554fa59f27cSAnand Jain * btrfs_parse_device_options and can be ignored here. 555edf24abeSChristoph Hellwig */ 55695e05289SChris Mason break; 557b6cda9bcSChris Mason case Opt_nodatasum: 5583cdde224SJeff Mahoney btrfs_set_and_info(info, NODATASUM, 55907802534SQu Wenruo "setting nodatasum"); 560be20aa9dSChris Mason break; 561d399167dSQu Wenruo case Opt_datasum: 5623cdde224SJeff Mahoney if (btrfs_test_opt(info, NODATASUM)) { 5633cdde224SJeff Mahoney if (btrfs_test_opt(info, NODATACOW)) 5640b246afaSJeff Mahoney btrfs_info(info, 5655d163e0eSJeff Mahoney "setting datasum, datacow enabled"); 566d399167dSQu Wenruo else 5670b246afaSJeff Mahoney btrfs_info(info, "setting datasum"); 56807802534SQu Wenruo } 569d399167dSQu Wenruo btrfs_clear_opt(info->mount_opt, NODATACOW); 570d399167dSQu Wenruo btrfs_clear_opt(info->mount_opt, NODATASUM); 571d399167dSQu Wenruo break; 572be20aa9dSChris Mason case Opt_nodatacow: 5733cdde224SJeff Mahoney if (!btrfs_test_opt(info, NODATACOW)) { 5743cdde224SJeff Mahoney if (!btrfs_test_opt(info, COMPRESS) || 5753cdde224SJeff Mahoney !btrfs_test_opt(info, FORCE_COMPRESS)) { 5760b246afaSJeff Mahoney btrfs_info(info, 577efe120a0SFrank Holton "setting nodatacow, compression disabled"); 578bedb2ccaSAndrei Popa } else { 5790b246afaSJeff Mahoney btrfs_info(info, "setting nodatacow"); 580bedb2ccaSAndrei Popa } 58107802534SQu Wenruo } 582bedb2ccaSAndrei Popa btrfs_clear_opt(info->mount_opt, COMPRESS); 583bedb2ccaSAndrei Popa btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS); 584be20aa9dSChris Mason btrfs_set_opt(info->mount_opt, NODATACOW); 585be20aa9dSChris Mason btrfs_set_opt(info->mount_opt, NODATASUM); 586b6cda9bcSChris Mason break; 587a258af7aSQu Wenruo case Opt_datacow: 5883cdde224SJeff Mahoney btrfs_clear_and_info(info, NODATACOW, 58907802534SQu Wenruo "setting datacow"); 590a258af7aSQu Wenruo break; 591a555f810SChris Mason case Opt_compress_force: 592261507a0SLi Zefan case Opt_compress_force_type: 593261507a0SLi Zefan compress_force = true; 594c730ae0cSMarcos Paulo de Souza fallthrough; 595261507a0SLi Zefan case Opt_compress: 596261507a0SLi Zefan case Opt_compress_type: 5973cdde224SJeff Mahoney saved_compress_type = btrfs_test_opt(info, 5983cdde224SJeff Mahoney COMPRESS) ? 599b7c47bbbSTsutomu Itoh info->compress_type : BTRFS_COMPRESS_NONE; 600b7c47bbbSTsutomu Itoh saved_compress_force = 6013cdde224SJeff Mahoney btrfs_test_opt(info, FORCE_COMPRESS); 60227942c99SDavid Sterba saved_compress_level = info->compress_level; 603261507a0SLi Zefan if (token == Opt_compress || 604261507a0SLi Zefan token == Opt_compress_force || 605a7164fa4SDavid Sterba strncmp(args[0].from, "zlib", 4) == 0) { 606261507a0SLi Zefan compress_type = "zlib"; 607eae8d825SQu Wenruo 608261507a0SLi Zefan info->compress_type = BTRFS_COMPRESS_ZLIB; 609eae8d825SQu Wenruo info->compress_level = BTRFS_ZLIB_DEFAULT_LEVEL; 610eae8d825SQu Wenruo /* 611eae8d825SQu Wenruo * args[0] contains uninitialized data since 612eae8d825SQu Wenruo * for these tokens we don't expect any 613eae8d825SQu Wenruo * parameter. 614eae8d825SQu Wenruo */ 615eae8d825SQu Wenruo if (token != Opt_compress && 616eae8d825SQu Wenruo token != Opt_compress_force) 617f51d2b59SDavid Sterba info->compress_level = 618d0ab62ceSDennis Zhou btrfs_compress_str2level( 619d0ab62ceSDennis Zhou BTRFS_COMPRESS_ZLIB, 620d0ab62ceSDennis Zhou args[0].from + 4); 621063849eaSArnd Hannemann btrfs_set_opt(info->mount_opt, COMPRESS); 622bedb2ccaSAndrei Popa btrfs_clear_opt(info->mount_opt, NODATACOW); 623bedb2ccaSAndrei Popa btrfs_clear_opt(info->mount_opt, NODATASUM); 624b7c47bbbSTsutomu Itoh no_compress = 0; 625a7164fa4SDavid Sterba } else if (strncmp(args[0].from, "lzo", 3) == 0) { 626a6fa6faeSLi Zefan compress_type = "lzo"; 627a6fa6faeSLi Zefan info->compress_type = BTRFS_COMPRESS_LZO; 628*282dd7d7SMarcos Paulo de Souza info->compress_level = 0; 629063849eaSArnd Hannemann btrfs_set_opt(info->mount_opt, COMPRESS); 630bedb2ccaSAndrei Popa btrfs_clear_opt(info->mount_opt, NODATACOW); 631bedb2ccaSAndrei Popa btrfs_clear_opt(info->mount_opt, NODATASUM); 6322b0ce2c2SMitch Harder btrfs_set_fs_incompat(info, COMPRESS_LZO); 633b7c47bbbSTsutomu Itoh no_compress = 0; 6343f93aef5SDennis Zhou } else if (strncmp(args[0].from, "zstd", 4) == 0) { 6355c1aab1dSNick Terrell compress_type = "zstd"; 6365c1aab1dSNick Terrell info->compress_type = BTRFS_COMPRESS_ZSTD; 6373f93aef5SDennis Zhou info->compress_level = 6383f93aef5SDennis Zhou btrfs_compress_str2level( 6393f93aef5SDennis Zhou BTRFS_COMPRESS_ZSTD, 6403f93aef5SDennis Zhou args[0].from + 4); 6415c1aab1dSNick Terrell btrfs_set_opt(info->mount_opt, COMPRESS); 6425c1aab1dSNick Terrell btrfs_clear_opt(info->mount_opt, NODATACOW); 6435c1aab1dSNick Terrell btrfs_clear_opt(info->mount_opt, NODATASUM); 6445c1aab1dSNick Terrell btrfs_set_fs_incompat(info, COMPRESS_ZSTD); 6455c1aab1dSNick Terrell no_compress = 0; 646063849eaSArnd Hannemann } else if (strncmp(args[0].from, "no", 2) == 0) { 647063849eaSArnd Hannemann compress_type = "no"; 64827942c99SDavid Sterba info->compress_level = 0; 64927942c99SDavid Sterba info->compress_type = 0; 650063849eaSArnd Hannemann btrfs_clear_opt(info->mount_opt, COMPRESS); 651063849eaSArnd Hannemann btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS); 652063849eaSArnd Hannemann compress_force = false; 653b7c47bbbSTsutomu Itoh no_compress++; 654261507a0SLi Zefan } else { 655261507a0SLi Zefan ret = -EINVAL; 656261507a0SLi Zefan goto out; 657261507a0SLi Zefan } 658261507a0SLi Zefan 659261507a0SLi Zefan if (compress_force) { 660b7c47bbbSTsutomu Itoh btrfs_set_opt(info->mount_opt, FORCE_COMPRESS); 661143f3636SDavid Sterba } else { 6624027e0f4SWang Shilong /* 6634027e0f4SWang Shilong * If we remount from compress-force=xxx to 6644027e0f4SWang Shilong * compress=xxx, we need clear FORCE_COMPRESS 6654027e0f4SWang Shilong * flag, otherwise, there is no way for users 6664027e0f4SWang Shilong * to disable forcible compression separately. 6674027e0f4SWang Shilong */ 6684027e0f4SWang Shilong btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS); 669a7e252afSMiao Xie } 67027942c99SDavid Sterba if (no_compress == 1) { 67127942c99SDavid Sterba btrfs_info(info, "use no compression"); 67227942c99SDavid Sterba } else if ((info->compress_type != saved_compress_type) || 67327942c99SDavid Sterba (compress_force != saved_compress_force) || 67427942c99SDavid Sterba (info->compress_level != saved_compress_level)) { 675f51d2b59SDavid Sterba btrfs_info(info, "%s %s compression, level %d", 676b7c47bbbSTsutomu Itoh (compress_force) ? "force" : "use", 677f51d2b59SDavid Sterba compress_type, info->compress_level); 678b7c47bbbSTsutomu Itoh } 679b7c47bbbSTsutomu Itoh compress_force = false; 680a555f810SChris Mason break; 681e18e4809SChris Mason case Opt_ssd: 6823cdde224SJeff Mahoney btrfs_set_and_info(info, SSD, 683583b7231SHans van Kranenburg "enabling ssd optimizations"); 684951e7966SAdam Borowski btrfs_clear_opt(info->mount_opt, NOSSD); 685e18e4809SChris Mason break; 686451d7585SChris Mason case Opt_ssd_spread: 687583b7231SHans van Kranenburg btrfs_set_and_info(info, SSD, 688583b7231SHans van Kranenburg "enabling ssd optimizations"); 6893cdde224SJeff Mahoney btrfs_set_and_info(info, SSD_SPREAD, 690583b7231SHans van Kranenburg "using spread ssd allocation scheme"); 691951e7966SAdam Borowski btrfs_clear_opt(info->mount_opt, NOSSD); 692451d7585SChris Mason break; 6933b30c22fSChris Mason case Opt_nossd: 694583b7231SHans van Kranenburg btrfs_set_opt(info->mount_opt, NOSSD); 695583b7231SHans van Kranenburg btrfs_clear_and_info(info, SSD, 696583b7231SHans van Kranenburg "not using ssd optimizations"); 697c730ae0cSMarcos Paulo de Souza fallthrough; 69862b8e077SHoward McLauchlan case Opt_nossd_spread: 699583b7231SHans van Kranenburg btrfs_clear_and_info(info, SSD_SPREAD, 700583b7231SHans van Kranenburg "not using spread ssd allocation scheme"); 7013b30c22fSChris Mason break; 702842bef58SQu Wenruo case Opt_barrier: 7033cdde224SJeff Mahoney btrfs_clear_and_info(info, NOBARRIER, 70407802534SQu Wenruo "turning on barriers"); 705842bef58SQu Wenruo break; 70621ad10cfSChris Mason case Opt_nobarrier: 7073cdde224SJeff Mahoney btrfs_set_and_info(info, NOBARRIER, 70807802534SQu Wenruo "turning off barriers"); 70921ad10cfSChris Mason break; 7104543df7eSChris Mason case Opt_thread_pool: 7112c334e87SWang Shilong ret = match_int(&args[0], &intarg); 7122c334e87SWang Shilong if (ret) { 7132c334e87SWang Shilong goto out; 714f7b885beSAnand Jain } else if (intarg == 0) { 7152c334e87SWang Shilong ret = -EINVAL; 7162c334e87SWang Shilong goto out; 7172c334e87SWang Shilong } 718f7b885beSAnand Jain info->thread_pool_size = intarg; 7194543df7eSChris Mason break; 7206f568d35SChris Mason case Opt_max_inline: 721edf24abeSChristoph Hellwig num = match_strdup(&args[0]); 7226f568d35SChris Mason if (num) { 72391748467SAkinobu Mita info->max_inline = memparse(num, NULL); 7246f568d35SChris Mason kfree(num); 7256f568d35SChris Mason 72615ada040SChris Mason if (info->max_inline) { 727feb5f965SMitch Harder info->max_inline = min_t(u64, 72815ada040SChris Mason info->max_inline, 7290b246afaSJeff Mahoney info->sectorsize); 73015ada040SChris Mason } 7310b246afaSJeff Mahoney btrfs_info(info, "max_inline at %llu", 732c1c9ff7cSGeert Uytterhoeven info->max_inline); 7332c334e87SWang Shilong } else { 7342c334e87SWang Shilong ret = -ENOMEM; 7352c334e87SWang Shilong goto out; 7366f568d35SChris Mason } 7376f568d35SChris Mason break; 738bd0330adSQu Wenruo case Opt_acl: 73945ff35d6SGuangliang Zhao #ifdef CONFIG_BTRFS_FS_POSIX_ACL 7401751e8a6SLinus Torvalds info->sb->s_flags |= SB_POSIXACL; 741bd0330adSQu Wenruo break; 74245ff35d6SGuangliang Zhao #else 7430b246afaSJeff Mahoney btrfs_err(info, "support for ACL not compiled in!"); 74445ff35d6SGuangliang Zhao ret = -EINVAL; 74545ff35d6SGuangliang Zhao goto out; 74645ff35d6SGuangliang Zhao #endif 74733268eafSJosef Bacik case Opt_noacl: 7481751e8a6SLinus Torvalds info->sb->s_flags &= ~SB_POSIXACL; 74933268eafSJosef Bacik break; 7503a5e1404SSage Weil case Opt_notreelog: 7513cdde224SJeff Mahoney btrfs_set_and_info(info, NOTREELOG, 75207802534SQu Wenruo "disabling tree log"); 7533a5e1404SSage Weil break; 754a88998f2SQu Wenruo case Opt_treelog: 7553cdde224SJeff Mahoney btrfs_clear_and_info(info, NOTREELOG, 75607802534SQu Wenruo "enabling tree log"); 757a88998f2SQu Wenruo break; 758fed8f166SQu Wenruo case Opt_norecovery: 75996da0919SQu Wenruo case Opt_nologreplay: 76074ef0018SQu Wenruo btrfs_warn(info, 76174ef0018SQu Wenruo "'nologreplay' is deprecated, use 'rescue=nologreplay' instead"); 7623cdde224SJeff Mahoney btrfs_set_and_info(info, NOLOGREPLAY, 76396da0919SQu Wenruo "disabling log replay at mount time"); 76496da0919SQu Wenruo break; 765dccae999SSage Weil case Opt_flushoncommit: 7663cdde224SJeff Mahoney btrfs_set_and_info(info, FLUSHONCOMMIT, 76707802534SQu Wenruo "turning on flush-on-commit"); 768dccae999SSage Weil break; 7692c9ee856SQu Wenruo case Opt_noflushoncommit: 7703cdde224SJeff Mahoney btrfs_clear_and_info(info, FLUSHONCOMMIT, 77107802534SQu Wenruo "turning off flush-on-commit"); 7722c9ee856SQu Wenruo break; 77397e728d4SJosef Bacik case Opt_ratio: 7742c334e87SWang Shilong ret = match_int(&args[0], &intarg); 775764cb8b4SAnand Jain if (ret) 7762c334e87SWang Shilong goto out; 77797e728d4SJosef Bacik info->metadata_ratio = intarg; 778764cb8b4SAnand Jain btrfs_info(info, "metadata ratio %u", 77997e728d4SJosef Bacik info->metadata_ratio); 78097e728d4SJosef Bacik break; 781e244a0aeSChristoph Hellwig case Opt_discard: 782b0643e59SDennis Zhou case Opt_discard_mode: 783b0643e59SDennis Zhou if (token == Opt_discard || 784b0643e59SDennis Zhou strcmp(args[0].from, "sync") == 0) { 785b0643e59SDennis Zhou btrfs_clear_opt(info->mount_opt, DISCARD_ASYNC); 78646b27f50SDennis Zhou btrfs_set_and_info(info, DISCARD_SYNC, 78746b27f50SDennis Zhou "turning on sync discard"); 788b0643e59SDennis Zhou } else if (strcmp(args[0].from, "async") == 0) { 789b0643e59SDennis Zhou btrfs_clear_opt(info->mount_opt, DISCARD_SYNC); 790b0643e59SDennis Zhou btrfs_set_and_info(info, DISCARD_ASYNC, 791b0643e59SDennis Zhou "turning on async discard"); 792b0643e59SDennis Zhou } else { 793b0643e59SDennis Zhou ret = -EINVAL; 794b0643e59SDennis Zhou goto out; 795b0643e59SDennis Zhou } 796e244a0aeSChristoph Hellwig break; 797e07a2adeSQu Wenruo case Opt_nodiscard: 79846b27f50SDennis Zhou btrfs_clear_and_info(info, DISCARD_SYNC, 79907802534SQu Wenruo "turning off discard"); 800b0643e59SDennis Zhou btrfs_clear_and_info(info, DISCARD_ASYNC, 801b0643e59SDennis Zhou "turning off async discard"); 802e07a2adeSQu Wenruo break; 8030af3d00bSJosef Bacik case Opt_space_cache: 80470f6d82eSOmar Sandoval case Opt_space_cache_version: 80570f6d82eSOmar Sandoval if (token == Opt_space_cache || 80670f6d82eSOmar Sandoval strcmp(args[0].from, "v1") == 0) { 8070b246afaSJeff Mahoney btrfs_clear_opt(info->mount_opt, 80870f6d82eSOmar Sandoval FREE_SPACE_TREE); 8093cdde224SJeff Mahoney btrfs_set_and_info(info, SPACE_CACHE, 81007802534SQu Wenruo "enabling disk space caching"); 81170f6d82eSOmar Sandoval } else if (strcmp(args[0].from, "v2") == 0) { 8120b246afaSJeff Mahoney btrfs_clear_opt(info->mount_opt, 81370f6d82eSOmar Sandoval SPACE_CACHE); 8140b246afaSJeff Mahoney btrfs_set_and_info(info, FREE_SPACE_TREE, 81570f6d82eSOmar Sandoval "enabling free space tree"); 81670f6d82eSOmar Sandoval } else { 81770f6d82eSOmar Sandoval ret = -EINVAL; 81870f6d82eSOmar Sandoval goto out; 81970f6d82eSOmar Sandoval } 8200de90876SJosef Bacik break; 821f420ee1eSStefan Behrens case Opt_rescan_uuid_tree: 822f420ee1eSStefan Behrens btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE); 823f420ee1eSStefan Behrens break; 82473bc1876SJosef Bacik case Opt_no_space_cache: 8253cdde224SJeff Mahoney if (btrfs_test_opt(info, SPACE_CACHE)) { 8260b246afaSJeff Mahoney btrfs_clear_and_info(info, SPACE_CACHE, 82707802534SQu Wenruo "disabling disk space caching"); 82870f6d82eSOmar Sandoval } 8293cdde224SJeff Mahoney if (btrfs_test_opt(info, FREE_SPACE_TREE)) { 8300b246afaSJeff Mahoney btrfs_clear_and_info(info, FREE_SPACE_TREE, 83170f6d82eSOmar Sandoval "disabling free space tree"); 83270f6d82eSOmar Sandoval } 83373bc1876SJosef Bacik break; 8344b9465cbSChris Mason case Opt_inode_cache: 835b547a88eSDavid Sterba btrfs_warn(info, 836b547a88eSDavid Sterba "the 'inode_cache' option is deprecated and will have no effect from 5.11"); 8377e1876acSDavid Sterba btrfs_set_pending_and_info(info, INODE_MAP_CACHE, 83807802534SQu Wenruo "enabling inode map caching"); 8393818aea2SQu Wenruo break; 8403818aea2SQu Wenruo case Opt_noinode_cache: 8417e1876acSDavid Sterba btrfs_clear_pending_and_info(info, INODE_MAP_CACHE, 84207802534SQu Wenruo "disabling inode map caching"); 8434b9465cbSChris Mason break; 84488c2ba3bSJosef Bacik case Opt_clear_cache: 8453cdde224SJeff Mahoney btrfs_set_and_info(info, CLEAR_CACHE, 84607802534SQu Wenruo "force clearing of disk cache"); 8470af3d00bSJosef Bacik break; 8484260f7c7SSage Weil case Opt_user_subvol_rm_allowed: 8494260f7c7SSage Weil btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED); 8504260f7c7SSage Weil break; 85191435650SChris Mason case Opt_enospc_debug: 85291435650SChris Mason btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG); 85391435650SChris Mason break; 85453036293SQu Wenruo case Opt_noenospc_debug: 85553036293SQu Wenruo btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG); 85653036293SQu Wenruo break; 8574cb5300bSChris Mason case Opt_defrag: 8583cdde224SJeff Mahoney btrfs_set_and_info(info, AUTO_DEFRAG, 85907802534SQu Wenruo "enabling auto defrag"); 8604cb5300bSChris Mason break; 861fc0ca9afSQu Wenruo case Opt_nodefrag: 8623cdde224SJeff Mahoney btrfs_clear_and_info(info, AUTO_DEFRAG, 86307802534SQu Wenruo "disabling auto defrag"); 864fc0ca9afSQu Wenruo break; 865af31f5e5SChris Mason case Opt_recovery: 8668dcddfa0SQu Wenruo case Opt_usebackuproot: 86774ef0018SQu Wenruo btrfs_warn(info, 86874ef0018SQu Wenruo "'%s' is deprecated, use 'rescue=usebackuproot' instead", 86974ef0018SQu Wenruo token == Opt_recovery ? "recovery" : 87074ef0018SQu Wenruo "usebackuproot"); 8710b246afaSJeff Mahoney btrfs_info(info, 8728dcddfa0SQu Wenruo "trying to use backup root at mount time"); 8738dcddfa0SQu Wenruo btrfs_set_opt(info->mount_opt, USEBACKUPROOT); 874af31f5e5SChris Mason break; 8759555c6c1SIlya Dryomov case Opt_skip_balance: 8769555c6c1SIlya Dryomov btrfs_set_opt(info->mount_opt, SKIP_BALANCE); 8779555c6c1SIlya Dryomov break; 87821adbd5cSStefan Behrens #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY 87921adbd5cSStefan Behrens case Opt_check_integrity_including_extent_data: 8800b246afaSJeff Mahoney btrfs_info(info, 881efe120a0SFrank Holton "enabling check integrity including extent data"); 88221adbd5cSStefan Behrens btrfs_set_opt(info->mount_opt, 88321adbd5cSStefan Behrens CHECK_INTEGRITY_INCLUDING_EXTENT_DATA); 88421adbd5cSStefan Behrens btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY); 88521adbd5cSStefan Behrens break; 88621adbd5cSStefan Behrens case Opt_check_integrity: 8870b246afaSJeff Mahoney btrfs_info(info, "enabling check integrity"); 88821adbd5cSStefan Behrens btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY); 88921adbd5cSStefan Behrens break; 89021adbd5cSStefan Behrens case Opt_check_integrity_print_mask: 8912c334e87SWang Shilong ret = match_int(&args[0], &intarg); 89202453bdeSAnand Jain if (ret) 8932c334e87SWang Shilong goto out; 89421adbd5cSStefan Behrens info->check_integrity_print_mask = intarg; 89502453bdeSAnand Jain btrfs_info(info, "check_integrity_print_mask 0x%x", 89621adbd5cSStefan Behrens info->check_integrity_print_mask); 89721adbd5cSStefan Behrens break; 89821adbd5cSStefan Behrens #else 89921adbd5cSStefan Behrens case Opt_check_integrity_including_extent_data: 90021adbd5cSStefan Behrens case Opt_check_integrity: 90121adbd5cSStefan Behrens case Opt_check_integrity_print_mask: 9020b246afaSJeff Mahoney btrfs_err(info, 903efe120a0SFrank Holton "support for check_integrity* not compiled in!"); 90421adbd5cSStefan Behrens ret = -EINVAL; 90521adbd5cSStefan Behrens goto out; 90621adbd5cSStefan Behrens #endif 9078c342930SJeff Mahoney case Opt_fatal_errors: 9088c342930SJeff Mahoney if (strcmp(args[0].from, "panic") == 0) 9098c342930SJeff Mahoney btrfs_set_opt(info->mount_opt, 9108c342930SJeff Mahoney PANIC_ON_FATAL_ERROR); 9118c342930SJeff Mahoney else if (strcmp(args[0].from, "bug") == 0) 9128c342930SJeff Mahoney btrfs_clear_opt(info->mount_opt, 9138c342930SJeff Mahoney PANIC_ON_FATAL_ERROR); 9148c342930SJeff Mahoney else { 9158c342930SJeff Mahoney ret = -EINVAL; 9168c342930SJeff Mahoney goto out; 9178c342930SJeff Mahoney } 9188c342930SJeff Mahoney break; 9198b87dc17SDavid Sterba case Opt_commit_interval: 9208b87dc17SDavid Sterba intarg = 0; 9218b87dc17SDavid Sterba ret = match_int(&args[0], &intarg); 922d3740608SAnand Jain if (ret) 9238b87dc17SDavid Sterba goto out; 924d3740608SAnand Jain if (intarg == 0) { 925d3740608SAnand Jain btrfs_info(info, 926d3740608SAnand Jain "using default commit interval %us", 927d3740608SAnand Jain BTRFS_DEFAULT_COMMIT_INTERVAL); 928d3740608SAnand Jain intarg = BTRFS_DEFAULT_COMMIT_INTERVAL; 929d3740608SAnand Jain } else if (intarg > 300) { 930d3740608SAnand Jain btrfs_warn(info, "excessive commit interval %d", 9318b87dc17SDavid Sterba intarg); 9328b87dc17SDavid Sterba } 9338b87dc17SDavid Sterba info->commit_interval = intarg; 9348b87dc17SDavid Sterba break; 93574ef0018SQu Wenruo case Opt_rescue: 93674ef0018SQu Wenruo ret = parse_rescue_options(info, args[0].from); 93774ef0018SQu Wenruo if (ret < 0) 93874ef0018SQu Wenruo goto out; 93974ef0018SQu Wenruo break; 940d0bd4560SJosef Bacik #ifdef CONFIG_BTRFS_DEBUG 941d0bd4560SJosef Bacik case Opt_fragment_all: 9420b246afaSJeff Mahoney btrfs_info(info, "fragmenting all space"); 943d0bd4560SJosef Bacik btrfs_set_opt(info->mount_opt, FRAGMENT_DATA); 944d0bd4560SJosef Bacik btrfs_set_opt(info->mount_opt, FRAGMENT_METADATA); 945d0bd4560SJosef Bacik break; 946d0bd4560SJosef Bacik case Opt_fragment_metadata: 9470b246afaSJeff Mahoney btrfs_info(info, "fragmenting metadata"); 948d0bd4560SJosef Bacik btrfs_set_opt(info->mount_opt, 949d0bd4560SJosef Bacik FRAGMENT_METADATA); 950d0bd4560SJosef Bacik break; 951d0bd4560SJosef Bacik case Opt_fragment_data: 9520b246afaSJeff Mahoney btrfs_info(info, "fragmenting data"); 953d0bd4560SJosef Bacik btrfs_set_opt(info->mount_opt, FRAGMENT_DATA); 954d0bd4560SJosef Bacik break; 955d0bd4560SJosef Bacik #endif 956fb592373SJosef Bacik #ifdef CONFIG_BTRFS_FS_REF_VERIFY 957fb592373SJosef Bacik case Opt_ref_verify: 958fb592373SJosef Bacik btrfs_info(info, "doing ref verification"); 959fb592373SJosef Bacik btrfs_set_opt(info->mount_opt, REF_VERIFY); 960fb592373SJosef Bacik break; 961fb592373SJosef Bacik #endif 962a7a3f7caSSage Weil case Opt_err: 9637e8f19e5SDavid Sterba btrfs_err(info, "unrecognized mount option '%s'", p); 964a7a3f7caSSage Weil ret = -EINVAL; 965a7a3f7caSSage Weil goto out; 96695e05289SChris Mason default: 967be20aa9dSChris Mason break; 96895e05289SChris Mason } 96995e05289SChris Mason } 97096da0919SQu Wenruo check: 97196da0919SQu Wenruo /* 97296da0919SQu Wenruo * Extra check for current option against current flag 97396da0919SQu Wenruo */ 9741751e8a6SLinus Torvalds if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & SB_RDONLY)) { 9750b246afaSJeff Mahoney btrfs_err(info, 97696da0919SQu Wenruo "nologreplay must be used with ro mount option"); 97796da0919SQu Wenruo ret = -EINVAL; 97896da0919SQu Wenruo } 979a7a3f7caSSage Weil out: 9800b246afaSJeff Mahoney if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE) && 9813cdde224SJeff Mahoney !btrfs_test_opt(info, FREE_SPACE_TREE) && 9823cdde224SJeff Mahoney !btrfs_test_opt(info, CLEAR_CACHE)) { 9830b246afaSJeff Mahoney btrfs_err(info, "cannot disable free space tree"); 98470f6d82eSOmar Sandoval ret = -EINVAL; 98570f6d82eSOmar Sandoval 98670f6d82eSOmar Sandoval } 9873cdde224SJeff Mahoney if (!ret && btrfs_test_opt(info, SPACE_CACHE)) 9880b246afaSJeff Mahoney btrfs_info(info, "disk space caching is enabled"); 9893cdde224SJeff Mahoney if (!ret && btrfs_test_opt(info, FREE_SPACE_TREE)) 9900b246afaSJeff Mahoney btrfs_info(info, "using free space tree"); 991a7a3f7caSSage Weil return ret; 992edf24abeSChristoph Hellwig } 993edf24abeSChristoph Hellwig 994edf24abeSChristoph Hellwig /* 995edf24abeSChristoph Hellwig * Parse mount options that are required early in the mount process. 996edf24abeSChristoph Hellwig * 997edf24abeSChristoph Hellwig * All other options will be parsed on much later in the mount process and 998edf24abeSChristoph Hellwig * only when we need to allocate a new super block. 999edf24abeSChristoph Hellwig */ 1000fa59f27cSAnand Jain static int btrfs_parse_device_options(const char *options, fmode_t flags, 1001d64dcbd1SGu Jinxiang void *holder) 1002edf24abeSChristoph Hellwig { 1003edf24abeSChristoph Hellwig substring_t args[MAX_OPT_ARGS]; 100483c8c9bdSJeff Liu char *device_name, *opts, *orig, *p; 100536350e95SGu Jinxiang struct btrfs_device *device = NULL; 1006d7407606SMisono, Tomohiro int error = 0; 1007d7407606SMisono, Tomohiro 10085139cff5SDavid Sterba lockdep_assert_held(&uuid_mutex); 10095139cff5SDavid Sterba 1010d7407606SMisono, Tomohiro if (!options) 1011d7407606SMisono, Tomohiro return 0; 1012d7407606SMisono, Tomohiro 1013d7407606SMisono, Tomohiro /* 1014d7407606SMisono, Tomohiro * strsep changes the string, duplicate it because btrfs_parse_options 1015d7407606SMisono, Tomohiro * gets called later 1016d7407606SMisono, Tomohiro */ 1017d7407606SMisono, Tomohiro opts = kstrdup(options, GFP_KERNEL); 1018d7407606SMisono, Tomohiro if (!opts) 1019d7407606SMisono, Tomohiro return -ENOMEM; 1020d7407606SMisono, Tomohiro orig = opts; 1021d7407606SMisono, Tomohiro 1022d7407606SMisono, Tomohiro while ((p = strsep(&opts, ",")) != NULL) { 1023d7407606SMisono, Tomohiro int token; 1024d7407606SMisono, Tomohiro 1025d7407606SMisono, Tomohiro if (!*p) 1026d7407606SMisono, Tomohiro continue; 1027d7407606SMisono, Tomohiro 1028d7407606SMisono, Tomohiro token = match_token(p, tokens, args); 1029d7407606SMisono, Tomohiro if (token == Opt_device) { 1030d7407606SMisono, Tomohiro device_name = match_strdup(&args[0]); 1031d7407606SMisono, Tomohiro if (!device_name) { 1032d7407606SMisono, Tomohiro error = -ENOMEM; 1033d7407606SMisono, Tomohiro goto out; 1034d7407606SMisono, Tomohiro } 103536350e95SGu Jinxiang device = btrfs_scan_one_device(device_name, flags, 103636350e95SGu Jinxiang holder); 1037d7407606SMisono, Tomohiro kfree(device_name); 103836350e95SGu Jinxiang if (IS_ERR(device)) { 103936350e95SGu Jinxiang error = PTR_ERR(device); 1040d7407606SMisono, Tomohiro goto out; 1041d7407606SMisono, Tomohiro } 1042d7407606SMisono, Tomohiro } 104336350e95SGu Jinxiang } 1044d7407606SMisono, Tomohiro 1045d7407606SMisono, Tomohiro out: 1046d7407606SMisono, Tomohiro kfree(orig); 1047d7407606SMisono, Tomohiro return error; 1048d7407606SMisono, Tomohiro } 1049d7407606SMisono, Tomohiro 1050d7407606SMisono, Tomohiro /* 1051d7407606SMisono, Tomohiro * Parse mount options that are related to subvolume id 1052d7407606SMisono, Tomohiro * 1053d7407606SMisono, Tomohiro * The value is later passed to mount_subvol() 1054d7407606SMisono, Tomohiro */ 105593b9bcdfSGu Jinxiang static int btrfs_parse_subvol_options(const char *options, char **subvol_name, 105693b9bcdfSGu Jinxiang u64 *subvol_objectid) 1057d7407606SMisono, Tomohiro { 1058d7407606SMisono, Tomohiro substring_t args[MAX_OPT_ARGS]; 1059d7407606SMisono, Tomohiro char *opts, *orig, *p; 1060edf24abeSChristoph Hellwig int error = 0; 1061ccb0e7d1SAnand Jain u64 subvolid; 1062edf24abeSChristoph Hellwig 1063edf24abeSChristoph Hellwig if (!options) 1064830c4adbSJosef Bacik return 0; 1065edf24abeSChristoph Hellwig 1066edf24abeSChristoph Hellwig /* 1067d7407606SMisono, Tomohiro * strsep changes the string, duplicate it because 1068fa59f27cSAnand Jain * btrfs_parse_device_options gets called later 1069edf24abeSChristoph Hellwig */ 1070edf24abeSChristoph Hellwig opts = kstrdup(options, GFP_KERNEL); 1071edf24abeSChristoph Hellwig if (!opts) 1072edf24abeSChristoph Hellwig return -ENOMEM; 10733f3d0bc0STero Roponen orig = opts; 1074edf24abeSChristoph Hellwig 1075edf24abeSChristoph Hellwig while ((p = strsep(&opts, ",")) != NULL) { 1076edf24abeSChristoph Hellwig int token; 1077edf24abeSChristoph Hellwig if (!*p) 1078edf24abeSChristoph Hellwig continue; 1079edf24abeSChristoph Hellwig 1080edf24abeSChristoph Hellwig token = match_token(p, tokens, args); 1081edf24abeSChristoph Hellwig switch (token) { 1082edf24abeSChristoph Hellwig case Opt_subvol: 1083a90e8b6fSIlya Dryomov kfree(*subvol_name); 1084edf24abeSChristoph Hellwig *subvol_name = match_strdup(&args[0]); 10852c334e87SWang Shilong if (!*subvol_name) { 10862c334e87SWang Shilong error = -ENOMEM; 10872c334e87SWang Shilong goto out; 10882c334e87SWang Shilong } 1089edf24abeSChristoph Hellwig break; 109073f73415SJosef Bacik case Opt_subvolid: 1091ccb0e7d1SAnand Jain error = match_u64(&args[0], &subvolid); 1092ccb0e7d1SAnand Jain if (error) 10932c334e87SWang Shilong goto out; 1094ccb0e7d1SAnand Jain 1095ccb0e7d1SAnand Jain /* we want the original fs_tree */ 1096ccb0e7d1SAnand Jain if (subvolid == 0) 1097ccb0e7d1SAnand Jain subvolid = BTRFS_FS_TREE_OBJECTID; 1098ccb0e7d1SAnand Jain 1099ccb0e7d1SAnand Jain *subvol_objectid = subvolid; 110073f73415SJosef Bacik break; 1101edf24abeSChristoph Hellwig default: 1102edf24abeSChristoph Hellwig break; 1103edf24abeSChristoph Hellwig } 1104edf24abeSChristoph Hellwig } 1105edf24abeSChristoph Hellwig 1106edf24abeSChristoph Hellwig out: 1107830c4adbSJosef Bacik kfree(orig); 1108edf24abeSChristoph Hellwig return error; 110995e05289SChris Mason } 111095e05289SChris Mason 1111c0c907a4SMarcos Paulo de Souza char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info, 111273f73415SJosef Bacik u64 subvol_objectid) 111373f73415SJosef Bacik { 1114815745cfSAl Viro struct btrfs_root *root = fs_info->tree_root; 11155168489aSJosef Bacik struct btrfs_root *fs_root = NULL; 111605dbe683SOmar Sandoval struct btrfs_root_ref *root_ref; 111705dbe683SOmar Sandoval struct btrfs_inode_ref *inode_ref; 111805dbe683SOmar Sandoval struct btrfs_key key; 111905dbe683SOmar Sandoval struct btrfs_path *path = NULL; 112005dbe683SOmar Sandoval char *name = NULL, *ptr; 112105dbe683SOmar Sandoval u64 dirid; 112205dbe683SOmar Sandoval int len; 112305dbe683SOmar Sandoval int ret; 112405dbe683SOmar Sandoval 112505dbe683SOmar Sandoval path = btrfs_alloc_path(); 112605dbe683SOmar Sandoval if (!path) { 112705dbe683SOmar Sandoval ret = -ENOMEM; 112805dbe683SOmar Sandoval goto err; 112905dbe683SOmar Sandoval } 113005dbe683SOmar Sandoval path->leave_spinning = 1; 113105dbe683SOmar Sandoval 11323ec83621SDavid Sterba name = kmalloc(PATH_MAX, GFP_KERNEL); 113305dbe683SOmar Sandoval if (!name) { 113405dbe683SOmar Sandoval ret = -ENOMEM; 113505dbe683SOmar Sandoval goto err; 113605dbe683SOmar Sandoval } 113705dbe683SOmar Sandoval ptr = name + PATH_MAX - 1; 113805dbe683SOmar Sandoval ptr[0] = '\0'; 113905dbe683SOmar Sandoval 114005dbe683SOmar Sandoval /* 114105dbe683SOmar Sandoval * Walk up the subvolume trees in the tree of tree roots by root 114205dbe683SOmar Sandoval * backrefs until we hit the top-level subvolume. 114305dbe683SOmar Sandoval */ 114405dbe683SOmar Sandoval while (subvol_objectid != BTRFS_FS_TREE_OBJECTID) { 114505dbe683SOmar Sandoval key.objectid = subvol_objectid; 114605dbe683SOmar Sandoval key.type = BTRFS_ROOT_BACKREF_KEY; 114705dbe683SOmar Sandoval key.offset = (u64)-1; 114805dbe683SOmar Sandoval 114905dbe683SOmar Sandoval ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 115005dbe683SOmar Sandoval if (ret < 0) { 115105dbe683SOmar Sandoval goto err; 115205dbe683SOmar Sandoval } else if (ret > 0) { 115305dbe683SOmar Sandoval ret = btrfs_previous_item(root, path, subvol_objectid, 115405dbe683SOmar Sandoval BTRFS_ROOT_BACKREF_KEY); 115505dbe683SOmar Sandoval if (ret < 0) { 115605dbe683SOmar Sandoval goto err; 115705dbe683SOmar Sandoval } else if (ret > 0) { 115805dbe683SOmar Sandoval ret = -ENOENT; 115905dbe683SOmar Sandoval goto err; 116005dbe683SOmar Sandoval } 116105dbe683SOmar Sandoval } 116205dbe683SOmar Sandoval 116305dbe683SOmar Sandoval btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 116405dbe683SOmar Sandoval subvol_objectid = key.offset; 116505dbe683SOmar Sandoval 116605dbe683SOmar Sandoval root_ref = btrfs_item_ptr(path->nodes[0], path->slots[0], 116705dbe683SOmar Sandoval struct btrfs_root_ref); 116805dbe683SOmar Sandoval len = btrfs_root_ref_name_len(path->nodes[0], root_ref); 116905dbe683SOmar Sandoval ptr -= len + 1; 117005dbe683SOmar Sandoval if (ptr < name) { 117105dbe683SOmar Sandoval ret = -ENAMETOOLONG; 117205dbe683SOmar Sandoval goto err; 117305dbe683SOmar Sandoval } 117405dbe683SOmar Sandoval read_extent_buffer(path->nodes[0], ptr + 1, 117505dbe683SOmar Sandoval (unsigned long)(root_ref + 1), len); 117605dbe683SOmar Sandoval ptr[0] = '/'; 117705dbe683SOmar Sandoval dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref); 117805dbe683SOmar Sandoval btrfs_release_path(path); 117905dbe683SOmar Sandoval 118056e9357aSDavid Sterba fs_root = btrfs_get_fs_root(fs_info, subvol_objectid, true); 118105dbe683SOmar Sandoval if (IS_ERR(fs_root)) { 118205dbe683SOmar Sandoval ret = PTR_ERR(fs_root); 11835168489aSJosef Bacik fs_root = NULL; 11845168489aSJosef Bacik goto err; 11855168489aSJosef Bacik } 118605dbe683SOmar Sandoval 118705dbe683SOmar Sandoval /* 118805dbe683SOmar Sandoval * Walk up the filesystem tree by inode refs until we hit the 118905dbe683SOmar Sandoval * root directory. 119005dbe683SOmar Sandoval */ 119105dbe683SOmar Sandoval while (dirid != BTRFS_FIRST_FREE_OBJECTID) { 119205dbe683SOmar Sandoval key.objectid = dirid; 119305dbe683SOmar Sandoval key.type = BTRFS_INODE_REF_KEY; 119405dbe683SOmar Sandoval key.offset = (u64)-1; 119505dbe683SOmar Sandoval 119605dbe683SOmar Sandoval ret = btrfs_search_slot(NULL, fs_root, &key, path, 0, 0); 119705dbe683SOmar Sandoval if (ret < 0) { 119805dbe683SOmar Sandoval goto err; 119905dbe683SOmar Sandoval } else if (ret > 0) { 120005dbe683SOmar Sandoval ret = btrfs_previous_item(fs_root, path, dirid, 120105dbe683SOmar Sandoval BTRFS_INODE_REF_KEY); 120205dbe683SOmar Sandoval if (ret < 0) { 120305dbe683SOmar Sandoval goto err; 120405dbe683SOmar Sandoval } else if (ret > 0) { 120505dbe683SOmar Sandoval ret = -ENOENT; 120605dbe683SOmar Sandoval goto err; 120705dbe683SOmar Sandoval } 120805dbe683SOmar Sandoval } 120905dbe683SOmar Sandoval 121005dbe683SOmar Sandoval btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 121105dbe683SOmar Sandoval dirid = key.offset; 121205dbe683SOmar Sandoval 121305dbe683SOmar Sandoval inode_ref = btrfs_item_ptr(path->nodes[0], 121405dbe683SOmar Sandoval path->slots[0], 121505dbe683SOmar Sandoval struct btrfs_inode_ref); 121605dbe683SOmar Sandoval len = btrfs_inode_ref_name_len(path->nodes[0], 121705dbe683SOmar Sandoval inode_ref); 121805dbe683SOmar Sandoval ptr -= len + 1; 121905dbe683SOmar Sandoval if (ptr < name) { 122005dbe683SOmar Sandoval ret = -ENAMETOOLONG; 122105dbe683SOmar Sandoval goto err; 122205dbe683SOmar Sandoval } 122305dbe683SOmar Sandoval read_extent_buffer(path->nodes[0], ptr + 1, 122405dbe683SOmar Sandoval (unsigned long)(inode_ref + 1), len); 122505dbe683SOmar Sandoval ptr[0] = '/'; 122605dbe683SOmar Sandoval btrfs_release_path(path); 122705dbe683SOmar Sandoval } 122800246528SJosef Bacik btrfs_put_root(fs_root); 12295168489aSJosef Bacik fs_root = NULL; 123005dbe683SOmar Sandoval } 123105dbe683SOmar Sandoval 123205dbe683SOmar Sandoval btrfs_free_path(path); 123305dbe683SOmar Sandoval if (ptr == name + PATH_MAX - 1) { 123405dbe683SOmar Sandoval name[0] = '/'; 123505dbe683SOmar Sandoval name[1] = '\0'; 123605dbe683SOmar Sandoval } else { 123705dbe683SOmar Sandoval memmove(name, ptr, name + PATH_MAX - ptr); 123805dbe683SOmar Sandoval } 123905dbe683SOmar Sandoval return name; 124005dbe683SOmar Sandoval 124105dbe683SOmar Sandoval err: 124200246528SJosef Bacik btrfs_put_root(fs_root); 124305dbe683SOmar Sandoval btrfs_free_path(path); 124405dbe683SOmar Sandoval kfree(name); 124505dbe683SOmar Sandoval return ERR_PTR(ret); 124605dbe683SOmar Sandoval } 124705dbe683SOmar Sandoval 124805dbe683SOmar Sandoval static int get_default_subvol_objectid(struct btrfs_fs_info *fs_info, u64 *objectid) 124905dbe683SOmar Sandoval { 125005dbe683SOmar Sandoval struct btrfs_root *root = fs_info->tree_root; 125173f73415SJosef Bacik struct btrfs_dir_item *di; 125273f73415SJosef Bacik struct btrfs_path *path; 125373f73415SJosef Bacik struct btrfs_key location; 125473f73415SJosef Bacik u64 dir_id; 125573f73415SJosef Bacik 125673f73415SJosef Bacik path = btrfs_alloc_path(); 125773f73415SJosef Bacik if (!path) 125805dbe683SOmar Sandoval return -ENOMEM; 125973f73415SJosef Bacik path->leave_spinning = 1; 126073f73415SJosef Bacik 126173f73415SJosef Bacik /* 126273f73415SJosef Bacik * Find the "default" dir item which points to the root item that we 126373f73415SJosef Bacik * will mount by default if we haven't been given a specific subvolume 126473f73415SJosef Bacik * to mount. 126573f73415SJosef Bacik */ 1266815745cfSAl Viro dir_id = btrfs_super_root_dir(fs_info->super_copy); 126773f73415SJosef Bacik di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0); 1268b0839166SJulia Lawall if (IS_ERR(di)) { 1269b0839166SJulia Lawall btrfs_free_path(path); 127005dbe683SOmar Sandoval return PTR_ERR(di); 1271b0839166SJulia Lawall } 127273f73415SJosef Bacik if (!di) { 127373f73415SJosef Bacik /* 127473f73415SJosef Bacik * Ok the default dir item isn't there. This is weird since 127573f73415SJosef Bacik * it's always been there, but don't freak out, just try and 127605dbe683SOmar Sandoval * mount the top-level subvolume. 127773f73415SJosef Bacik */ 127873f73415SJosef Bacik btrfs_free_path(path); 127905dbe683SOmar Sandoval *objectid = BTRFS_FS_TREE_OBJECTID; 128005dbe683SOmar Sandoval return 0; 128173f73415SJosef Bacik } 128273f73415SJosef Bacik 128373f73415SJosef Bacik btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location); 128473f73415SJosef Bacik btrfs_free_path(path); 128505dbe683SOmar Sandoval *objectid = location.objectid; 128605dbe683SOmar Sandoval return 0; 128773f73415SJosef Bacik } 128873f73415SJosef Bacik 12898a4b83ccSChris Mason static int btrfs_fill_super(struct super_block *sb, 12908a4b83ccSChris Mason struct btrfs_fs_devices *fs_devices, 129156e033a7SDavid Sterba void *data) 12922e635a27SChris Mason { 12932e635a27SChris Mason struct inode *inode; 1294815745cfSAl Viro struct btrfs_fs_info *fs_info = btrfs_sb(sb); 129539279cc3SChris Mason int err; 12962e635a27SChris Mason 12972e635a27SChris Mason sb->s_maxbytes = MAX_LFS_FILESIZE; 12982e635a27SChris Mason sb->s_magic = BTRFS_SUPER_MAGIC; 1299e20d96d6SChris Mason sb->s_op = &btrfs_super_ops; 1300af53d29aSAl Viro sb->s_d_op = &btrfs_dentry_operations; 1301be6e8dc0SBalaji Rao sb->s_export_op = &btrfs_export_ops; 13025103e947SJosef Bacik sb->s_xattr = btrfs_xattr_handlers; 13032e635a27SChris Mason sb->s_time_gran = 1; 13040eda294dSChris Mason #ifdef CONFIG_BTRFS_FS_POSIX_ACL 13051751e8a6SLinus Torvalds sb->s_flags |= SB_POSIXACL; 130649cf6f45SChris Ball #endif 1307357fdad0SMatthew Garrett sb->s_flags |= SB_I_VERSION; 1308da2f0f74SChris Mason sb->s_iflags |= SB_I_CGROUPWB; 13099e11ceeeSJan Kara 13109e11ceeeSJan Kara err = super_setup_bdi(sb); 13119e11ceeeSJan Kara if (err) { 13129e11ceeeSJan Kara btrfs_err(fs_info, "super_setup_bdi failed"); 13139e11ceeeSJan Kara return err; 13149e11ceeeSJan Kara } 13159e11ceeeSJan Kara 1316ad2b2c80SAl Viro err = open_ctree(sb, fs_devices, (char *)data); 1317ad2b2c80SAl Viro if (err) { 1318ab8d0fc4SJeff Mahoney btrfs_err(fs_info, "open_ctree failed"); 1319ad2b2c80SAl Viro return err; 1320e20d96d6SChris Mason } 1321b888db2bSChris Mason 13220202e83fSDavid Sterba inode = btrfs_iget(sb, BTRFS_FIRST_FREE_OBJECTID, fs_info->fs_root); 13235d4f98a2SYan Zheng if (IS_ERR(inode)) { 13245d4f98a2SYan Zheng err = PTR_ERR(inode); 132539279cc3SChris Mason goto fail_close; 132639279cc3SChris Mason } 13272e635a27SChris Mason 132848fde701SAl Viro sb->s_root = d_make_root(inode); 132948fde701SAl Viro if (!sb->s_root) { 133039279cc3SChris Mason err = -ENOMEM; 133139279cc3SChris Mason goto fail_close; 13322e635a27SChris Mason } 133358176a96SJosef Bacik 133490a887c9SDan Magenheimer cleancache_init_fs(sb); 13351751e8a6SLinus Torvalds sb->s_flags |= SB_ACTIVE; 13362e635a27SChris Mason return 0; 13372e635a27SChris Mason 133839279cc3SChris Mason fail_close: 13396bccf3abSJeff Mahoney close_ctree(fs_info); 1340d5719762SChris Mason return err; 1341d5719762SChris Mason } 1342d5719762SChris Mason 13436bf13c0cSSage Weil int btrfs_sync_fs(struct super_block *sb, int wait) 1344d5719762SChris Mason { 1345d5719762SChris Mason struct btrfs_trans_handle *trans; 1346815745cfSAl Viro struct btrfs_fs_info *fs_info = btrfs_sb(sb); 1347815745cfSAl Viro struct btrfs_root *root = fs_info->tree_root; 1348df2ce34cSChris Mason 1349bc074524SJeff Mahoney trace_btrfs_sync_fs(fs_info, wait); 13501abe9b8aSliubo 1351d561c025SChris Mason if (!wait) { 1352815745cfSAl Viro filemap_flush(fs_info->btree_inode->i_mapping); 1353df2ce34cSChris Mason return 0; 1354d561c025SChris Mason } 1355771ed689SChris Mason 13566374e57aSChris Mason btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1); 1357771ed689SChris Mason 1358d4edf39bSMiao Xie trans = btrfs_attach_transaction_barrier(root); 135960376ce4SJosef Bacik if (IS_ERR(trans)) { 1360354aa0fbSMiao Xie /* no transaction, don't bother */ 13616b5fe46dSDavid Sterba if (PTR_ERR(trans) == -ENOENT) { 13626b5fe46dSDavid Sterba /* 13636b5fe46dSDavid Sterba * Exit unless we have some pending changes 13646b5fe46dSDavid Sterba * that need to go through commit 13656b5fe46dSDavid Sterba */ 13666b5fe46dSDavid Sterba if (fs_info->pending_changes == 0) 1367bd7de2c9SJosef Bacik return 0; 1368a53f4f8eSQu Wenruo /* 1369a53f4f8eSQu Wenruo * A non-blocking test if the fs is frozen. We must not 1370a53f4f8eSQu Wenruo * start a new transaction here otherwise a deadlock 1371a53f4f8eSQu Wenruo * happens. The pending operations are delayed to the 1372a53f4f8eSQu Wenruo * next commit after thawing. 1373a53f4f8eSQu Wenruo */ 1374a7e3c5f2SRakesh Pandit if (sb_start_write_trylock(sb)) 1375a7e3c5f2SRakesh Pandit sb_end_write(sb); 1376a53f4f8eSQu Wenruo else 1377a53f4f8eSQu Wenruo return 0; 13786b5fe46dSDavid Sterba trans = btrfs_start_transaction(root, 0); 137960376ce4SJosef Bacik } 138098bd5c54SDavid Sterba if (IS_ERR(trans)) 138198bd5c54SDavid Sterba return PTR_ERR(trans); 13826b5fe46dSDavid Sterba } 13833a45bb20SJeff Mahoney return btrfs_commit_transaction(trans); 1384d5719762SChris Mason } 1385d5719762SChris Mason 138634c80b1dSAl Viro static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry) 1387a9572a15SEric Paris { 1388815745cfSAl Viro struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb); 13890f628c63SDavid Sterba const char *compress_type; 13903ef3959bSJosef Bacik const char *subvol_name; 1391a9572a15SEric Paris 13923cdde224SJeff Mahoney if (btrfs_test_opt(info, DEGRADED)) 1393a9572a15SEric Paris seq_puts(seq, ",degraded"); 13943cdde224SJeff Mahoney if (btrfs_test_opt(info, NODATASUM)) 1395a9572a15SEric Paris seq_puts(seq, ",nodatasum"); 13963cdde224SJeff Mahoney if (btrfs_test_opt(info, NODATACOW)) 1397a9572a15SEric Paris seq_puts(seq, ",nodatacow"); 13983cdde224SJeff Mahoney if (btrfs_test_opt(info, NOBARRIER)) 1399a9572a15SEric Paris seq_puts(seq, ",nobarrier"); 140095ac567aSFilipe David Borba Manana if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE) 1401c1c9ff7cSGeert Uytterhoeven seq_printf(seq, ",max_inline=%llu", info->max_inline); 1402a9572a15SEric Paris if (info->thread_pool_size != min_t(unsigned long, 1403a9572a15SEric Paris num_online_cpus() + 2, 8)) 1404f7b885beSAnand Jain seq_printf(seq, ",thread_pool=%u", info->thread_pool_size); 14053cdde224SJeff Mahoney if (btrfs_test_opt(info, COMPRESS)) { 14060f628c63SDavid Sterba compress_type = btrfs_compress_type2str(info->compress_type); 14073cdde224SJeff Mahoney if (btrfs_test_opt(info, FORCE_COMPRESS)) 1408200da64eSTsutomu Itoh seq_printf(seq, ",compress-force=%s", compress_type); 1409200da64eSTsutomu Itoh else 1410200da64eSTsutomu Itoh seq_printf(seq, ",compress=%s", compress_type); 1411f51d2b59SDavid Sterba if (info->compress_level) 1412fa4d885aSAdam Borowski seq_printf(seq, ":%d", info->compress_level); 1413200da64eSTsutomu Itoh } 14143cdde224SJeff Mahoney if (btrfs_test_opt(info, NOSSD)) 1415c289811cSChris Mason seq_puts(seq, ",nossd"); 14163cdde224SJeff Mahoney if (btrfs_test_opt(info, SSD_SPREAD)) 1417451d7585SChris Mason seq_puts(seq, ",ssd_spread"); 14183cdde224SJeff Mahoney else if (btrfs_test_opt(info, SSD)) 1419a9572a15SEric Paris seq_puts(seq, ",ssd"); 14203cdde224SJeff Mahoney if (btrfs_test_opt(info, NOTREELOG)) 14216b65c5c6SSage Weil seq_puts(seq, ",notreelog"); 14223cdde224SJeff Mahoney if (btrfs_test_opt(info, NOLOGREPLAY)) 142374ef0018SQu Wenruo seq_puts(seq, ",rescue=nologreplay"); 14243cdde224SJeff Mahoney if (btrfs_test_opt(info, FLUSHONCOMMIT)) 14256b65c5c6SSage Weil seq_puts(seq, ",flushoncommit"); 142646b27f50SDennis Zhou if (btrfs_test_opt(info, DISCARD_SYNC)) 142720a5239aSMatthew Wilcox seq_puts(seq, ",discard"); 1428b0643e59SDennis Zhou if (btrfs_test_opt(info, DISCARD_ASYNC)) 1429b0643e59SDennis Zhou seq_puts(seq, ",discard=async"); 14301751e8a6SLinus Torvalds if (!(info->sb->s_flags & SB_POSIXACL)) 1431a9572a15SEric Paris seq_puts(seq, ",noacl"); 14323cdde224SJeff Mahoney if (btrfs_test_opt(info, SPACE_CACHE)) 1433200da64eSTsutomu Itoh seq_puts(seq, ",space_cache"); 14343cdde224SJeff Mahoney else if (btrfs_test_opt(info, FREE_SPACE_TREE)) 143570f6d82eSOmar Sandoval seq_puts(seq, ",space_cache=v2"); 143673bc1876SJosef Bacik else 14378965593eSDavid Sterba seq_puts(seq, ",nospace_cache"); 14383cdde224SJeff Mahoney if (btrfs_test_opt(info, RESCAN_UUID_TREE)) 1439f420ee1eSStefan Behrens seq_puts(seq, ",rescan_uuid_tree"); 14403cdde224SJeff Mahoney if (btrfs_test_opt(info, CLEAR_CACHE)) 1441200da64eSTsutomu Itoh seq_puts(seq, ",clear_cache"); 14423cdde224SJeff Mahoney if (btrfs_test_opt(info, USER_SUBVOL_RM_ALLOWED)) 1443200da64eSTsutomu Itoh seq_puts(seq, ",user_subvol_rm_allowed"); 14443cdde224SJeff Mahoney if (btrfs_test_opt(info, ENOSPC_DEBUG)) 14450942caa3SDavid Sterba seq_puts(seq, ",enospc_debug"); 14463cdde224SJeff Mahoney if (btrfs_test_opt(info, AUTO_DEFRAG)) 14470942caa3SDavid Sterba seq_puts(seq, ",autodefrag"); 14483cdde224SJeff Mahoney if (btrfs_test_opt(info, INODE_MAP_CACHE)) 14490942caa3SDavid Sterba seq_puts(seq, ",inode_cache"); 14503cdde224SJeff Mahoney if (btrfs_test_opt(info, SKIP_BALANCE)) 14519555c6c1SIlya Dryomov seq_puts(seq, ",skip_balance"); 14528507d216SWang Shilong #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY 14533cdde224SJeff Mahoney if (btrfs_test_opt(info, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA)) 14548507d216SWang Shilong seq_puts(seq, ",check_int_data"); 14553cdde224SJeff Mahoney else if (btrfs_test_opt(info, CHECK_INTEGRITY)) 14568507d216SWang Shilong seq_puts(seq, ",check_int"); 14578507d216SWang Shilong if (info->check_integrity_print_mask) 14588507d216SWang Shilong seq_printf(seq, ",check_int_print_mask=%d", 14598507d216SWang Shilong info->check_integrity_print_mask); 14608507d216SWang Shilong #endif 14618507d216SWang Shilong if (info->metadata_ratio) 1462764cb8b4SAnand Jain seq_printf(seq, ",metadata_ratio=%u", info->metadata_ratio); 14633cdde224SJeff Mahoney if (btrfs_test_opt(info, PANIC_ON_FATAL_ERROR)) 14648c342930SJeff Mahoney seq_puts(seq, ",fatal_errors=panic"); 14658b87dc17SDavid Sterba if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL) 1466d3740608SAnand Jain seq_printf(seq, ",commit=%u", info->commit_interval); 1467d0bd4560SJosef Bacik #ifdef CONFIG_BTRFS_DEBUG 14683cdde224SJeff Mahoney if (btrfs_test_opt(info, FRAGMENT_DATA)) 1469d0bd4560SJosef Bacik seq_puts(seq, ",fragment=data"); 14703cdde224SJeff Mahoney if (btrfs_test_opt(info, FRAGMENT_METADATA)) 1471d0bd4560SJosef Bacik seq_puts(seq, ",fragment=metadata"); 1472d0bd4560SJosef Bacik #endif 1473fb592373SJosef Bacik if (btrfs_test_opt(info, REF_VERIFY)) 1474fb592373SJosef Bacik seq_puts(seq, ",ref_verify"); 1475c8d3fe02SOmar Sandoval seq_printf(seq, ",subvolid=%llu", 1476c8d3fe02SOmar Sandoval BTRFS_I(d_inode(dentry))->root->root_key.objectid); 14773ef3959bSJosef Bacik subvol_name = btrfs_get_subvol_name_from_objectid(info, 14783ef3959bSJosef Bacik BTRFS_I(d_inode(dentry))->root->root_key.objectid); 14793ef3959bSJosef Bacik if (!IS_ERR(subvol_name)) { 1480c8d3fe02SOmar Sandoval seq_puts(seq, ",subvol="); 14813ef3959bSJosef Bacik seq_escape(seq, subvol_name, " \t\n\\"); 14823ef3959bSJosef Bacik kfree(subvol_name); 14833ef3959bSJosef Bacik } 1484a9572a15SEric Paris return 0; 1485a9572a15SEric Paris } 1486a9572a15SEric Paris 1487a061fc8dSChris Mason static int btrfs_test_super(struct super_block *s, void *data) 14882e635a27SChris Mason { 1489815745cfSAl Viro struct btrfs_fs_info *p = data; 1490815745cfSAl Viro struct btrfs_fs_info *fs_info = btrfs_sb(s); 14914b82d6e4SYan 1492815745cfSAl Viro return fs_info->fs_devices == p->fs_devices; 14934b82d6e4SYan } 14944b82d6e4SYan 1495450ba0eaSJosef Bacik static int btrfs_set_super(struct super_block *s, void *data) 1496450ba0eaSJosef Bacik { 14976de1d09dSAl Viro int err = set_anon_super(s, data); 14986de1d09dSAl Viro if (!err) 1499450ba0eaSJosef Bacik s->s_fs_info = data; 15006de1d09dSAl Viro return err; 1501450ba0eaSJosef Bacik } 1502450ba0eaSJosef Bacik 1503830c4adbSJosef Bacik /* 1504f9d9ef62SDavid Sterba * subvolumes are identified by ino 256 1505f9d9ef62SDavid Sterba */ 1506f9d9ef62SDavid Sterba static inline int is_subvolume_inode(struct inode *inode) 1507f9d9ef62SDavid Sterba { 1508f9d9ef62SDavid Sterba if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID) 1509f9d9ef62SDavid Sterba return 1; 1510f9d9ef62SDavid Sterba return 0; 1511f9d9ef62SDavid Sterba } 1512f9d9ef62SDavid Sterba 1513bb289b7bSOmar Sandoval static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid, 1514ae0bc863SAnand Jain struct vfsmount *mnt) 1515830c4adbSJosef Bacik { 1516830c4adbSJosef Bacik struct dentry *root; 1517fa330659SOmar Sandoval int ret; 1518830c4adbSJosef Bacik 151905dbe683SOmar Sandoval if (!subvol_name) { 152005dbe683SOmar Sandoval if (!subvol_objectid) { 152105dbe683SOmar Sandoval ret = get_default_subvol_objectid(btrfs_sb(mnt->mnt_sb), 152205dbe683SOmar Sandoval &subvol_objectid); 152305dbe683SOmar Sandoval if (ret) { 152405dbe683SOmar Sandoval root = ERR_PTR(ret); 152505dbe683SOmar Sandoval goto out; 152605dbe683SOmar Sandoval } 152705dbe683SOmar Sandoval } 1528c0c907a4SMarcos Paulo de Souza subvol_name = btrfs_get_subvol_name_from_objectid( 1529c0c907a4SMarcos Paulo de Souza btrfs_sb(mnt->mnt_sb), subvol_objectid); 153005dbe683SOmar Sandoval if (IS_ERR(subvol_name)) { 153105dbe683SOmar Sandoval root = ERR_CAST(subvol_name); 153205dbe683SOmar Sandoval subvol_name = NULL; 153305dbe683SOmar Sandoval goto out; 153405dbe683SOmar Sandoval } 153505dbe683SOmar Sandoval 153605dbe683SOmar Sandoval } 153705dbe683SOmar Sandoval 1538ea441d11SAl Viro root = mount_subtree(mnt, subvol_name); 1539fa330659SOmar Sandoval /* mount_subtree() drops our reference on the vfsmount. */ 1540fa330659SOmar Sandoval mnt = NULL; 1541830c4adbSJosef Bacik 1542bb289b7bSOmar Sandoval if (!IS_ERR(root)) { 1543ea441d11SAl Viro struct super_block *s = root->d_sb; 1544ab8d0fc4SJeff Mahoney struct btrfs_fs_info *fs_info = btrfs_sb(s); 1545bb289b7bSOmar Sandoval struct inode *root_inode = d_inode(root); 1546bb289b7bSOmar Sandoval u64 root_objectid = BTRFS_I(root_inode)->root->root_key.objectid; 1547bb289b7bSOmar Sandoval 1548bb289b7bSOmar Sandoval ret = 0; 1549bb289b7bSOmar Sandoval if (!is_subvolume_inode(root_inode)) { 1550ab8d0fc4SJeff Mahoney btrfs_err(fs_info, "'%s' is not a valid subvolume", 1551bb289b7bSOmar Sandoval subvol_name); 1552bb289b7bSOmar Sandoval ret = -EINVAL; 1553bb289b7bSOmar Sandoval } 1554bb289b7bSOmar Sandoval if (subvol_objectid && root_objectid != subvol_objectid) { 155505dbe683SOmar Sandoval /* 155605dbe683SOmar Sandoval * This will also catch a race condition where a 155705dbe683SOmar Sandoval * subvolume which was passed by ID is renamed and 155805dbe683SOmar Sandoval * another subvolume is renamed over the old location. 155905dbe683SOmar Sandoval */ 1560ab8d0fc4SJeff Mahoney btrfs_err(fs_info, 1561ab8d0fc4SJeff Mahoney "subvol '%s' does not match subvolid %llu", 1562bb289b7bSOmar Sandoval subvol_name, subvol_objectid); 1563bb289b7bSOmar Sandoval ret = -EINVAL; 1564bb289b7bSOmar Sandoval } 1565bb289b7bSOmar Sandoval if (ret) { 1566ea441d11SAl Viro dput(root); 1567bb289b7bSOmar Sandoval root = ERR_PTR(ret); 1568ea441d11SAl Viro deactivate_locked_super(s); 1569bb289b7bSOmar Sandoval } 1570f9d9ef62SDavid Sterba } 1571f9d9ef62SDavid Sterba 1572fa330659SOmar Sandoval out: 1573fa330659SOmar Sandoval mntput(mnt); 1574fa330659SOmar Sandoval kfree(subvol_name); 1575830c4adbSJosef Bacik return root; 1576830c4adbSJosef Bacik } 1577450ba0eaSJosef Bacik 1578312c89fbSMisono, Tomohiro /* 1579312c89fbSMisono, Tomohiro * Find a superblock for the given device / mount point. 1580312c89fbSMisono, Tomohiro * 1581312c89fbSMisono, Tomohiro * Note: This is based on mount_bdev from fs/super.c with a few additions 1582312c89fbSMisono, Tomohiro * for multiple device setup. Make sure to keep it in sync. 1583312c89fbSMisono, Tomohiro */ 158472fa39f5SMisono, Tomohiro static struct dentry *btrfs_mount_root(struct file_system_type *fs_type, 158572fa39f5SMisono, Tomohiro int flags, const char *device_name, void *data) 158672fa39f5SMisono, Tomohiro { 158772fa39f5SMisono, Tomohiro struct block_device *bdev = NULL; 158872fa39f5SMisono, Tomohiro struct super_block *s; 158936350e95SGu Jinxiang struct btrfs_device *device = NULL; 159072fa39f5SMisono, Tomohiro struct btrfs_fs_devices *fs_devices = NULL; 159172fa39f5SMisono, Tomohiro struct btrfs_fs_info *fs_info = NULL; 1592204cc0ccSAl Viro void *new_sec_opts = NULL; 159372fa39f5SMisono, Tomohiro fmode_t mode = FMODE_READ; 159472fa39f5SMisono, Tomohiro int error = 0; 159572fa39f5SMisono, Tomohiro 159672fa39f5SMisono, Tomohiro if (!(flags & SB_RDONLY)) 159772fa39f5SMisono, Tomohiro mode |= FMODE_WRITE; 159872fa39f5SMisono, Tomohiro 159972fa39f5SMisono, Tomohiro if (data) { 1600a65001e8SAl Viro error = security_sb_eat_lsm_opts(data, &new_sec_opts); 160172fa39f5SMisono, Tomohiro if (error) 160272fa39f5SMisono, Tomohiro return ERR_PTR(error); 160372fa39f5SMisono, Tomohiro } 160472fa39f5SMisono, Tomohiro 160572fa39f5SMisono, Tomohiro /* 160672fa39f5SMisono, Tomohiro * Setup a dummy root and fs_info for test/set super. This is because 160772fa39f5SMisono, Tomohiro * we don't actually fill this stuff out until open_ctree, but we need 16088260edbaSJosef Bacik * then open_ctree will properly initialize the file system specific 16098260edbaSJosef Bacik * settings later. btrfs_init_fs_info initializes the static elements 16108260edbaSJosef Bacik * of the fs_info (locks and such) to make cleanup easier if we find a 16118260edbaSJosef Bacik * superblock with our given fs_devices later on at sget() time. 161272fa39f5SMisono, Tomohiro */ 1613a8fd1f71SJeff Mahoney fs_info = kvzalloc(sizeof(struct btrfs_fs_info), GFP_KERNEL); 161472fa39f5SMisono, Tomohiro if (!fs_info) { 161572fa39f5SMisono, Tomohiro error = -ENOMEM; 161672fa39f5SMisono, Tomohiro goto error_sec_opts; 161772fa39f5SMisono, Tomohiro } 16188260edbaSJosef Bacik btrfs_init_fs_info(fs_info); 161972fa39f5SMisono, Tomohiro 162072fa39f5SMisono, Tomohiro fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL); 162172fa39f5SMisono, Tomohiro fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL); 162272fa39f5SMisono, Tomohiro if (!fs_info->super_copy || !fs_info->super_for_commit) { 162372fa39f5SMisono, Tomohiro error = -ENOMEM; 162472fa39f5SMisono, Tomohiro goto error_fs_info; 162572fa39f5SMisono, Tomohiro } 162672fa39f5SMisono, Tomohiro 1627f5194e34SDavid Sterba mutex_lock(&uuid_mutex); 1628fa59f27cSAnand Jain error = btrfs_parse_device_options(data, mode, fs_type); 162981ffd56bSDavid Sterba if (error) { 1630399f7f4cSDavid Sterba mutex_unlock(&uuid_mutex); 1631399f7f4cSDavid Sterba goto error_fs_info; 163281ffd56bSDavid Sterba } 1633399f7f4cSDavid Sterba 163436350e95SGu Jinxiang device = btrfs_scan_one_device(device_name, mode, fs_type); 163536350e95SGu Jinxiang if (IS_ERR(device)) { 1636399f7f4cSDavid Sterba mutex_unlock(&uuid_mutex); 163736350e95SGu Jinxiang error = PTR_ERR(device); 1638399f7f4cSDavid Sterba goto error_fs_info; 163981ffd56bSDavid Sterba } 1640399f7f4cSDavid Sterba 164136350e95SGu Jinxiang fs_devices = device->fs_devices; 1642399f7f4cSDavid Sterba fs_info->fs_devices = fs_devices; 1643399f7f4cSDavid Sterba 164472fa39f5SMisono, Tomohiro error = btrfs_open_devices(fs_devices, mode, fs_type); 1645f5194e34SDavid Sterba mutex_unlock(&uuid_mutex); 164672fa39f5SMisono, Tomohiro if (error) 164772fa39f5SMisono, Tomohiro goto error_fs_info; 164872fa39f5SMisono, Tomohiro 164972fa39f5SMisono, Tomohiro if (!(flags & SB_RDONLY) && fs_devices->rw_devices == 0) { 165072fa39f5SMisono, Tomohiro error = -EACCES; 165172fa39f5SMisono, Tomohiro goto error_close_devices; 165272fa39f5SMisono, Tomohiro } 165372fa39f5SMisono, Tomohiro 165472fa39f5SMisono, Tomohiro bdev = fs_devices->latest_bdev; 165572fa39f5SMisono, Tomohiro s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | SB_NOSEC, 165672fa39f5SMisono, Tomohiro fs_info); 165772fa39f5SMisono, Tomohiro if (IS_ERR(s)) { 165872fa39f5SMisono, Tomohiro error = PTR_ERR(s); 165972fa39f5SMisono, Tomohiro goto error_close_devices; 166072fa39f5SMisono, Tomohiro } 166172fa39f5SMisono, Tomohiro 166272fa39f5SMisono, Tomohiro if (s->s_root) { 166372fa39f5SMisono, Tomohiro btrfs_close_devices(fs_devices); 16640d4b0463SJosef Bacik btrfs_free_fs_info(fs_info); 166572fa39f5SMisono, Tomohiro if ((flags ^ s->s_flags) & SB_RDONLY) 166672fa39f5SMisono, Tomohiro error = -EBUSY; 166772fa39f5SMisono, Tomohiro } else { 166872fa39f5SMisono, Tomohiro snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev); 166972fa39f5SMisono, Tomohiro btrfs_sb(s)->bdev_holder = fs_type; 16709b4e675aSDavid Sterba if (!strstr(crc32c_impl(), "generic")) 16719b4e675aSDavid Sterba set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags); 167272fa39f5SMisono, Tomohiro error = btrfs_fill_super(s, fs_devices, data); 167372fa39f5SMisono, Tomohiro } 1674a65001e8SAl Viro if (!error) 1675204cc0ccSAl Viro error = security_sb_set_mnt_opts(s, new_sec_opts, 0, NULL); 1676a65001e8SAl Viro security_free_mnt_opts(&new_sec_opts); 167772fa39f5SMisono, Tomohiro if (error) { 167872fa39f5SMisono, Tomohiro deactivate_locked_super(s); 1679a65001e8SAl Viro return ERR_PTR(error); 168072fa39f5SMisono, Tomohiro } 168172fa39f5SMisono, Tomohiro 168272fa39f5SMisono, Tomohiro return dget(s->s_root); 168372fa39f5SMisono, Tomohiro 168472fa39f5SMisono, Tomohiro error_close_devices: 168572fa39f5SMisono, Tomohiro btrfs_close_devices(fs_devices); 168672fa39f5SMisono, Tomohiro error_fs_info: 16870d4b0463SJosef Bacik btrfs_free_fs_info(fs_info); 168872fa39f5SMisono, Tomohiro error_sec_opts: 168972fa39f5SMisono, Tomohiro security_free_mnt_opts(&new_sec_opts); 169072fa39f5SMisono, Tomohiro return ERR_PTR(error); 169172fa39f5SMisono, Tomohiro } 1692312c89fbSMisono, Tomohiro 1693edf24abeSChristoph Hellwig /* 1694312c89fbSMisono, Tomohiro * Mount function which is called by VFS layer. 1695edf24abeSChristoph Hellwig * 1696312c89fbSMisono, Tomohiro * In order to allow mounting a subvolume directly, btrfs uses mount_subtree() 1697312c89fbSMisono, Tomohiro * which needs vfsmount* of device's root (/). This means device's root has to 1698312c89fbSMisono, Tomohiro * be mounted internally in any case. 1699312c89fbSMisono, Tomohiro * 1700312c89fbSMisono, Tomohiro * Operation flow: 1701312c89fbSMisono, Tomohiro * 1. Parse subvol id related options for later use in mount_subvol(). 1702312c89fbSMisono, Tomohiro * 1703312c89fbSMisono, Tomohiro * 2. Mount device's root (/) by calling vfs_kern_mount(). 1704312c89fbSMisono, Tomohiro * 1705312c89fbSMisono, Tomohiro * NOTE: vfs_kern_mount() is used by VFS to call btrfs_mount() in the 1706312c89fbSMisono, Tomohiro * first place. In order to avoid calling btrfs_mount() again, we use 1707312c89fbSMisono, Tomohiro * different file_system_type which is not registered to VFS by 1708312c89fbSMisono, Tomohiro * register_filesystem() (btrfs_root_fs_type). As a result, 1709312c89fbSMisono, Tomohiro * btrfs_mount_root() is called. The return value will be used by 1710312c89fbSMisono, Tomohiro * mount_subtree() in mount_subvol(). 1711312c89fbSMisono, Tomohiro * 1712312c89fbSMisono, Tomohiro * 3. Call mount_subvol() to get the dentry of subvolume. Since there is 1713312c89fbSMisono, Tomohiro * "btrfs subvolume set-default", mount_subvol() is called always. 1714edf24abeSChristoph Hellwig */ 1715061dbc6bSAl Viro static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, 1716306e16ceSDavid Sterba const char *device_name, void *data) 17174b82d6e4SYan { 1718312c89fbSMisono, Tomohiro struct vfsmount *mnt_root; 1719312c89fbSMisono, Tomohiro struct dentry *root; 172073f73415SJosef Bacik char *subvol_name = NULL; 172173f73415SJosef Bacik u64 subvol_objectid = 0; 17224b82d6e4SYan int error = 0; 17234b82d6e4SYan 172493b9bcdfSGu Jinxiang error = btrfs_parse_subvol_options(data, &subvol_name, 172593b9bcdfSGu Jinxiang &subvol_objectid); 1726f23c8af8SIlya Dryomov if (error) { 1727f23c8af8SIlya Dryomov kfree(subvol_name); 1728061dbc6bSAl Viro return ERR_PTR(error); 1729f23c8af8SIlya Dryomov } 1730edf24abeSChristoph Hellwig 1731312c89fbSMisono, Tomohiro /* mount device's root (/) */ 1732312c89fbSMisono, Tomohiro mnt_root = vfs_kern_mount(&btrfs_root_fs_type, flags, device_name, data); 1733312c89fbSMisono, Tomohiro if (PTR_ERR_OR_ZERO(mnt_root) == -EBUSY) { 1734312c89fbSMisono, Tomohiro if (flags & SB_RDONLY) { 1735312c89fbSMisono, Tomohiro mnt_root = vfs_kern_mount(&btrfs_root_fs_type, 1736312c89fbSMisono, Tomohiro flags & ~SB_RDONLY, device_name, data); 17374b82d6e4SYan } else { 1738312c89fbSMisono, Tomohiro mnt_root = vfs_kern_mount(&btrfs_root_fs_type, 1739312c89fbSMisono, Tomohiro flags | SB_RDONLY, device_name, data); 1740312c89fbSMisono, Tomohiro if (IS_ERR(mnt_root)) { 1741312c89fbSMisono, Tomohiro root = ERR_CAST(mnt_root); 1742532b618bSEric W. Biederman kfree(subvol_name); 1743312c89fbSMisono, Tomohiro goto out; 1744f667aef6SQu Wenruo } 1745f667aef6SQu Wenruo 1746312c89fbSMisono, Tomohiro down_write(&mnt_root->mnt_sb->s_umount); 1747312c89fbSMisono, Tomohiro error = btrfs_remount(mnt_root->mnt_sb, &flags, NULL); 1748312c89fbSMisono, Tomohiro up_write(&mnt_root->mnt_sb->s_umount); 1749312c89fbSMisono, Tomohiro if (error < 0) { 1750312c89fbSMisono, Tomohiro root = ERR_PTR(error); 1751312c89fbSMisono, Tomohiro mntput(mnt_root); 1752532b618bSEric W. Biederman kfree(subvol_name); 1753312c89fbSMisono, Tomohiro goto out; 1754312c89fbSMisono, Tomohiro } 1755312c89fbSMisono, Tomohiro } 1756312c89fbSMisono, Tomohiro } 1757312c89fbSMisono, Tomohiro if (IS_ERR(mnt_root)) { 1758312c89fbSMisono, Tomohiro root = ERR_CAST(mnt_root); 1759532b618bSEric W. Biederman kfree(subvol_name); 1760312c89fbSMisono, Tomohiro goto out; 1761f667aef6SQu Wenruo } 17624b82d6e4SYan 1763312c89fbSMisono, Tomohiro /* mount_subvol() will free subvol_name and mnt_root */ 1764ae0bc863SAnand Jain root = mount_subvol(subvol_name, subvol_objectid, mnt_root); 17654b82d6e4SYan 1766312c89fbSMisono, Tomohiro out: 1767312c89fbSMisono, Tomohiro return root; 17684b82d6e4SYan } 17692e635a27SChris Mason 17700d2450abSSergei Trofimovich static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info, 1771f7b885beSAnand Jain u32 new_pool_size, u32 old_pool_size) 17720d2450abSSergei Trofimovich { 17730d2450abSSergei Trofimovich if (new_pool_size == old_pool_size) 17740d2450abSSergei Trofimovich return; 17750d2450abSSergei Trofimovich 17760d2450abSSergei Trofimovich fs_info->thread_pool_size = new_pool_size; 17770d2450abSSergei Trofimovich 1778efe120a0SFrank Holton btrfs_info(fs_info, "resize thread pool %d -> %d", 17790d2450abSSergei Trofimovich old_pool_size, new_pool_size); 17800d2450abSSergei Trofimovich 17815cdc7ad3SQu Wenruo btrfs_workqueue_set_max(fs_info->workers, new_pool_size); 1782afe3d242SQu Wenruo btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size); 1783e66f0bb1SQu Wenruo btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size); 1784fccb5d86SQu Wenruo btrfs_workqueue_set_max(fs_info->endio_workers, new_pool_size); 1785fccb5d86SQu Wenruo btrfs_workqueue_set_max(fs_info->endio_meta_workers, new_pool_size); 1786fccb5d86SQu Wenruo btrfs_workqueue_set_max(fs_info->endio_meta_write_workers, 1787fccb5d86SQu Wenruo new_pool_size); 1788fccb5d86SQu Wenruo btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size); 1789fccb5d86SQu Wenruo btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size); 17905b3bc44eSQu Wenruo btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size); 1791736cfa15SQu Wenruo btrfs_workqueue_set_max(fs_info->readahead_workers, new_pool_size); 17920339ef2fSQu Wenruo btrfs_workqueue_set_max(fs_info->scrub_wr_completion_workers, 1793ff023aacSStefan Behrens new_pool_size); 17940d2450abSSergei Trofimovich } 17950d2450abSSergei Trofimovich 1796f42a34b2SMiao Xie static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info, 1797f42a34b2SMiao Xie unsigned long old_opts, int flags) 1798f42a34b2SMiao Xie { 1799dc81cdc5SMiao Xie if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) && 1800dc81cdc5SMiao Xie (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || 18011751e8a6SLinus Torvalds (flags & SB_RDONLY))) { 1802dc81cdc5SMiao Xie /* wait for any defraggers to finish */ 1803dc81cdc5SMiao Xie wait_event(fs_info->transaction_wait, 1804dc81cdc5SMiao Xie (atomic_read(&fs_info->defrag_running) == 0)); 18051751e8a6SLinus Torvalds if (flags & SB_RDONLY) 1806dc81cdc5SMiao Xie sync_filesystem(fs_info->sb); 1807dc81cdc5SMiao Xie } 1808dc81cdc5SMiao Xie } 1809dc81cdc5SMiao Xie 1810dc81cdc5SMiao Xie static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info, 1811dc81cdc5SMiao Xie unsigned long old_opts) 1812dc81cdc5SMiao Xie { 1813dc81cdc5SMiao Xie /* 1814180e4d47SLuis de Bethencourt * We need to cleanup all defragable inodes if the autodefragment is 1815180e4d47SLuis de Bethencourt * close or the filesystem is read only. 1816dc81cdc5SMiao Xie */ 1817dc81cdc5SMiao Xie if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) && 1818bc98a42cSDavid Howells (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || sb_rdonly(fs_info->sb))) { 1819dc81cdc5SMiao Xie btrfs_cleanup_defrag_inodes(fs_info); 1820dc81cdc5SMiao Xie } 1821dc81cdc5SMiao Xie 1822b0643e59SDennis Zhou /* If we toggled discard async */ 1823b0643e59SDennis Zhou if (!btrfs_raw_test_opt(old_opts, DISCARD_ASYNC) && 1824b0643e59SDennis Zhou btrfs_test_opt(fs_info, DISCARD_ASYNC)) 1825b0643e59SDennis Zhou btrfs_discard_resume(fs_info); 1826b0643e59SDennis Zhou else if (btrfs_raw_test_opt(old_opts, DISCARD_ASYNC) && 1827b0643e59SDennis Zhou !btrfs_test_opt(fs_info, DISCARD_ASYNC)) 1828b0643e59SDennis Zhou btrfs_discard_cleanup(fs_info); 1829dc81cdc5SMiao Xie } 1830dc81cdc5SMiao Xie 1831c146afadSYan Zheng static int btrfs_remount(struct super_block *sb, int *flags, char *data) 1832c146afadSYan Zheng { 1833815745cfSAl Viro struct btrfs_fs_info *fs_info = btrfs_sb(sb); 1834815745cfSAl Viro struct btrfs_root *root = fs_info->tree_root; 183549b25e05SJeff Mahoney unsigned old_flags = sb->s_flags; 183649b25e05SJeff Mahoney unsigned long old_opts = fs_info->mount_opt; 183749b25e05SJeff Mahoney unsigned long old_compress_type = fs_info->compress_type; 183849b25e05SJeff Mahoney u64 old_max_inline = fs_info->max_inline; 1839f7b885beSAnand Jain u32 old_thread_pool_size = fs_info->thread_pool_size; 1840d612ac59SAnand Jain u32 old_metadata_ratio = fs_info->metadata_ratio; 1841c146afadSYan Zheng int ret; 1842c146afadSYan Zheng 184302b9984dSTheodore Ts'o sync_filesystem(sb); 184488c4703fSJohannes Thumshirn set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state); 1845dc81cdc5SMiao Xie 1846f667aef6SQu Wenruo if (data) { 1847204cc0ccSAl Viro void *new_sec_opts = NULL; 1848f667aef6SQu Wenruo 1849a65001e8SAl Viro ret = security_sb_eat_lsm_opts(data, &new_sec_opts); 1850a65001e8SAl Viro if (!ret) 1851204cc0ccSAl Viro ret = security_sb_remount(sb, new_sec_opts); 1852a65001e8SAl Viro security_free_mnt_opts(&new_sec_opts); 1853f667aef6SQu Wenruo if (ret) 1854f667aef6SQu Wenruo goto restore; 1855f667aef6SQu Wenruo } 1856f667aef6SQu Wenruo 18572ff7e61eSJeff Mahoney ret = btrfs_parse_options(fs_info, data, *flags); 1858891f41cbSChengguang Xu if (ret) 185949b25e05SJeff Mahoney goto restore; 1860b288052eSChris Mason 1861f42a34b2SMiao Xie btrfs_remount_begin(fs_info, old_opts, *flags); 18620d2450abSSergei Trofimovich btrfs_resize_thread_pool(fs_info, 18630d2450abSSergei Trofimovich fs_info->thread_pool_size, old_thread_pool_size); 18640d2450abSSergei Trofimovich 18651751e8a6SLinus Torvalds if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb)) 1866dc81cdc5SMiao Xie goto out; 1867c146afadSYan Zheng 18681751e8a6SLinus Torvalds if (*flags & SB_RDONLY) { 18698dabb742SStefan Behrens /* 18708dabb742SStefan Behrens * this also happens on 'umount -rf' or on shutdown, when 18718dabb742SStefan Behrens * the filesystem is busy. 18728dabb742SStefan Behrens */ 187321c7e756SMiao Xie cancel_work_sync(&fs_info->async_reclaim_work); 1874361c093dSStefan Behrens 1875b0643e59SDennis Zhou btrfs_discard_cleanup(fs_info); 1876b0643e59SDennis Zhou 1877361c093dSStefan Behrens /* wait for the uuid_scan task to finish */ 1878361c093dSStefan Behrens down(&fs_info->uuid_tree_rescan_sem); 1879361c093dSStefan Behrens /* avoid complains from lockdep et al. */ 1880361c093dSStefan Behrens up(&fs_info->uuid_tree_rescan_sem); 1881361c093dSStefan Behrens 18821751e8a6SLinus Torvalds sb->s_flags |= SB_RDONLY; 1883c146afadSYan Zheng 1884e44163e1SJeff Mahoney /* 18851751e8a6SLinus Torvalds * Setting SB_RDONLY will put the cleaner thread to 1886e44163e1SJeff Mahoney * sleep at the next loop if it's already active. 1887e44163e1SJeff Mahoney * If it's already asleep, we'll leave unused block 1888e44163e1SJeff Mahoney * groups on disk until we're mounted read-write again 1889e44163e1SJeff Mahoney * unless we clean them up here. 1890e44163e1SJeff Mahoney */ 1891e44163e1SJeff Mahoney btrfs_delete_unused_bgs(fs_info); 1892e44163e1SJeff Mahoney 18938dabb742SStefan Behrens btrfs_dev_replace_suspend_for_unmount(fs_info); 18948dabb742SStefan Behrens btrfs_scrub_cancel(fs_info); 1895061594efSMiao Xie btrfs_pause_balance(fs_info); 18968dabb742SStefan Behrens 18976bccf3abSJeff Mahoney ret = btrfs_commit_super(fs_info); 189849b25e05SJeff Mahoney if (ret) 189949b25e05SJeff Mahoney goto restore; 1900c146afadSYan Zheng } else { 19010b246afaSJeff Mahoney if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 19026ef3de9cSDavid Sterba btrfs_err(fs_info, 1903efe120a0SFrank Holton "Remounting read-write after error is not allowed"); 19046ef3de9cSDavid Sterba ret = -EINVAL; 19056ef3de9cSDavid Sterba goto restore; 19066ef3de9cSDavid Sterba } 19078a3db184SSergei Trofimovich if (fs_info->fs_devices->rw_devices == 0) { 190849b25e05SJeff Mahoney ret = -EACCES; 190949b25e05SJeff Mahoney goto restore; 19108a3db184SSergei Trofimovich } 19112b82032cSYan Zheng 19126528b99dSAnand Jain if (!btrfs_check_rw_degradable(fs_info, NULL)) { 1913efe120a0SFrank Holton btrfs_warn(fs_info, 191452042d8eSAndrea Gelmini "too many missing devices, writable remount is not allowed"); 1915292fd7fcSStefan Behrens ret = -EACCES; 1916292fd7fcSStefan Behrens goto restore; 1917292fd7fcSStefan Behrens } 1918292fd7fcSStefan Behrens 19198a3db184SSergei Trofimovich if (btrfs_super_log_root(fs_info->super_copy) != 0) { 192010a3a3edSDavid Sterba btrfs_warn(fs_info, 192110a3a3edSDavid Sterba "mount required to replay tree-log, cannot remount read-write"); 192249b25e05SJeff Mahoney ret = -EINVAL; 192349b25e05SJeff Mahoney goto restore; 19248a3db184SSergei Trofimovich } 1925c146afadSYan Zheng 1926815745cfSAl Viro ret = btrfs_cleanup_fs_roots(fs_info); 192749b25e05SJeff Mahoney if (ret) 192849b25e05SJeff Mahoney goto restore; 1929c146afadSYan Zheng 1930d68fc57bSYan, Zheng /* recover relocation */ 19315f316481SWang Shilong mutex_lock(&fs_info->cleaner_mutex); 1932d68fc57bSYan, Zheng ret = btrfs_recover_relocation(root); 19335f316481SWang Shilong mutex_unlock(&fs_info->cleaner_mutex); 193449b25e05SJeff Mahoney if (ret) 193549b25e05SJeff Mahoney goto restore; 1936c146afadSYan Zheng 19372b6ba629SIlya Dryomov ret = btrfs_resume_balance_async(fs_info); 19382b6ba629SIlya Dryomov if (ret) 19392b6ba629SIlya Dryomov goto restore; 19402b6ba629SIlya Dryomov 19418dabb742SStefan Behrens ret = btrfs_resume_dev_replace_async(fs_info); 19428dabb742SStefan Behrens if (ret) { 1943efe120a0SFrank Holton btrfs_warn(fs_info, "failed to resume dev_replace"); 19448dabb742SStefan Behrens goto restore; 19458dabb742SStefan Behrens } 194694aebfb2SJosef Bacik 19476c6b5a39SAleksa Sarai btrfs_qgroup_rescan_resume(fs_info); 19486c6b5a39SAleksa Sarai 194994aebfb2SJosef Bacik if (!fs_info->uuid_root) { 1950efe120a0SFrank Holton btrfs_info(fs_info, "creating UUID tree"); 195194aebfb2SJosef Bacik ret = btrfs_create_uuid_tree(fs_info); 195294aebfb2SJosef Bacik if (ret) { 19535d163e0eSJeff Mahoney btrfs_warn(fs_info, 19545d163e0eSJeff Mahoney "failed to create the UUID tree %d", 19555d163e0eSJeff Mahoney ret); 195694aebfb2SJosef Bacik goto restore; 195794aebfb2SJosef Bacik } 195894aebfb2SJosef Bacik } 19591751e8a6SLinus Torvalds sb->s_flags &= ~SB_RDONLY; 196090c711abSZygo Blaxell 1961afcdd129SJosef Bacik set_bit(BTRFS_FS_OPEN, &fs_info->flags); 1962c146afadSYan Zheng } 1963dc81cdc5SMiao Xie out: 1964faa00889SJosef Bacik /* 1965faa00889SJosef Bacik * We need to set SB_I_VERSION here otherwise it'll get cleared by VFS, 1966faa00889SJosef Bacik * since the absence of the flag means it can be toggled off by remount. 1967faa00889SJosef Bacik */ 1968faa00889SJosef Bacik *flags |= SB_I_VERSION; 1969faa00889SJosef Bacik 19702c6a92b0SJustin Maggard wake_up_process(fs_info->transaction_kthread); 1971dc81cdc5SMiao Xie btrfs_remount_cleanup(fs_info, old_opts); 197288c4703fSJohannes Thumshirn clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state); 197388c4703fSJohannes Thumshirn 1974c146afadSYan Zheng return 0; 197549b25e05SJeff Mahoney 197649b25e05SJeff Mahoney restore: 19771751e8a6SLinus Torvalds /* We've hit an error - don't reset SB_RDONLY */ 1978bc98a42cSDavid Howells if (sb_rdonly(sb)) 19791751e8a6SLinus Torvalds old_flags |= SB_RDONLY; 198049b25e05SJeff Mahoney sb->s_flags = old_flags; 198149b25e05SJeff Mahoney fs_info->mount_opt = old_opts; 198249b25e05SJeff Mahoney fs_info->compress_type = old_compress_type; 198349b25e05SJeff Mahoney fs_info->max_inline = old_max_inline; 19840d2450abSSergei Trofimovich btrfs_resize_thread_pool(fs_info, 19850d2450abSSergei Trofimovich old_thread_pool_size, fs_info->thread_pool_size); 198649b25e05SJeff Mahoney fs_info->metadata_ratio = old_metadata_ratio; 1987dc81cdc5SMiao Xie btrfs_remount_cleanup(fs_info, old_opts); 198888c4703fSJohannes Thumshirn clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state); 198988c4703fSJohannes Thumshirn 199049b25e05SJeff Mahoney return ret; 1991c146afadSYan Zheng } 1992c146afadSYan Zheng 1993bcd53741SArne Jansen /* Used to sort the devices by max_avail(descending sort) */ 19947e17916bSArnd Bergmann static inline int btrfs_cmp_device_free_bytes(const void *dev_info1, 1995bcd53741SArne Jansen const void *dev_info2) 1996bcd53741SArne Jansen { 1997bcd53741SArne Jansen if (((struct btrfs_device_info *)dev_info1)->max_avail > 1998bcd53741SArne Jansen ((struct btrfs_device_info *)dev_info2)->max_avail) 1999bcd53741SArne Jansen return -1; 2000bcd53741SArne Jansen else if (((struct btrfs_device_info *)dev_info1)->max_avail < 2001bcd53741SArne Jansen ((struct btrfs_device_info *)dev_info2)->max_avail) 2002bcd53741SArne Jansen return 1; 2003bcd53741SArne Jansen else 2004bcd53741SArne Jansen return 0; 2005bcd53741SArne Jansen } 2006bcd53741SArne Jansen 2007bcd53741SArne Jansen /* 2008bcd53741SArne Jansen * sort the devices by max_avail, in which max free extent size of each device 2009bcd53741SArne Jansen * is stored.(Descending Sort) 2010bcd53741SArne Jansen */ 2011bcd53741SArne Jansen static inline void btrfs_descending_sort_devices( 2012bcd53741SArne Jansen struct btrfs_device_info *devices, 2013bcd53741SArne Jansen size_t nr_devices) 2014bcd53741SArne Jansen { 2015bcd53741SArne Jansen sort(devices, nr_devices, sizeof(struct btrfs_device_info), 2016bcd53741SArne Jansen btrfs_cmp_device_free_bytes, NULL); 2017bcd53741SArne Jansen } 2018bcd53741SArne Jansen 20196d07bcecSMiao Xie /* 20206d07bcecSMiao Xie * The helper to calc the free space on the devices that can be used to store 20216d07bcecSMiao Xie * file data. 20226d07bcecSMiao Xie */ 20237e17916bSArnd Bergmann static inline int btrfs_calc_avail_data_space(struct btrfs_fs_info *fs_info, 20246bccf3abSJeff Mahoney u64 *free_bytes) 20256d07bcecSMiao Xie { 20266d07bcecSMiao Xie struct btrfs_device_info *devices_info; 20276d07bcecSMiao Xie struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 20286d07bcecSMiao Xie struct btrfs_device *device; 20296d07bcecSMiao Xie u64 type; 20306d07bcecSMiao Xie u64 avail_space; 20316d07bcecSMiao Xie u64 min_stripe_size; 2032559ca6eaSNikolay Borisov int num_stripes = 1; 20336d07bcecSMiao Xie int i = 0, nr_devices; 20344f080f57SDavid Sterba const struct btrfs_raid_attr *rattr; 20356d07bcecSMiao Xie 20367e33fd99SJosef Bacik /* 203701327610SNicholas D Steeves * We aren't under the device list lock, so this is racy-ish, but good 20387e33fd99SJosef Bacik * enough for our purposes. 20397e33fd99SJosef Bacik */ 2040b772a86eSLi Zefan nr_devices = fs_info->fs_devices->open_devices; 20417e33fd99SJosef Bacik if (!nr_devices) { 20427e33fd99SJosef Bacik smp_mb(); 20437e33fd99SJosef Bacik nr_devices = fs_info->fs_devices->open_devices; 20447e33fd99SJosef Bacik ASSERT(nr_devices); 20457e33fd99SJosef Bacik if (!nr_devices) { 20467e33fd99SJosef Bacik *free_bytes = 0; 20477e33fd99SJosef Bacik return 0; 20487e33fd99SJosef Bacik } 20497e33fd99SJosef Bacik } 20506d07bcecSMiao Xie 2051d9b0d9baSDulshani Gunawardhana devices_info = kmalloc_array(nr_devices, sizeof(*devices_info), 20526a44517dSDavid Sterba GFP_KERNEL); 20536d07bcecSMiao Xie if (!devices_info) 20546d07bcecSMiao Xie return -ENOMEM; 20556d07bcecSMiao Xie 205601327610SNicholas D Steeves /* calc min stripe number for data space allocation */ 20571b86826dSJeff Mahoney type = btrfs_data_alloc_profile(fs_info); 20584f080f57SDavid Sterba rattr = &btrfs_raid_array[btrfs_bg_flags_to_raid_index(type)]; 20594f080f57SDavid Sterba 2060e1ea2beeSDavid Sterba if (type & BTRFS_BLOCK_GROUP_RAID0) 206139fb26c3SMiao Xie num_stripes = nr_devices; 2062e1ea2beeSDavid Sterba else if (type & BTRFS_BLOCK_GROUP_RAID1) 206339fb26c3SMiao Xie num_stripes = 2; 206447e6f742SDavid Sterba else if (type & BTRFS_BLOCK_GROUP_RAID1C3) 206547e6f742SDavid Sterba num_stripes = 3; 20668d6fac00SDavid Sterba else if (type & BTRFS_BLOCK_GROUP_RAID1C4) 20678d6fac00SDavid Sterba num_stripes = 4; 2068e1ea2beeSDavid Sterba else if (type & BTRFS_BLOCK_GROUP_RAID10) 206939fb26c3SMiao Xie num_stripes = 4; 20706d07bcecSMiao Xie 20714f080f57SDavid Sterba /* Adjust for more than 1 stripe per device */ 20724f080f57SDavid Sterba min_stripe_size = rattr->dev_stripes * BTRFS_STRIPE_LEN; 20736d07bcecSMiao Xie 20747e33fd99SJosef Bacik rcu_read_lock(); 20757e33fd99SJosef Bacik list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) { 2076e12c9621SAnand Jain if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, 2077e12c9621SAnand Jain &device->dev_state) || 2078401e29c1SAnand Jain !device->bdev || 2079401e29c1SAnand Jain test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) 20806d07bcecSMiao Xie continue; 20816d07bcecSMiao Xie 20827e33fd99SJosef Bacik if (i >= nr_devices) 20837e33fd99SJosef Bacik break; 20847e33fd99SJosef Bacik 20856d07bcecSMiao Xie avail_space = device->total_bytes - device->bytes_used; 20866d07bcecSMiao Xie 20876d07bcecSMiao Xie /* align with stripe_len */ 2088559ca6eaSNikolay Borisov avail_space = rounddown(avail_space, BTRFS_STRIPE_LEN); 20896d07bcecSMiao Xie 20906d07bcecSMiao Xie /* 209101327610SNicholas D Steeves * In order to avoid overwriting the superblock on the drive, 20926d07bcecSMiao Xie * btrfs starts at an offset of at least 1MB when doing chunk 20936d07bcecSMiao Xie * allocation. 2094559ca6eaSNikolay Borisov * 2095559ca6eaSNikolay Borisov * This ensures we have at least min_stripe_size free space 2096559ca6eaSNikolay Borisov * after excluding 1MB. 20976d07bcecSMiao Xie */ 2098559ca6eaSNikolay Borisov if (avail_space <= SZ_1M + min_stripe_size) 20996d07bcecSMiao Xie continue; 21006d07bcecSMiao Xie 2101559ca6eaSNikolay Borisov avail_space -= SZ_1M; 2102559ca6eaSNikolay Borisov 21036d07bcecSMiao Xie devices_info[i].dev = device; 21046d07bcecSMiao Xie devices_info[i].max_avail = avail_space; 21056d07bcecSMiao Xie 21066d07bcecSMiao Xie i++; 21076d07bcecSMiao Xie } 21087e33fd99SJosef Bacik rcu_read_unlock(); 21096d07bcecSMiao Xie 21106d07bcecSMiao Xie nr_devices = i; 21116d07bcecSMiao Xie 21126d07bcecSMiao Xie btrfs_descending_sort_devices(devices_info, nr_devices); 21136d07bcecSMiao Xie 21146d07bcecSMiao Xie i = nr_devices - 1; 21156d07bcecSMiao Xie avail_space = 0; 2116559ca6eaSNikolay Borisov while (nr_devices >= rattr->devs_min) { 2117559ca6eaSNikolay Borisov num_stripes = min(num_stripes, nr_devices); 211839fb26c3SMiao Xie 21196d07bcecSMiao Xie if (devices_info[i].max_avail >= min_stripe_size) { 21206d07bcecSMiao Xie int j; 21216d07bcecSMiao Xie u64 alloc_size; 21226d07bcecSMiao Xie 212339fb26c3SMiao Xie avail_space += devices_info[i].max_avail * num_stripes; 21246d07bcecSMiao Xie alloc_size = devices_info[i].max_avail; 212539fb26c3SMiao Xie for (j = i + 1 - num_stripes; j <= i; j++) 21266d07bcecSMiao Xie devices_info[j].max_avail -= alloc_size; 21276d07bcecSMiao Xie } 21286d07bcecSMiao Xie i--; 21296d07bcecSMiao Xie nr_devices--; 21306d07bcecSMiao Xie } 21316d07bcecSMiao Xie 21326d07bcecSMiao Xie kfree(devices_info); 21336d07bcecSMiao Xie *free_bytes = avail_space; 21346d07bcecSMiao Xie return 0; 21356d07bcecSMiao Xie } 21366d07bcecSMiao Xie 2137ba7b6e62SDavid Sterba /* 2138ba7b6e62SDavid Sterba * Calculate numbers for 'df', pessimistic in case of mixed raid profiles. 2139ba7b6e62SDavid Sterba * 2140ba7b6e62SDavid Sterba * If there's a redundant raid level at DATA block groups, use the respective 2141ba7b6e62SDavid Sterba * multiplier to scale the sizes. 2142ba7b6e62SDavid Sterba * 2143ba7b6e62SDavid Sterba * Unused device space usage is based on simulating the chunk allocator 21440d0c71b3SDavid Sterba * algorithm that respects the device sizes and order of allocations. This is 21450d0c71b3SDavid Sterba * a close approximation of the actual use but there are other factors that may 21460d0c71b3SDavid Sterba * change the result (like a new metadata chunk). 2147ba7b6e62SDavid Sterba * 2148ca8a51b3SDavid Sterba * If metadata is exhausted, f_bavail will be 0. 2149ba7b6e62SDavid Sterba */ 21508fd17795SChris Mason static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf) 21518fd17795SChris Mason { 2152815745cfSAl Viro struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb); 2153815745cfSAl Viro struct btrfs_super_block *disk_super = fs_info->super_copy; 2154bd4d1088SJosef Bacik struct btrfs_space_info *found; 2155bd4d1088SJosef Bacik u64 total_used = 0; 21566d07bcecSMiao Xie u64 total_free_data = 0; 2157ca8a51b3SDavid Sterba u64 total_free_meta = 0; 2158db94535dSChris Mason int bits = dentry->d_sb->s_blocksize_bits; 2159de37aa51SNikolay Borisov __be32 *fsid = (__be32 *)fs_info->fs_devices->fsid; 2160ba7b6e62SDavid Sterba unsigned factor = 1; 2161ba7b6e62SDavid Sterba struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 21626d07bcecSMiao Xie int ret; 2163ca8a51b3SDavid Sterba u64 thresh = 0; 2164ae02d1bdSLuis de Bethencourt int mixed = 0; 21658fd17795SChris Mason 2166bd4d1088SJosef Bacik rcu_read_lock(); 2167f5389f33SJohannes Thumshirn list_for_each_entry_rcu(found, &fs_info->space_info, list) { 21686d07bcecSMiao Xie if (found->flags & BTRFS_BLOCK_GROUP_DATA) { 2169ba7b6e62SDavid Sterba int i; 2170ba7b6e62SDavid Sterba 21716d07bcecSMiao Xie total_free_data += found->disk_total - found->disk_used; 21726d07bcecSMiao Xie total_free_data -= 21736d07bcecSMiao Xie btrfs_account_ro_block_groups_free_space(found); 2174ba7b6e62SDavid Sterba 2175ba7b6e62SDavid Sterba for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) { 217646df06b8SDavid Sterba if (!list_empty(&found->block_groups[i])) 217746df06b8SDavid Sterba factor = btrfs_bg_type_to_factor( 217846df06b8SDavid Sterba btrfs_raid_array[i].bg_flag); 2179ba7b6e62SDavid Sterba } 21806d07bcecSMiao Xie } 2181ae02d1bdSLuis de Bethencourt 2182ae02d1bdSLuis de Bethencourt /* 2183ae02d1bdSLuis de Bethencourt * Metadata in mixed block goup profiles are accounted in data 2184ae02d1bdSLuis de Bethencourt */ 2185ae02d1bdSLuis de Bethencourt if (!mixed && found->flags & BTRFS_BLOCK_GROUP_METADATA) { 2186ae02d1bdSLuis de Bethencourt if (found->flags & BTRFS_BLOCK_GROUP_DATA) 2187ae02d1bdSLuis de Bethencourt mixed = 1; 2188ae02d1bdSLuis de Bethencourt else 2189ae02d1bdSLuis de Bethencourt total_free_meta += found->disk_total - 2190ae02d1bdSLuis de Bethencourt found->disk_used; 2191ae02d1bdSLuis de Bethencourt } 21926d07bcecSMiao Xie 2193b742bb82SYan, Zheng total_used += found->disk_used; 219489a55897SJosef Bacik } 2195ba7b6e62SDavid Sterba 2196bd4d1088SJosef Bacik rcu_read_unlock(); 2197bd4d1088SJosef Bacik 2198ba7b6e62SDavid Sterba buf->f_blocks = div_u64(btrfs_super_total_bytes(disk_super), factor); 2199ba7b6e62SDavid Sterba buf->f_blocks >>= bits; 2200ba7b6e62SDavid Sterba buf->f_bfree = buf->f_blocks - (div_u64(total_used, factor) >> bits); 2201ba7b6e62SDavid Sterba 2202ba7b6e62SDavid Sterba /* Account global block reserve as used, it's in logical size already */ 2203ba7b6e62SDavid Sterba spin_lock(&block_rsv->lock); 220441b34accSLuis de Bethencourt /* Mixed block groups accounting is not byte-accurate, avoid overflow */ 220541b34accSLuis de Bethencourt if (buf->f_bfree >= block_rsv->size >> bits) 2206ba7b6e62SDavid Sterba buf->f_bfree -= block_rsv->size >> bits; 220741b34accSLuis de Bethencourt else 220841b34accSLuis de Bethencourt buf->f_bfree = 0; 2209ba7b6e62SDavid Sterba spin_unlock(&block_rsv->lock); 2210ba7b6e62SDavid Sterba 22110d95c1beSDavid Sterba buf->f_bavail = div_u64(total_free_data, factor); 22126bccf3abSJeff Mahoney ret = btrfs_calc_avail_data_space(fs_info, &total_free_data); 22137e33fd99SJosef Bacik if (ret) 22146d07bcecSMiao Xie return ret; 2215ba7b6e62SDavid Sterba buf->f_bavail += div_u64(total_free_data, factor); 22166d07bcecSMiao Xie buf->f_bavail = buf->f_bavail >> bits; 2217d397712bSChris Mason 2218ca8a51b3SDavid Sterba /* 2219ca8a51b3SDavid Sterba * We calculate the remaining metadata space minus global reserve. If 2220ca8a51b3SDavid Sterba * this is (supposedly) smaller than zero, there's no space. But this 2221ca8a51b3SDavid Sterba * does not hold in practice, the exhausted state happens where's still 2222ca8a51b3SDavid Sterba * some positive delta. So we apply some guesswork and compare the 2223ca8a51b3SDavid Sterba * delta to a 4M threshold. (Practically observed delta was ~2M.) 2224ca8a51b3SDavid Sterba * 2225ca8a51b3SDavid Sterba * We probably cannot calculate the exact threshold value because this 2226ca8a51b3SDavid Sterba * depends on the internal reservations requested by various 2227ca8a51b3SDavid Sterba * operations, so some operations that consume a few metadata will 2228ca8a51b3SDavid Sterba * succeed even if the Avail is zero. But this is better than the other 2229ca8a51b3SDavid Sterba * way around. 2230ca8a51b3SDavid Sterba */ 2231d4417e22SNikolay Borisov thresh = SZ_4M; 2232ca8a51b3SDavid Sterba 2233d55966c4SJosef Bacik /* 2234d55966c4SJosef Bacik * We only want to claim there's no available space if we can no longer 2235d55966c4SJosef Bacik * allocate chunks for our metadata profile and our global reserve will 2236d55966c4SJosef Bacik * not fit in the free metadata space. If we aren't ->full then we 2237d55966c4SJosef Bacik * still can allocate chunks and thus are fine using the currently 2238d55966c4SJosef Bacik * calculated f_bavail. 2239d55966c4SJosef Bacik */ 2240d55966c4SJosef Bacik if (!mixed && block_rsv->space_info->full && 2241d55966c4SJosef Bacik total_free_meta - thresh < block_rsv->size) 2242ca8a51b3SDavid Sterba buf->f_bavail = 0; 2243ca8a51b3SDavid Sterba 2244ba7b6e62SDavid Sterba buf->f_type = BTRFS_SUPER_MAGIC; 2245ba7b6e62SDavid Sterba buf->f_bsize = dentry->d_sb->s_blocksize; 2246ba7b6e62SDavid Sterba buf->f_namelen = BTRFS_NAME_LEN; 2247ba7b6e62SDavid Sterba 22489d03632eSDavid Woodhouse /* We treat it as constant endianness (it doesn't matter _which_) 22499d03632eSDavid Woodhouse because we want the fsid to come out the same whether mounted 22509d03632eSDavid Woodhouse on a big-endian or little-endian host */ 22519d03632eSDavid Woodhouse buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]); 22529d03632eSDavid Woodhouse buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]); 225332d48fa1SDavid Woodhouse /* Mask in the root object ID too, to disambiguate subvols */ 22544fd786e6SMisono Tomohiro buf->f_fsid.val[0] ^= 22554fd786e6SMisono Tomohiro BTRFS_I(d_inode(dentry))->root->root_key.objectid >> 32; 22564fd786e6SMisono Tomohiro buf->f_fsid.val[1] ^= 22574fd786e6SMisono Tomohiro BTRFS_I(d_inode(dentry))->root->root_key.objectid; 225832d48fa1SDavid Woodhouse 22598fd17795SChris Mason return 0; 22608fd17795SChris Mason } 2261b5133862SChris Mason 2262aea52e19SAl Viro static void btrfs_kill_super(struct super_block *sb) 2263aea52e19SAl Viro { 2264815745cfSAl Viro struct btrfs_fs_info *fs_info = btrfs_sb(sb); 2265aea52e19SAl Viro kill_anon_super(sb); 22660d4b0463SJosef Bacik btrfs_free_fs_info(fs_info); 2267aea52e19SAl Viro } 2268aea52e19SAl Viro 22692e635a27SChris Mason static struct file_system_type btrfs_fs_type = { 22702e635a27SChris Mason .owner = THIS_MODULE, 22712e635a27SChris Mason .name = "btrfs", 2272061dbc6bSAl Viro .mount = btrfs_mount, 2273aea52e19SAl Viro .kill_sb = btrfs_kill_super, 2274f667aef6SQu Wenruo .fs_flags = FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA, 22752e635a27SChris Mason }; 227672fa39f5SMisono, Tomohiro 227772fa39f5SMisono, Tomohiro static struct file_system_type btrfs_root_fs_type = { 227872fa39f5SMisono, Tomohiro .owner = THIS_MODULE, 227972fa39f5SMisono, Tomohiro .name = "btrfs", 228072fa39f5SMisono, Tomohiro .mount = btrfs_mount_root, 228172fa39f5SMisono, Tomohiro .kill_sb = btrfs_kill_super, 228272fa39f5SMisono, Tomohiro .fs_flags = FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA, 228372fa39f5SMisono, Tomohiro }; 228472fa39f5SMisono, Tomohiro 22857f78e035SEric W. Biederman MODULE_ALIAS_FS("btrfs"); 2286a9218f6bSChris Mason 2287d8620958STom Van Braeckel static int btrfs_control_open(struct inode *inode, struct file *file) 2288d8620958STom Van Braeckel { 2289d8620958STom Van Braeckel /* 2290d8620958STom Van Braeckel * The control file's private_data is used to hold the 2291d8620958STom Van Braeckel * transaction when it is started and is used to keep 2292d8620958STom Van Braeckel * track of whether a transaction is already in progress. 2293d8620958STom Van Braeckel */ 2294d8620958STom Van Braeckel file->private_data = NULL; 2295d8620958STom Van Braeckel return 0; 2296d8620958STom Van Braeckel } 2297d8620958STom Van Braeckel 2298d352ac68SChris Mason /* 2299cfe953c8SSu Yue * Used by /dev/btrfs-control for devices ioctls. 2300d352ac68SChris Mason */ 23018a4b83ccSChris Mason static long btrfs_control_ioctl(struct file *file, unsigned int cmd, 23028a4b83ccSChris Mason unsigned long arg) 23038a4b83ccSChris Mason { 23048a4b83ccSChris Mason struct btrfs_ioctl_vol_args *vol; 230536350e95SGu Jinxiang struct btrfs_device *device = NULL; 2306c071fcfdSChris Mason int ret = -ENOTTY; 23078a4b83ccSChris Mason 2308e441d54dSChris Mason if (!capable(CAP_SYS_ADMIN)) 2309e441d54dSChris Mason return -EPERM; 2310e441d54dSChris Mason 2311dae7b665SLi Zefan vol = memdup_user((void __user *)arg, sizeof(*vol)); 2312dae7b665SLi Zefan if (IS_ERR(vol)) 2313dae7b665SLi Zefan return PTR_ERR(vol); 2314f505754fSFilipe Manana vol->name[BTRFS_PATH_NAME_MAX] = '\0'; 2315c071fcfdSChris Mason 23168a4b83ccSChris Mason switch (cmd) { 23178a4b83ccSChris Mason case BTRFS_IOC_SCAN_DEV: 2318899f9307SDavid Sterba mutex_lock(&uuid_mutex); 231936350e95SGu Jinxiang device = btrfs_scan_one_device(vol->name, FMODE_READ, 232036350e95SGu Jinxiang &btrfs_root_fs_type); 232136350e95SGu Jinxiang ret = PTR_ERR_OR_ZERO(device); 2322899f9307SDavid Sterba mutex_unlock(&uuid_mutex); 23238a4b83ccSChris Mason break; 2324228a73abSAnand Jain case BTRFS_IOC_FORGET_DEV: 2325228a73abSAnand Jain ret = btrfs_forget_devices(vol->name); 2326228a73abSAnand Jain break; 232702db0844SJosef Bacik case BTRFS_IOC_DEVICES_READY: 2328899f9307SDavid Sterba mutex_lock(&uuid_mutex); 232936350e95SGu Jinxiang device = btrfs_scan_one_device(vol->name, FMODE_READ, 233036350e95SGu Jinxiang &btrfs_root_fs_type); 233136350e95SGu Jinxiang if (IS_ERR(device)) { 2332899f9307SDavid Sterba mutex_unlock(&uuid_mutex); 233336350e95SGu Jinxiang ret = PTR_ERR(device); 233402db0844SJosef Bacik break; 2335899f9307SDavid Sterba } 233636350e95SGu Jinxiang ret = !(device->fs_devices->num_devices == 233736350e95SGu Jinxiang device->fs_devices->total_devices); 2338899f9307SDavid Sterba mutex_unlock(&uuid_mutex); 233902db0844SJosef Bacik break; 2340c5868f83SDavid Sterba case BTRFS_IOC_GET_SUPPORTED_FEATURES: 2341d5131b65SDavid Sterba ret = btrfs_ioctl_get_supported_features((void __user*)arg); 2342c5868f83SDavid Sterba break; 23438a4b83ccSChris Mason } 2344dae7b665SLi Zefan 23458a4b83ccSChris Mason kfree(vol); 2346f819d837SLinda Knippers return ret; 23478a4b83ccSChris Mason } 23488a4b83ccSChris Mason 23490176260fSLinus Torvalds static int btrfs_freeze(struct super_block *sb) 2350ed0dab6bSYan { 2351354aa0fbSMiao Xie struct btrfs_trans_handle *trans; 23520b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = btrfs_sb(sb); 23530b246afaSJeff Mahoney struct btrfs_root *root = fs_info->tree_root; 2354354aa0fbSMiao Xie 2355fac03c8dSDavid Sterba set_bit(BTRFS_FS_FROZEN, &fs_info->flags); 23569e7cc91aSWang Xiaoguang /* 23579e7cc91aSWang Xiaoguang * We don't need a barrier here, we'll wait for any transaction that 23589e7cc91aSWang Xiaoguang * could be in progress on other threads (and do delayed iputs that 23599e7cc91aSWang Xiaoguang * we want to avoid on a frozen filesystem), or do the commit 23609e7cc91aSWang Xiaoguang * ourselves. 23619e7cc91aSWang Xiaoguang */ 2362d4edf39bSMiao Xie trans = btrfs_attach_transaction_barrier(root); 2363354aa0fbSMiao Xie if (IS_ERR(trans)) { 2364354aa0fbSMiao Xie /* no transaction, don't bother */ 2365354aa0fbSMiao Xie if (PTR_ERR(trans) == -ENOENT) 23660176260fSLinus Torvalds return 0; 2367354aa0fbSMiao Xie return PTR_ERR(trans); 2368354aa0fbSMiao Xie } 23693a45bb20SJeff Mahoney return btrfs_commit_transaction(trans); 2370ed0dab6bSYan } 2371ed0dab6bSYan 23729e7cc91aSWang Xiaoguang static int btrfs_unfreeze(struct super_block *sb) 23739e7cc91aSWang Xiaoguang { 2374fac03c8dSDavid Sterba struct btrfs_fs_info *fs_info = btrfs_sb(sb); 2375fac03c8dSDavid Sterba 2376fac03c8dSDavid Sterba clear_bit(BTRFS_FS_FROZEN, &fs_info->flags); 23779e7cc91aSWang Xiaoguang return 0; 23789e7cc91aSWang Xiaoguang } 23799e7cc91aSWang Xiaoguang 23809c5085c1SJosef Bacik static int btrfs_show_devname(struct seq_file *m, struct dentry *root) 23819c5085c1SJosef Bacik { 23829c5085c1SJosef Bacik struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb); 23839c5085c1SJosef Bacik struct btrfs_device *dev, *first_dev = NULL; 23849c5085c1SJosef Bacik 238588c14590SDavid Sterba /* 238688c14590SDavid Sterba * Lightweight locking of the devices. We should not need 238788c14590SDavid Sterba * device_list_mutex here as we only read the device data and the list 238888c14590SDavid Sterba * is protected by RCU. Even if a device is deleted during the list 238988c14590SDavid Sterba * traversals, we'll get valid data, the freeing callback will wait at 239052042d8eSAndrea Gelmini * least until the rcu_read_unlock. 239188c14590SDavid Sterba */ 239288c14590SDavid Sterba rcu_read_lock(); 23934faf55b0SAnand Jain list_for_each_entry_rcu(dev, &fs_info->fs_devices->devices, dev_list) { 2394e6e674bdSAnand Jain if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state)) 2395aa9ddcd4SJosef Bacik continue; 23960aeb8a6eSAnand Jain if (!dev->name) 23970aeb8a6eSAnand Jain continue; 23989c5085c1SJosef Bacik if (!first_dev || dev->devid < first_dev->devid) 23999c5085c1SJosef Bacik first_dev = dev; 24009c5085c1SJosef Bacik } 24019c5085c1SJosef Bacik 2402672d5990SMisono Tomohiro if (first_dev) 2403672d5990SMisono Tomohiro seq_escape(m, rcu_str_deref(first_dev->name), " \t\n\\"); 2404672d5990SMisono Tomohiro else 24059c5085c1SJosef Bacik WARN_ON(1); 240688c14590SDavid Sterba rcu_read_unlock(); 24079c5085c1SJosef Bacik return 0; 24089c5085c1SJosef Bacik } 24099c5085c1SJosef Bacik 2410b87221deSAlexey Dobriyan static const struct super_operations btrfs_super_ops = { 241176dda93cSYan, Zheng .drop_inode = btrfs_drop_inode, 2412bd555975SAl Viro .evict_inode = btrfs_evict_inode, 2413e20d96d6SChris Mason .put_super = btrfs_put_super, 2414d5719762SChris Mason .sync_fs = btrfs_sync_fs, 2415a9572a15SEric Paris .show_options = btrfs_show_options, 24169c5085c1SJosef Bacik .show_devname = btrfs_show_devname, 24172c90e5d6SChris Mason .alloc_inode = btrfs_alloc_inode, 24182c90e5d6SChris Mason .destroy_inode = btrfs_destroy_inode, 241926602cabSAl Viro .free_inode = btrfs_free_inode, 24208fd17795SChris Mason .statfs = btrfs_statfs, 2421c146afadSYan Zheng .remount_fs = btrfs_remount, 24220176260fSLinus Torvalds .freeze_fs = btrfs_freeze, 24239e7cc91aSWang Xiaoguang .unfreeze_fs = btrfs_unfreeze, 2424e20d96d6SChris Mason }; 2425a9218f6bSChris Mason 2426a9218f6bSChris Mason static const struct file_operations btrfs_ctl_fops = { 2427d8620958STom Van Braeckel .open = btrfs_control_open, 2428a9218f6bSChris Mason .unlocked_ioctl = btrfs_control_ioctl, 24291832f2d8SArnd Bergmann .compat_ioctl = compat_ptr_ioctl, 2430a9218f6bSChris Mason .owner = THIS_MODULE, 24316038f373SArnd Bergmann .llseek = noop_llseek, 2432a9218f6bSChris Mason }; 2433a9218f6bSChris Mason 2434a9218f6bSChris Mason static struct miscdevice btrfs_misc = { 2435578454ffSKay Sievers .minor = BTRFS_MINOR, 2436a9218f6bSChris Mason .name = "btrfs-control", 2437a9218f6bSChris Mason .fops = &btrfs_ctl_fops 2438a9218f6bSChris Mason }; 2439a9218f6bSChris Mason 2440578454ffSKay Sievers MODULE_ALIAS_MISCDEV(BTRFS_MINOR); 2441578454ffSKay Sievers MODULE_ALIAS("devname:btrfs-control"); 2442578454ffSKay Sievers 2443f5c29bd9SLiu Bo static int __init btrfs_interface_init(void) 2444a9218f6bSChris Mason { 2445a9218f6bSChris Mason return misc_register(&btrfs_misc); 2446a9218f6bSChris Mason } 2447a9218f6bSChris Mason 2448e67c718bSDavid Sterba static __cold void btrfs_interface_exit(void) 2449a9218f6bSChris Mason { 2450f368ed60SGreg Kroah-Hartman misc_deregister(&btrfs_misc); 2451a9218f6bSChris Mason } 2452a9218f6bSChris Mason 2453f5c29bd9SLiu Bo static void __init btrfs_print_mod_info(void) 245485965600SDavid Sterba { 2455edf57cbfSBart Van Assche static const char options[] = "" 245685965600SDavid Sterba #ifdef CONFIG_BTRFS_DEBUG 245785965600SDavid Sterba ", debug=on" 245885965600SDavid Sterba #endif 245979556c3dSStefan Behrens #ifdef CONFIG_BTRFS_ASSERT 246079556c3dSStefan Behrens ", assert=on" 246179556c3dSStefan Behrens #endif 246285965600SDavid Sterba #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY 246385965600SDavid Sterba ", integrity-checker=on" 246485965600SDavid Sterba #endif 2465fb592373SJosef Bacik #ifdef CONFIG_BTRFS_FS_REF_VERIFY 2466fb592373SJosef Bacik ", ref-verify=on" 2467fb592373SJosef Bacik #endif 2468edf57cbfSBart Van Assche ; 2469edf57cbfSBart Van Assche pr_info("Btrfs loaded, crc32c=%s%s\n", crc32c_impl(), options); 247085965600SDavid Sterba } 247185965600SDavid Sterba 24722e635a27SChris Mason static int __init init_btrfs_fs(void) 24732e635a27SChris Mason { 24742c90e5d6SChris Mason int err; 247558176a96SJosef Bacik 247663541927SFilipe David Borba Manana btrfs_props_init(); 247763541927SFilipe David Borba Manana 247858176a96SJosef Bacik err = btrfs_init_sysfs(); 247958176a96SJosef Bacik if (err) 24809678c543SNikolay Borisov return err; 248158176a96SJosef Bacik 2482143bede5SJeff Mahoney btrfs_init_compress(); 2483d1310b2eSChris Mason 2484261507a0SLi Zefan err = btrfs_init_cachep(); 2485261507a0SLi Zefan if (err) 2486261507a0SLi Zefan goto free_compress; 2487261507a0SLi Zefan 2488d1310b2eSChris Mason err = extent_io_init(); 24892f4cbe64SWyatt Banks if (err) 24902f4cbe64SWyatt Banks goto free_cachep; 24912f4cbe64SWyatt Banks 24926f0d04f8SJosef Bacik err = extent_state_cache_init(); 2493d1310b2eSChris Mason if (err) 2494d1310b2eSChris Mason goto free_extent_io; 2495d1310b2eSChris Mason 24966f0d04f8SJosef Bacik err = extent_map_init(); 24976f0d04f8SJosef Bacik if (err) 24986f0d04f8SJosef Bacik goto free_extent_state_cache; 24996f0d04f8SJosef Bacik 25006352b91dSMiao Xie err = ordered_data_init(); 25012f4cbe64SWyatt Banks if (err) 25022f4cbe64SWyatt Banks goto free_extent_map; 2503c8b97818SChris Mason 25046352b91dSMiao Xie err = btrfs_delayed_inode_init(); 25056352b91dSMiao Xie if (err) 25066352b91dSMiao Xie goto free_ordered_data; 25076352b91dSMiao Xie 25089247f317SMiao Xie err = btrfs_auto_defrag_init(); 250916cdcec7SMiao Xie if (err) 251016cdcec7SMiao Xie goto free_delayed_inode; 251116cdcec7SMiao Xie 251278a6184aSMiao Xie err = btrfs_delayed_ref_init(); 25139247f317SMiao Xie if (err) 25149247f317SMiao Xie goto free_auto_defrag; 25159247f317SMiao Xie 2516b9e9a6cbSWang Shilong err = btrfs_prelim_ref_init(); 2517b9e9a6cbSWang Shilong if (err) 2518af13b492SDavid Sterba goto free_delayed_ref; 2519b9e9a6cbSWang Shilong 252097eb6b69SDavid Sterba err = btrfs_end_io_wq_init(); 252178a6184aSMiao Xie if (err) 2522af13b492SDavid Sterba goto free_prelim_ref; 252378a6184aSMiao Xie 252497eb6b69SDavid Sterba err = btrfs_interface_init(); 252597eb6b69SDavid Sterba if (err) 252697eb6b69SDavid Sterba goto free_end_io_wq; 252797eb6b69SDavid Sterba 2528e565d4b9SJan Schmidt btrfs_init_lockdep(); 2529e565d4b9SJan Schmidt 25308ae1af3cSAnand Jain btrfs_print_mod_info(); 2531dc11dd5dSJosef Bacik 2532dc11dd5dSJosef Bacik err = btrfs_run_sanity_tests(); 2533dc11dd5dSJosef Bacik if (err) 2534dc11dd5dSJosef Bacik goto unregister_ioctl; 2535dc11dd5dSJosef Bacik 2536dc11dd5dSJosef Bacik err = register_filesystem(&btrfs_fs_type); 2537dc11dd5dSJosef Bacik if (err) 2538dc11dd5dSJosef Bacik goto unregister_ioctl; 253974255aa0SJosef Bacik 25402f4cbe64SWyatt Banks return 0; 25412f4cbe64SWyatt Banks 2542a9218f6bSChris Mason unregister_ioctl: 2543a9218f6bSChris Mason btrfs_interface_exit(); 254497eb6b69SDavid Sterba free_end_io_wq: 254597eb6b69SDavid Sterba btrfs_end_io_wq_exit(); 2546b9e9a6cbSWang Shilong free_prelim_ref: 2547b9e9a6cbSWang Shilong btrfs_prelim_ref_exit(); 254878a6184aSMiao Xie free_delayed_ref: 254978a6184aSMiao Xie btrfs_delayed_ref_exit(); 25509247f317SMiao Xie free_auto_defrag: 25519247f317SMiao Xie btrfs_auto_defrag_exit(); 255216cdcec7SMiao Xie free_delayed_inode: 255316cdcec7SMiao Xie btrfs_delayed_inode_exit(); 25546352b91dSMiao Xie free_ordered_data: 25556352b91dSMiao Xie ordered_data_exit(); 25562f4cbe64SWyatt Banks free_extent_map: 25572f4cbe64SWyatt Banks extent_map_exit(); 25586f0d04f8SJosef Bacik free_extent_state_cache: 25596f0d04f8SJosef Bacik extent_state_cache_exit(); 2560d1310b2eSChris Mason free_extent_io: 2561d1310b2eSChris Mason extent_io_exit(); 25622f4cbe64SWyatt Banks free_cachep: 25632f4cbe64SWyatt Banks btrfs_destroy_cachep(); 2564261507a0SLi Zefan free_compress: 2565261507a0SLi Zefan btrfs_exit_compress(); 25662f4cbe64SWyatt Banks btrfs_exit_sysfs(); 25679678c543SNikolay Borisov 25682c90e5d6SChris Mason return err; 25692e635a27SChris Mason } 25702e635a27SChris Mason 25712e635a27SChris Mason static void __exit exit_btrfs_fs(void) 25722e635a27SChris Mason { 257339279cc3SChris Mason btrfs_destroy_cachep(); 257478a6184aSMiao Xie btrfs_delayed_ref_exit(); 25759247f317SMiao Xie btrfs_auto_defrag_exit(); 257616cdcec7SMiao Xie btrfs_delayed_inode_exit(); 2577b9e9a6cbSWang Shilong btrfs_prelim_ref_exit(); 25786352b91dSMiao Xie ordered_data_exit(); 2579a52d9a80SChris Mason extent_map_exit(); 25806f0d04f8SJosef Bacik extent_state_cache_exit(); 2581d1310b2eSChris Mason extent_io_exit(); 2582a9218f6bSChris Mason btrfs_interface_exit(); 25835ed5f588SJosef Bacik btrfs_end_io_wq_exit(); 25842e635a27SChris Mason unregister_filesystem(&btrfs_fs_type); 258558176a96SJosef Bacik btrfs_exit_sysfs(); 25868a4b83ccSChris Mason btrfs_cleanup_fs_uuids(); 2587261507a0SLi Zefan btrfs_exit_compress(); 25882e635a27SChris Mason } 25892e635a27SChris Mason 259060efa5ebSFilipe David Borba Manana late_initcall(init_btrfs_fs); 25912e635a27SChris Mason module_exit(exit_btrfs_fs) 25922e635a27SChris Mason 25932e635a27SChris Mason MODULE_LICENSE("GPL"); 2594d5178578SJohannes Thumshirn MODULE_SOFTDEP("pre: crc32c"); 25953951e7f0SJohannes Thumshirn MODULE_SOFTDEP("pre: xxhash64"); 25963831bf00SJohannes Thumshirn MODULE_SOFTDEP("pre: sha256"); 2597352ae07bSDavid Sterba MODULE_SOFTDEP("pre: blake2b-256"); 2598