/*
   * Copyright (C) 2007 Oracle.  All rights reserved.
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public
   * License v2 as published by the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * General Public License for more details.
   *
   * You should have received a copy of the GNU General Public
   * License along with this program; if not, write to the
   * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   * Boston, MA 021110-1307, USA.
   */

  #include <linux/blkdev.h>

  #include <linux/module.h>

  #include <linux/buffer_head.h>

  #include <linux/fs.h>
  #include <linux/pagemap.h>
  #include <linux/highmem.h>
  #include <linux/time.h>
  #include <linux/init.h>

  #include <linux/seq_file.h>

  #include <linux/string.h>

  #include <linux/backing-dev.h>

  #include <linux/mount.h>

  #include <linux/mpage.h>

  #include <linux/swap.h>
  #include <linux/writeback.h>

  #include <linux/statfs.h>

  #include <linux/compat.h>

  #include <linux/parser.h>

  #include <linux/ctype.h>

  #include <linux/namei.h>

  #include <linux/miscdevice.h>

  #include <linux/magic.h>

  #include <linux/slab.h>

  #include <linux/cleancache.h>

  #include <linux/ratelimit.h>

  #include <linux/btrfs.h>

  #include "delayed-inode.h"

  #include "ctree.h"

  #include "disk-io.h"

  #include "transaction.h"

  #include "btrfs_inode.h"

  #include "print-tree.h"

  #include "hash.h"

  #include "props.h"

  #include "xattr.h"

  #include "volumes.h"

  #include "export.h"

  #include "compression.h"

  #include "rcu-string.h"

  #include "dev-replace.h"

  #include "free-space-cache.h"

  #include "backref.h"

  #include "tests/btrfs-tests.h"

  #include "qgroup.h"

  #define CREATE_TRACE_POINTS
  #include <trace/events/btrfs.h>

  static const struct super_operations btrfs_super_ops;

  static struct file_system_type btrfs_fs_type;

  static int btrfs_remount(struct super_block *sb, int *flags, char *data);

  const char *btrfs_decode_error(int errno)

  {

  	char *errstr = "unknown";

  
  	switch (errno) {
  	case -EIO:
  		errstr = "IO failure";
  		break;
  	case -ENOMEM:
  		errstr = "Out of memory";
  		break;
  	case -EROFS:
  		errstr = "Readonly filesystem";
  		break;

  	case -EEXIST:
  		errstr = "Object already exists";
  		break;

  	case -ENOSPC:
  		errstr = "No space left";
  		break;
  	case -ENOENT:
  		errstr = "No such entry";
  		break;

  	}
  
  	return errstr;
  }

  /* btrfs handle error by forcing the filesystem readonly */
  static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
  {
  	struct super_block *sb = fs_info->sb;
  
  	if (sb->s_flags & MS_RDONLY)
  		return;

  	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {

  		sb->s_flags |= MS_RDONLY;

  		btrfs_info(fs_info, "forced readonly");

  		/*
  		 * Note that a running device replace operation is not
  		 * canceled here although there is no way to update
  		 * the progress. It would add the risk of a deadlock,

  		 * therefore the canceling is omitted. The only penalty

  		 * is that some I/O remains active until the procedure
  		 * completes. The next time when the filesystem is
  		 * mounted writeable again, the device replace
  		 * operation continues.
  		 */

  	}
  }
  
  /*

   * __btrfs_handle_fs_error decodes expected errors from the caller and

   * invokes the approciate error response.
   */

  __cold

  void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,

  		       unsigned int line, int errno, const char *fmt, ...)

  {
  	struct super_block *sb = fs_info->sb;

  #ifdef CONFIG_PRINTK

  	const char *errstr;

  #endif

  
  	/*
  	 * Special case: if the error is EROFS, and we're already
  	 * under MS_RDONLY, then it is safe here.
  	 */
  	if (errno == -EROFS && (sb->s_flags & MS_RDONLY))

    		return;

  #ifdef CONFIG_PRINTK

  	errstr = btrfs_decode_error(errno);

  	if (fmt) {

  		struct va_format vaf;
  		va_list args;
  
  		va_start(args, fmt);
  		vaf.fmt = fmt;
  		vaf.va = &args;

  		pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s (%pV)
  ",

  			sb->s_id, function, line, errno, errstr, &vaf);

  		va_end(args);

  	} else {

  		pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s
  ",

  			sb->s_id, function, line, errno, errstr);

  	}

  #endif

  	/*
  	 * Today we only save the error info to memory.  Long term we'll
  	 * also send it down to the disk
  	 */
  	set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);

  	/* Don't go through full error handling during mount */

  	if (sb->s_flags & MS_BORN)

  		btrfs_handle_error(fs_info);

  }

  #ifdef CONFIG_PRINTK

  static const char * const logtypes[] = {

  	"emergency",
  	"alert",
  	"critical",
  	"error",
  	"warning",
  	"notice",
  	"info",
  	"debug",
  };

  
  /*
   * Use one ratelimit state per log level so that a flood of less important
   * messages doesn't cause more important ones to be dropped.
   */
  static struct ratelimit_state printk_limits[] = {
  	RATELIMIT_STATE_INIT(printk_limits[0], DEFAULT_RATELIMIT_INTERVAL, 100),
  	RATELIMIT_STATE_INIT(printk_limits[1], DEFAULT_RATELIMIT_INTERVAL, 100),
  	RATELIMIT_STATE_INIT(printk_limits[2], DEFAULT_RATELIMIT_INTERVAL, 100),
  	RATELIMIT_STATE_INIT(printk_limits[3], DEFAULT_RATELIMIT_INTERVAL, 100),
  	RATELIMIT_STATE_INIT(printk_limits[4], DEFAULT_RATELIMIT_INTERVAL, 100),
  	RATELIMIT_STATE_INIT(printk_limits[5], DEFAULT_RATELIMIT_INTERVAL, 100),
  	RATELIMIT_STATE_INIT(printk_limits[6], DEFAULT_RATELIMIT_INTERVAL, 100),
  	RATELIMIT_STATE_INIT(printk_limits[7], DEFAULT_RATELIMIT_INTERVAL, 100),
  };

  void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)

  {
  	struct super_block *sb = fs_info->sb;
  	char lvl[4];
  	struct va_format vaf;
  	va_list args;
  	const char *type = logtypes[4];

  	int kern_level;

  	struct ratelimit_state *ratelimit;

  
  	va_start(args, fmt);

  	kern_level = printk_get_level(fmt);
  	if (kern_level) {
  		size_t size = printk_skip_level(fmt) - fmt;
  		memcpy(lvl, fmt,  size);
  		lvl[size] = '\0';
  		fmt += size;
  		type = logtypes[kern_level - '0'];

  		ratelimit = &printk_limits[kern_level - '0'];
  	} else {

  		*lvl = '\0';

  		/* Default to debug output */
  		ratelimit = &printk_limits[7];
  	}

  
  	vaf.fmt = fmt;
  	vaf.va = &args;

  	if (__ratelimit(ratelimit))
  		printk("%sBTRFS %s (device %s): %pV
  ", lvl, type, sb->s_id, &vaf);

  
  	va_end(args);
  }

  #endif

  /*

   * We only mark the transaction aborted and then set the file system read-only.
   * This will prevent new transactions from starting or trying to join this
   * one.
   *
   * This means that error recovery at the call site is limited to freeing
   * any local memory allocations and passing the error code up without
   * further cleanup. The transaction should complete as it normally would
   * in the call path but will return -EIO.
   *
   * We'll complete the cleanup in btrfs_end_transaction and
   * btrfs_commit_transaction.
   */

  __cold

  void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,

  			       const char *function,

  			       unsigned int line, int errno)
  {

  	struct btrfs_fs_info *fs_info = trans->fs_info;

  	trans->aborted = errno;
  	/* Nothing used. The other threads that have joined this
  	 * transaction may be able to continue. */

  	if (!trans->dirty && list_empty(&trans->new_bgs)) {

  		const char *errstr;

  		errstr = btrfs_decode_error(errno);

  		btrfs_warn(fs_info,

  		           "%s:%d: Aborting unused transaction(%s).",
  		           function, line, errstr);

  		return;

  	}

  	ACCESS_ONCE(trans->transaction->aborted) = errno;

  	/* Wake up anybody who may be waiting on this transaction */

  	wake_up(&fs_info->transaction_wait);
  	wake_up(&fs_info->transaction_blocked_wait);
  	__btrfs_handle_fs_error(fs_info, function, line, errno, NULL);

  }
  /*

   * __btrfs_panic decodes unexpected, fatal errors from the caller,
   * issues an alert, and either panics or BUGs, depending on mount options.
   */

  __cold

  void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
  		   unsigned int line, int errno, const char *fmt, ...)
  {

  	char *s_id = "<unknown>";
  	const char *errstr;
  	struct va_format vaf = { .fmt = fmt };
  	va_list args;

  	if (fs_info)
  		s_id = fs_info->sb->s_id;

  	va_start(args, fmt);
  	vaf.va = &args;

  	errstr = btrfs_decode_error(errno);

  	if (fs_info && (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR))

  		panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)
  ",
  			s_id, function, line, &vaf, errno, errstr);

  	btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",
  		   function, line, &vaf, errno, errstr);

  	va_end(args);
  	/* Caller calls BUG() */

  }

  static void btrfs_put_super(struct super_block *sb)

  {

  	close_ctree(btrfs_sb(sb)->tree_root);

  }

  enum {

  	Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,

  	Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
  	Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,

  	Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
  	Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,

  	Opt_space_cache, Opt_space_cache_version, Opt_clear_cache,
  	Opt_user_subvol_rm_allowed, Opt_enospc_debug, Opt_subvolrootid,
  	Opt_defrag, Opt_inode_cache, Opt_no_space_cache, Opt_recovery,
  	Opt_skip_balance, Opt_check_integrity,
  	Opt_check_integrity_including_extent_data,

  	Opt_check_integrity_print_mask, Opt_fatal_errors, Opt_rescan_uuid_tree,

  	Opt_commit_interval, Opt_barrier, Opt_nodefrag, Opt_nodiscard,

  	Opt_noenospc_debug, Opt_noflushoncommit, Opt_acl, Opt_datacow,

  	Opt_datasum, Opt_treelog, Opt_noinode_cache, Opt_usebackuproot,

  	Opt_nologreplay, Opt_norecovery,

  #ifdef CONFIG_BTRFS_DEBUG
  	Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all,
  #endif

  	Opt_err,

  };

  static const match_table_t tokens = {

  	{Opt_degraded, "degraded"},

  	{Opt_subvol, "subvol=%s"},

  	{Opt_subvolid, "subvolid=%s"},

  	{Opt_device, "device=%s"},

  	{Opt_nodatasum, "nodatasum"},

  	{Opt_datasum, "datasum"},

  	{Opt_nodatacow, "nodatacow"},

  	{Opt_datacow, "datacow"},

  	{Opt_nobarrier, "nobarrier"},

  	{Opt_barrier, "barrier"},

  	{Opt_max_inline, "max_inline=%s"},

  	{Opt_alloc_start, "alloc_start=%s"},

  	{Opt_thread_pool, "thread_pool=%d"},

  	{Opt_compress, "compress"},

  	{Opt_compress_type, "compress=%s"},

  	{Opt_compress_force, "compress-force"},

  	{Opt_compress_force_type, "compress-force=%s"},

  	{Opt_ssd, "ssd"},

  	{Opt_ssd_spread, "ssd_spread"},

  	{Opt_nossd, "nossd"},

  	{Opt_acl, "acl"},

  	{Opt_noacl, "noacl"},

  	{Opt_notreelog, "notreelog"},

  	{Opt_treelog, "treelog"},

  	{Opt_nologreplay, "nologreplay"},

  	{Opt_norecovery, "norecovery"},

  	{Opt_flushoncommit, "flushoncommit"},

  	{Opt_noflushoncommit, "noflushoncommit"},

  	{Opt_ratio, "metadata_ratio=%d"},

  	{Opt_discard, "discard"},

  	{Opt_nodiscard, "nodiscard"},

  	{Opt_space_cache, "space_cache"},

  	{Opt_space_cache_version, "space_cache=%s"},

  	{Opt_clear_cache, "clear_cache"},

  	{Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},

  	{Opt_enospc_debug, "enospc_debug"},

  	{Opt_noenospc_debug, "noenospc_debug"},

  	{Opt_subvolrootid, "subvolrootid=%d"},

  	{Opt_defrag, "autodefrag"},

  	{Opt_nodefrag, "noautodefrag"},

  	{Opt_inode_cache, "inode_cache"},

  	{Opt_noinode_cache, "noinode_cache"},

  	{Opt_no_space_cache, "nospace_cache"},

  	{Opt_recovery, "recovery"}, /* deprecated */
  	{Opt_usebackuproot, "usebackuproot"},

  	{Opt_skip_balance, "skip_balance"},

  	{Opt_check_integrity, "check_int"},
  	{Opt_check_integrity_including_extent_data, "check_int_data"},
  	{Opt_check_integrity_print_mask, "check_int_print_mask=%d"},

  	{Opt_rescan_uuid_tree, "rescan_uuid_tree"},

  	{Opt_fatal_errors, "fatal_errors=%s"},

  	{Opt_commit_interval, "commit=%d"},

  #ifdef CONFIG_BTRFS_DEBUG
  	{Opt_fragment_data, "fragment=data"},
  	{Opt_fragment_metadata, "fragment=metadata"},
  	{Opt_fragment_all, "fragment=all"},
  #endif

  	{Opt_err, NULL},

  };

  /*
   * Regular mount options parser.  Everything that is needed only when
   * reading in a new superblock is parsed here.

   * XXX JDM: This needs to be cleaned up for remount.

   */

  int btrfs_parse_options(struct btrfs_root *root, char *options,
  			unsigned long new_flags)

  {

  	struct btrfs_fs_info *info = root->fs_info;

  	substring_t args[MAX_OPT_ARGS];

  	char *p, *num, *orig = NULL;
  	u64 cache_gen;

  	int intarg;

  	int ret = 0;

  	char *compress_type;
  	bool compress_force = false;

  	enum btrfs_compression_type saved_compress_type;
  	bool saved_compress_force;
  	int no_compress = 0;

  	cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);

  	if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE))
  		btrfs_set_opt(info->mount_opt, FREE_SPACE_TREE);
  	else if (cache_gen)

  		btrfs_set_opt(info->mount_opt, SPACE_CACHE);

  	/*
  	 * Even the options are empty, we still need to do extra check
  	 * against new flags
  	 */

  	if (!options)

  		goto check;

  	/*
  	 * strsep changes the string, duplicate it because parse_options
  	 * gets called twice
  	 */
  	options = kstrdup(options, GFP_NOFS);
  	if (!options)
  		return -ENOMEM;

  	orig = options;

  	while ((p = strsep(&options, ",")) != NULL) {

  		int token;
  		if (!*p)
  			continue;
  
  		token = match_token(p, tokens, args);
  		switch (token) {

  		case Opt_degraded:

  			btrfs_info(root->fs_info, "allowing degraded mounts");

  			btrfs_set_opt(info->mount_opt, DEGRADED);

  			break;

  		case Opt_subvol:

  		case Opt_subvolid:

  		case Opt_subvolrootid:

  		case Opt_device:

  			/*

  			 * These are parsed by btrfs_parse_early_options

  			 * and can be happily ignored here.
  			 */

  			break;
  		case Opt_nodatasum:

  			btrfs_set_and_info(info, NODATASUM,

  					   "setting nodatasum");

  			break;

  		case Opt_datasum:

  			if (btrfs_test_opt(info, NODATASUM)) {
  				if (btrfs_test_opt(info, NODATACOW))

  					btrfs_info(root->fs_info,
  						   "setting datasum, datacow enabled");

  				else

  					btrfs_info(root->fs_info,
  						   "setting datasum");

  			}

  			btrfs_clear_opt(info->mount_opt, NODATACOW);
  			btrfs_clear_opt(info->mount_opt, NODATASUM);
  			break;

  		case Opt_nodatacow:

  			if (!btrfs_test_opt(info, NODATACOW)) {
  				if (!btrfs_test_opt(info, COMPRESS) ||
  				    !btrfs_test_opt(info, FORCE_COMPRESS)) {

  					btrfs_info(root->fs_info,

  						   "setting nodatacow, compression disabled");
  				} else {

  					btrfs_info(root->fs_info,
  						   "setting nodatacow");

  				}

  			}

  			btrfs_clear_opt(info->mount_opt, COMPRESS);
  			btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);

  			btrfs_set_opt(info->mount_opt, NODATACOW);
  			btrfs_set_opt(info->mount_opt, NODATASUM);

  			break;

  		case Opt_datacow:

  			btrfs_clear_and_info(info, NODATACOW,

  					     "setting datacow");

  			break;

  		case Opt_compress_force:

  		case Opt_compress_force_type:
  			compress_force = true;

  			/* Fallthrough */

  		case Opt_compress:
  		case Opt_compress_type:

  			saved_compress_type = btrfs_test_opt(info,
  							     COMPRESS) ?

  				info->compress_type : BTRFS_COMPRESS_NONE;
  			saved_compress_force =

  				btrfs_test_opt(info, FORCE_COMPRESS);

  			if (token == Opt_compress ||
  			    token == Opt_compress_force ||
  			    strcmp(args[0].from, "zlib") == 0) {
  				compress_type = "zlib";
  				info->compress_type = BTRFS_COMPRESS_ZLIB;

  				btrfs_set_opt(info->mount_opt, COMPRESS);

  				btrfs_clear_opt(info->mount_opt, NODATACOW);
  				btrfs_clear_opt(info->mount_opt, NODATASUM);

  				no_compress = 0;

  			} else if (strcmp(args[0].from, "lzo") == 0) {
  				compress_type = "lzo";
  				info->compress_type = BTRFS_COMPRESS_LZO;

  				btrfs_set_opt(info->mount_opt, COMPRESS);

  				btrfs_clear_opt(info->mount_opt, NODATACOW);
  				btrfs_clear_opt(info->mount_opt, NODATASUM);

  				btrfs_set_fs_incompat(info, COMPRESS_LZO);

  				no_compress = 0;

  			} else if (strncmp(args[0].from, "no", 2) == 0) {
  				compress_type = "no";

  				btrfs_clear_opt(info->mount_opt, COMPRESS);
  				btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
  				compress_force = false;

  				no_compress++;

  			} else {
  				ret = -EINVAL;
  				goto out;
  			}

  			if (compress_force) {

  				btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);

  			} else {

  				/*
  				 * If we remount from compress-force=xxx to
  				 * compress=xxx, we need clear FORCE_COMPRESS
  				 * flag, otherwise, there is no way for users
  				 * to disable forcible compression separately.
  				 */
  				btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);

  			}

  			if ((btrfs_test_opt(info, COMPRESS) &&

  			     (info->compress_type != saved_compress_type ||
  			      compress_force != saved_compress_force)) ||

  			    (!btrfs_test_opt(info, COMPRESS) &&

  			     no_compress == 1)) {
  				btrfs_info(root->fs_info,
  					   "%s %s compression",
  					   (compress_force) ? "force" : "use",
  					   compress_type);
  			}
  			compress_force = false;

  			break;

  		case Opt_ssd:

  			btrfs_set_and_info(info, SSD,

  					   "use ssd allocation scheme");

  			break;

  		case Opt_ssd_spread:

  			btrfs_set_and_info(info, SSD_SPREAD,

  					   "use spread ssd allocation scheme");

  			btrfs_set_opt(info->mount_opt, SSD);

  			break;

  		case Opt_nossd:

  			btrfs_set_and_info(info, NOSSD,

  					     "not using ssd allocation scheme");

  			btrfs_clear_opt(info->mount_opt, SSD);
  			break;

  		case Opt_barrier:

  			btrfs_clear_and_info(info, NOBARRIER,

  					     "turning on barriers");

  			break;

  		case Opt_nobarrier:

  			btrfs_set_and_info(info, NOBARRIER,

  					   "turning off barriers");

  			break;

  		case Opt_thread_pool:

  			ret = match_int(&args[0], &intarg);
  			if (ret) {
  				goto out;
  			} else if (intarg > 0) {

  				info->thread_pool_size = intarg;

  			} else {
  				ret = -EINVAL;
  				goto out;
  			}

  			break;

  		case Opt_max_inline:

  			num = match_strdup(&args[0]);
  			if (num) {

  				info->max_inline = memparse(num, NULL);

  				kfree(num);

  				if (info->max_inline) {

  					info->max_inline = min_t(u64,

  						info->max_inline,
  						root->sectorsize);
  				}

  				btrfs_info(root->fs_info, "max_inline at %llu",

  					info->max_inline);

  			} else {
  				ret = -ENOMEM;
  				goto out;

  			}
  			break;

  		case Opt_alloc_start:

  			num = match_strdup(&args[0]);
  			if (num) {

  				mutex_lock(&info->chunk_mutex);

  				info->alloc_start = memparse(num, NULL);

  				mutex_unlock(&info->chunk_mutex);

  				kfree(num);

  				btrfs_info(root->fs_info,
  					   "allocations start at %llu",
  					   info->alloc_start);

  			} else {
  				ret = -ENOMEM;
  				goto out;

  			}
  			break;

  		case Opt_acl:

  #ifdef CONFIG_BTRFS_FS_POSIX_ACL

  			root->fs_info->sb->s_flags |= MS_POSIXACL;
  			break;

  #else
  			btrfs_err(root->fs_info,
  				"support for ACL not compiled in!");
  			ret = -EINVAL;
  			goto out;
  #endif

  		case Opt_noacl:
  			root->fs_info->sb->s_flags &= ~MS_POSIXACL;
  			break;

  		case Opt_notreelog:

  			btrfs_set_and_info(info, NOTREELOG,

  					   "disabling tree log");

  			break;
  		case Opt_treelog:

  			btrfs_clear_and_info(info, NOTREELOG,

  					     "enabling tree log");

  			break;

  		case Opt_norecovery:

  		case Opt_nologreplay:

  			btrfs_set_and_info(info, NOLOGREPLAY,

  					   "disabling log replay at mount time");
  			break;

  		case Opt_flushoncommit:

  			btrfs_set_and_info(info, FLUSHONCOMMIT,

  					   "turning on flush-on-commit");

  			break;

  		case Opt_noflushoncommit:

  			btrfs_clear_and_info(info, FLUSHONCOMMIT,

  					     "turning off flush-on-commit");

  			break;

  		case Opt_ratio:

  			ret = match_int(&args[0], &intarg);
  			if (ret) {
  				goto out;
  			} else if (intarg >= 0) {

  				info->metadata_ratio = intarg;

  				btrfs_info(root->fs_info, "metadata ratio %d",

  				       info->metadata_ratio);

  			} else {
  				ret = -EINVAL;
  				goto out;

  			}
  			break;

  		case Opt_discard:

  			btrfs_set_and_info(info, DISCARD,

  					   "turning on discard");

  			break;

  		case Opt_nodiscard:

  			btrfs_clear_and_info(info, DISCARD,

  					     "turning off discard");

  			break;

  		case Opt_space_cache:

  		case Opt_space_cache_version:
  			if (token == Opt_space_cache ||
  			    strcmp(args[0].from, "v1") == 0) {
  				btrfs_clear_opt(root->fs_info->mount_opt,
  						FREE_SPACE_TREE);

  				btrfs_set_and_info(info, SPACE_CACHE,

  						   "enabling disk space caching");
  			} else if (strcmp(args[0].from, "v2") == 0) {
  				btrfs_clear_opt(root->fs_info->mount_opt,
  						SPACE_CACHE);

  				btrfs_set_and_info(info,
  						   FREE_SPACE_TREE,

  						   "enabling free space tree");
  			} else {
  				ret = -EINVAL;
  				goto out;
  			}

  			break;

  		case Opt_rescan_uuid_tree:
  			btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
  			break;

  		case Opt_no_space_cache:

  			if (btrfs_test_opt(info, SPACE_CACHE)) {
  				btrfs_clear_and_info(info,
  						     SPACE_CACHE,

  						     "disabling disk space caching");
  			}

  			if (btrfs_test_opt(info, FREE_SPACE_TREE)) {
  				btrfs_clear_and_info(info,
  						     FREE_SPACE_TREE,

  						     "disabling free space tree");
  			}

  			break;

  		case Opt_inode_cache:

  			btrfs_set_pending_and_info(info, INODE_MAP_CACHE,

  					   "enabling inode map caching");

  			break;
  		case Opt_noinode_cache:

  			btrfs_clear_pending_and_info(info, INODE_MAP_CACHE,

  					     "disabling inode map caching");

  			break;

  		case Opt_clear_cache:

  			btrfs_set_and_info(info, CLEAR_CACHE,

  					   "force clearing of disk cache");

  			break;

  		case Opt_user_subvol_rm_allowed:
  			btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
  			break;

  		case Opt_enospc_debug:
  			btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
  			break;

  		case Opt_noenospc_debug:
  			btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
  			break;

  		case Opt_defrag:

  			btrfs_set_and_info(info, AUTO_DEFRAG,

  					   "enabling auto defrag");

  			break;

  		case Opt_nodefrag:

  			btrfs_clear_and_info(info, AUTO_DEFRAG,

  					     "disabling auto defrag");

  			break;

  		case Opt_recovery:

  			btrfs_warn(root->fs_info,
  				   "'recovery' is deprecated, use 'usebackuproot' instead");
  		case Opt_usebackuproot:
  			btrfs_info(root->fs_info,
  				   "trying to use backup root at mount time");
  			btrfs_set_opt(info->mount_opt, USEBACKUPROOT);

  			break;

  		case Opt_skip_balance:
  			btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
  			break;

  #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
  		case Opt_check_integrity_including_extent_data:

  			btrfs_info(root->fs_info,
  				   "enabling check integrity including extent data");

  			btrfs_set_opt(info->mount_opt,
  				      CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
  			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
  			break;
  		case Opt_check_integrity:

  			btrfs_info(root->fs_info, "enabling check integrity");

  			btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
  			break;
  		case Opt_check_integrity_print_mask:

  			ret = match_int(&args[0], &intarg);
  			if (ret) {
  				goto out;
  			} else if (intarg >= 0) {

  				info->check_integrity_print_mask = intarg;

  				btrfs_info(root->fs_info,
  					   "check_integrity_print_mask 0x%x",
  					   info->check_integrity_print_mask);

  			} else {
  				ret = -EINVAL;
  				goto out;

  			}
  			break;
  #else
  		case Opt_check_integrity_including_extent_data:
  		case Opt_check_integrity:
  		case Opt_check_integrity_print_mask:

  			btrfs_err(root->fs_info,
  				"support for check_integrity* not compiled in!");

  			ret = -EINVAL;
  			goto out;
  #endif

  		case Opt_fatal_errors:
  			if (strcmp(args[0].from, "panic") == 0)
  				btrfs_set_opt(info->mount_opt,
  					      PANIC_ON_FATAL_ERROR);
  			else if (strcmp(args[0].from, "bug") == 0)
  				btrfs_clear_opt(info->mount_opt,
  					      PANIC_ON_FATAL_ERROR);
  			else {
  				ret = -EINVAL;
  				goto out;
  			}
  			break;

  		case Opt_commit_interval:
  			intarg = 0;
  			ret = match_int(&args[0], &intarg);
  			if (ret < 0) {

  				btrfs_err(root->fs_info,
  					  "invalid commit interval");

  				ret = -EINVAL;
  				goto out;
  			}
  			if (intarg > 0) {
  				if (intarg > 300) {

  					btrfs_warn(root->fs_info,
  						"excessive commit interval %d",
  						intarg);

  				}
  				info->commit_interval = intarg;
  			} else {

  				btrfs_info(root->fs_info,
  					   "using default commit interval %ds",
  					   BTRFS_DEFAULT_COMMIT_INTERVAL);

  				info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
  			}
  			break;

  #ifdef CONFIG_BTRFS_DEBUG
  		case Opt_fragment_all:
  			btrfs_info(root->fs_info, "fragmenting all space");
  			btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
  			btrfs_set_opt(info->mount_opt, FRAGMENT_METADATA);
  			break;
  		case Opt_fragment_metadata:
  			btrfs_info(root->fs_info, "fragmenting metadata");
  			btrfs_set_opt(info->mount_opt,
  				      FRAGMENT_METADATA);
  			break;
  		case Opt_fragment_data:
  			btrfs_info(root->fs_info, "fragmenting data");
  			btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
  			break;
  #endif

  		case Opt_err:

  			btrfs_info(root->fs_info,
  				   "unrecognized mount option '%s'", p);

  			ret = -EINVAL;
  			goto out;

  		default:

  			break;

  		}
  	}

  check:
  	/*
  	 * Extra check for current option against current flag
  	 */

  	if (btrfs_test_opt(info, NOLOGREPLAY) && !(new_flags & MS_RDONLY)) {

  		btrfs_err(root->fs_info,
  			  "nologreplay must be used with ro mount option");
  		ret = -EINVAL;
  	}

  out:

  	if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE) &&

  	    !btrfs_test_opt(info, FREE_SPACE_TREE) &&
  	    !btrfs_test_opt(info, CLEAR_CACHE)) {

  		btrfs_err(root->fs_info, "cannot disable free space tree");
  		ret = -EINVAL;
  
  	}

  	if (!ret && btrfs_test_opt(info, SPACE_CACHE))

  		btrfs_info(root->fs_info, "disk space caching is enabled");

  	if (!ret && btrfs_test_opt(info, FREE_SPACE_TREE))

  		btrfs_info(root->fs_info, "using free space tree");

  	kfree(orig);

  	return ret;

  }
  
  /*
   * Parse mount options that are required early in the mount process.
   *
   * All other options will be parsed on much later in the mount process and
   * only when we need to allocate a new super block.
   */

  static int btrfs_parse_early_options(const char *options, fmode_t flags,

  		void *holder, char **subvol_name, u64 *subvol_objectid,

  		struct btrfs_fs_devices **fs_devices)

  {
  	substring_t args[MAX_OPT_ARGS];

  	char *device_name, *opts, *orig, *p;

  	char *num = NULL;

  	int error = 0;
  
  	if (!options)

  		return 0;

  
  	/*
  	 * strsep changes the string, duplicate it because parse_options
  	 * gets called twice
  	 */
  	opts = kstrdup(options, GFP_KERNEL);
  	if (!opts)
  		return -ENOMEM;

  	orig = opts;

  
  	while ((p = strsep(&opts, ",")) != NULL) {
  		int token;
  		if (!*p)
  			continue;
  
  		token = match_token(p, tokens, args);
  		switch (token) {
  		case Opt_subvol:

  			kfree(*subvol_name);

  			*subvol_name = match_strdup(&args[0]);

  			if (!*subvol_name) {
  				error = -ENOMEM;
  				goto out;
  			}

  			break;

  		case Opt_subvolid:

  			num = match_strdup(&args[0]);
  			if (num) {
  				*subvol_objectid = memparse(num, NULL);
  				kfree(num);

  				/* we want the original fs_tree */

  				if (!*subvol_objectid)

  					*subvol_objectid =
  						BTRFS_FS_TREE_OBJECTID;

  			} else {
  				error = -EINVAL;
  				goto out;

  			}

  			break;

  		case Opt_subvolrootid:

  			pr_warn("BTRFS: 'subvolrootid' mount option is deprecated and has no effect
  ");

  			break;

  		case Opt_device:

  			device_name = match_strdup(&args[0]);
  			if (!device_name) {
  				error = -ENOMEM;
  				goto out;
  			}
  			error = btrfs_scan_one_device(device_name,

  					flags, holder, fs_devices);

  			kfree(device_name);

  			if (error)

  				goto out;

  			break;

  		default:
  			break;
  		}
  	}

  out:

  	kfree(orig);

  	return error;

  }

  static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
  					   u64 subvol_objectid)

  {

  	struct btrfs_root *root = fs_info->tree_root;

  	struct btrfs_root *fs_root;
  	struct btrfs_root_ref *root_ref;
  	struct btrfs_inode_ref *inode_ref;
  	struct btrfs_key key;
  	struct btrfs_path *path = NULL;
  	char *name = NULL, *ptr;
  	u64 dirid;
  	int len;
  	int ret;
  
  	path = btrfs_alloc_path();
  	if (!path) {
  		ret = -ENOMEM;
  		goto err;
  	}
  	path->leave_spinning = 1;
  
  	name = kmalloc(PATH_MAX, GFP_NOFS);
  	if (!name) {
  		ret = -ENOMEM;
  		goto err;
  	}
  	ptr = name + PATH_MAX - 1;
  	ptr[0] = '\0';

  
  	/*

  	 * Walk up the subvolume trees in the tree of tree roots by root
  	 * backrefs until we hit the top-level subvolume.

  	 */

  	while (subvol_objectid != BTRFS_FS_TREE_OBJECTID) {
  		key.objectid = subvol_objectid;
  		key.type = BTRFS_ROOT_BACKREF_KEY;
  		key.offset = (u64)-1;
  
  		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
  		if (ret < 0) {
  			goto err;
  		} else if (ret > 0) {
  			ret = btrfs_previous_item(root, path, subvol_objectid,
  						  BTRFS_ROOT_BACKREF_KEY);
  			if (ret < 0) {
  				goto err;
  			} else if (ret > 0) {
  				ret = -ENOENT;
  				goto err;
  			}
  		}
  
  		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
  		subvol_objectid = key.offset;
  
  		root_ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
  					  struct btrfs_root_ref);
  		len = btrfs_root_ref_name_len(path->nodes[0], root_ref);
  		ptr -= len + 1;
  		if (ptr < name) {
  			ret = -ENAMETOOLONG;
  			goto err;
  		}
  		read_extent_buffer(path->nodes[0], ptr + 1,
  				   (unsigned long)(root_ref + 1), len);
  		ptr[0] = '/';
  		dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref);
  		btrfs_release_path(path);
  
  		key.objectid = subvol_objectid;
  		key.type = BTRFS_ROOT_ITEM_KEY;
  		key.offset = (u64)-1;
  		fs_root = btrfs_read_fs_root_no_name(fs_info, &key);
  		if (IS_ERR(fs_root)) {
  			ret = PTR_ERR(fs_root);
  			goto err;
  		}
  
  		/*
  		 * Walk up the filesystem tree by inode refs until we hit the
  		 * root directory.
  		 */
  		while (dirid != BTRFS_FIRST_FREE_OBJECTID) {
  			key.objectid = dirid;
  			key.type = BTRFS_INODE_REF_KEY;
  			key.offset = (u64)-1;
  
  			ret = btrfs_search_slot(NULL, fs_root, &key, path, 0, 0);
  			if (ret < 0) {
  				goto err;
  			} else if (ret > 0) {
  				ret = btrfs_previous_item(fs_root, path, dirid,
  							  BTRFS_INODE_REF_KEY);
  				if (ret < 0) {
  					goto err;
  				} else if (ret > 0) {
  					ret = -ENOENT;
  					goto err;
  				}
  			}
  
  			btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
  			dirid = key.offset;
  
  			inode_ref = btrfs_item_ptr(path->nodes[0],
  						   path->slots[0],
  						   struct btrfs_inode_ref);
  			len = btrfs_inode_ref_name_len(path->nodes[0],
  						       inode_ref);
  			ptr -= len + 1;
  			if (ptr < name) {
  				ret = -ENAMETOOLONG;
  				goto err;
  			}
  			read_extent_buffer(path->nodes[0], ptr + 1,
  					   (unsigned long)(inode_ref + 1), len);
  			ptr[0] = '/';
  			btrfs_release_path(path);
  		}

  	}

  	btrfs_free_path(path);
  	if (ptr == name + PATH_MAX - 1) {
  		name[0] = '/';
  		name[1] = '\0';
  	} else {
  		memmove(name, ptr, name + PATH_MAX - ptr);
  	}
  	return name;
  
  err:
  	btrfs_free_path(path);
  	kfree(name);
  	return ERR_PTR(ret);
  }
  
  static int get_default_subvol_objectid(struct btrfs_fs_info *fs_info, u64 *objectid)
  {
  	struct btrfs_root *root = fs_info->tree_root;
  	struct btrfs_dir_item *di;
  	struct btrfs_path *path;
  	struct btrfs_key location;
  	u64 dir_id;

  	path = btrfs_alloc_path();
  	if (!path)

  		return -ENOMEM;

  	path->leave_spinning = 1;
  
  	/*
  	 * Find the "default" dir item which points to the root item that we
  	 * will mount by default if we haven't been given a specific subvolume
  	 * to mount.
  	 */

  	dir_id = btrfs_super_root_dir(fs_info->super_copy);

  	di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);

  	if (IS_ERR(di)) {
  		btrfs_free_path(path);

  		return PTR_ERR(di);

  	}

  	if (!di) {
  		/*
  		 * Ok the default dir item isn't there.  This is weird since
  		 * it's always been there, but don't freak out, just try and

  		 * mount the top-level subvolume.

  		 */
  		btrfs_free_path(path);

  		*objectid = BTRFS_FS_TREE_OBJECTID;
  		return 0;

  	}
  
  	btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
  	btrfs_free_path(path);

  	*objectid = location.objectid;
  	return 0;

  }

  static int btrfs_fill_super(struct super_block *sb,

  			    struct btrfs_fs_devices *fs_devices,

  			    void *data, int silent)

  {

  	struct inode *inode;

  	struct btrfs_fs_info *fs_info = btrfs_sb(sb);

  	struct btrfs_key key;

  	int err;

  	sb->s_maxbytes = MAX_LFS_FILESIZE;
  	sb->s_magic = BTRFS_SUPER_MAGIC;
  	sb->s_op = &btrfs_super_ops;

  	sb->s_d_op = &btrfs_dentry_operations;

  	sb->s_export_op = &btrfs_export_ops;

  	sb->s_xattr = btrfs_xattr_handlers;

  	sb->s_time_gran = 1;

  #ifdef CONFIG_BTRFS_FS_POSIX_ACL

  	sb->s_flags |= MS_POSIXACL;

  #endif

  	sb->s_flags |= MS_I_VERSION;

  	sb->s_iflags |= SB_I_CGROUPWB;

  	err = open_ctree(sb, fs_devices, (char *)data);
  	if (err) {

  		btrfs_err(fs_info, "open_ctree failed");

  		return err;

  	}

  	key.objectid = BTRFS_FIRST_FREE_OBJECTID;
  	key.type = BTRFS_INODE_ITEM_KEY;
  	key.offset = 0;

  	inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);

  	if (IS_ERR(inode)) {
  		err = PTR_ERR(inode);

  		goto fail_close;

  	}

  	sb->s_root = d_make_root(inode);
  	if (!sb->s_root) {

  		err = -ENOMEM;
  		goto fail_close;

  	}

  	save_mount_options(sb, data);

  	cleancache_init_fs(sb);

  	sb->s_flags |= MS_ACTIVE;

  	return 0;

  
  fail_close:

  	close_ctree(fs_info->tree_root);

  	return err;

  }

  int btrfs_sync_fs(struct super_block *sb, int wait)

  {
  	struct btrfs_trans_handle *trans;

  	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
  	struct btrfs_root *root = fs_info->tree_root;

  	trace_btrfs_sync_fs(fs_info, wait);

  	if (!wait) {

  		filemap_flush(fs_info->btree_inode->i_mapping);

  		return 0;
  	}

  	btrfs_wait_ordered_roots(fs_info, -1, 0, (u64)-1);

  	trans = btrfs_attach_transaction_barrier(root);

  	if (IS_ERR(trans)) {

  		/* no transaction, don't bother */

  		if (PTR_ERR(trans) == -ENOENT) {
  			/*
  			 * Exit unless we have some pending changes
  			 * that need to go through commit
  			 */
  			if (fs_info->pending_changes == 0)
  				return 0;

  			/*
  			 * A non-blocking test if the fs is frozen. We must not
  			 * start a new transaction here otherwise a deadlock
  			 * happens. The pending operations are delayed to the
  			 * next commit after thawing.
  			 */
  			if (__sb_start_write(sb, SB_FREEZE_WRITE, false))
  				__sb_end_write(sb, SB_FREEZE_WRITE);
  			else
  				return 0;

  			trans = btrfs_start_transaction(root, 0);

  		}

  		if (IS_ERR(trans))
  			return PTR_ERR(trans);

  	}

  	return btrfs_commit_transaction(trans, root);

  }

  static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)

  {

  	struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
  	struct btrfs_root *root = info->tree_root;

  	char *compress_type;

  	if (btrfs_test_opt(info, DEGRADED))

  		seq_puts(seq, ",degraded");

  	if (btrfs_test_opt(info, NODATASUM))

  		seq_puts(seq, ",nodatasum");

  	if (btrfs_test_opt(info, NODATACOW))

  		seq_puts(seq, ",nodatacow");

  	if (btrfs_test_opt(info, NOBARRIER))

  		seq_puts(seq, ",nobarrier");

  	if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE)

  		seq_printf(seq, ",max_inline=%llu", info->max_inline);

  	if (info->alloc_start != 0)

  		seq_printf(seq, ",alloc_start=%llu", info->alloc_start);

  	if (info->thread_pool_size !=  min_t(unsigned long,
  					     num_online_cpus() + 2, 8))
  		seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);

  	if (btrfs_test_opt(info, COMPRESS)) {

  		if (info->compress_type == BTRFS_COMPRESS_ZLIB)
  			compress_type = "zlib";
  		else
  			compress_type = "lzo";

  		if (btrfs_test_opt(info, FORCE_COMPRESS))

  			seq_printf(seq, ",compress-force=%s", compress_type);
  		else
  			seq_printf(seq, ",compress=%s", compress_type);
  	}

  	if (btrfs_test_opt(info, NOSSD))

  		seq_puts(seq, ",nossd");

  	if (btrfs_test_opt(info, SSD_SPREAD))

  		seq_puts(seq, ",ssd_spread");

  	else if (btrfs_test_opt(info, SSD))

  		seq_puts(seq, ",ssd");

  	if (btrfs_test_opt(info, NOTREELOG))

  		seq_puts(seq, ",notreelog");

  	if (btrfs_test_opt(info, NOLOGREPLAY))

  		seq_puts(seq, ",nologreplay");

  	if (btrfs_test_opt(info, FLUSHONCOMMIT))

  		seq_puts(seq, ",flushoncommit");

  	if (btrfs_test_opt(info, DISCARD))

  		seq_puts(seq, ",discard");

  	if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
  		seq_puts(seq, ",noacl");

  	if (btrfs_test_opt(info, SPACE_CACHE))

  		seq_puts(seq, ",space_cache");

  	else if (btrfs_test_opt(info, FREE_SPACE_TREE))

  		seq_puts(seq, ",space_cache=v2");

  	else

  		seq_puts(seq, ",nospace_cache");

  	if (btrfs_test_opt(info, RESCAN_UUID_TREE))

  		seq_puts(seq, ",rescan_uuid_tree");

  	if (btrfs_test_opt(info, CLEAR_CACHE))

  		seq_puts(seq, ",clear_cache");

  	if (btrfs_test_opt(info, USER_SUBVOL_RM_ALLOWED))

  		seq_puts(seq, ",user_subvol_rm_allowed");

  	if (btrfs_test_opt(info, ENOSPC_DEBUG))

  		seq_puts(seq, ",enospc_debug");

  	if (btrfs_test_opt(info, AUTO_DEFRAG))

  		seq_puts(seq, ",autodefrag");

  	if (btrfs_test_opt(info, INODE_MAP_CACHE))

  		seq_puts(seq, ",inode_cache");

  	if (btrfs_test_opt(info, SKIP_BALANCE))

  		seq_puts(seq, ",skip_balance");

  #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY

  	if (btrfs_test_opt(info, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA))

  		seq_puts(seq, ",check_int_data");

  	else if (btrfs_test_opt(info, CHECK_INTEGRITY))

  		seq_puts(seq, ",check_int");
  	if (info->check_integrity_print_mask)
  		seq_printf(seq, ",check_int_print_mask=%d",
  				info->check_integrity_print_mask);
  #endif
  	if (info->metadata_ratio)
  		seq_printf(seq, ",metadata_ratio=%d",
  				info->metadata_ratio);

  	if (btrfs_test_opt(info, PANIC_ON_FATAL_ERROR))

  		seq_puts(seq, ",fatal_errors=panic");