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