Merge tag 'for-chris' of...

  notreelog

	Enable/disable the tree logging used for fsync and O_SYNC writes.

  recovery

	Enable autorecovery attempts if a bad tree root is found at mount time.

	Currently this scans a list of several previous tree roots and tries to

  nologreplay

	Disable the log tree replay at mount time to prevent filesystem

	from getting modified.

	Must be used with 'ro' mount option.

	A filesystem mounted with this option cannot transition to a

	read-write mount via remount,rw - the filesystem must be unmounted

	and mounted back again if read-write access is desired.

  usebackuproot

	Enable attempts to use backup tree roots if a bad tree root is found at

	mount time.

	Currently this scans a list of 4 previous tree roots and tries to

	use the first readable.

	And since the mount option doesn't affect any behavior after mount,

	it won't be shown in mount info.

	Prior to 4.6, this was done by 'recovery' option that has been

	deprecated, but will work.

  rescan_uuid_tree

	Force check and rebuild procedure of the UUID tree. This should not

void btrfs_prelim_ref_exit(void)

{

	if (btrfs_prelim_ref_cache)

	kmem_cache_destroy(btrfs_prelim_ref_cache);

}

		struct __prelim_ref *pos2 = pos1, *tmp;

		list_for_each_entry_safe_continue(pos2, tmp, head, list) {

			struct __prelim_ref *xchg, *ref1 = pos1, *ref2 = pos2;

			struct __prelim_ref *ref1 = pos1, *ref2 = pos2;

			struct extent_inode_elem *eie;

			if (!ref_for_same_block(ref1, ref2))

				continue;

			if (mode == 1) {

				if (!ref1->parent && ref2->parent) {

					xchg = ref1;

					ref1 = ref2;

					ref2 = xchg;

				}

				if (!ref1->parent && ref2->parent)

					swap(ref1, ref2);

			} else {

				if (ref1->parent != ref2->parent)

					continue;

struct tree_mod_elem {

	struct rb_node node;

	u64 index;		/* shifted logical */

	u64 logical;

	u64 seq;

	enum mod_log_op op;

/*

 * key order of the log:

 *       index -> sequence

 *       node/leaf start address -> sequence

 *

 * the index is the shifted logical of the *new* root node for root replace

 * operations, or the shifted logical of the affected block for all other

 * operations.

 * The 'start address' is the logical address of the *new* root node

 * for root replace operations, or the logical address of the affected

 * block for all other operations.

 *

 * Note: must be called with write lock (tree_mod_log_write_lock).

 */

	while (*new) {

		cur = container_of(*new, struct tree_mod_elem, node);

		parent = *new;

		if (cur->index < tm->index)

		if (cur->logical < tm->logical)

			new = &((*new)->rb_left);

		else if (cur->index > tm->index)

		else if (cur->logical > tm->logical)

			new = &((*new)->rb_right);

		else if (cur->seq < tm->seq)

			new = &((*new)->rb_left);

	if (!tm)

		return NULL;

	tm->index = eb->start >> PAGE_CACHE_SHIFT;

	tm->logical = eb->start;

	if (op != MOD_LOG_KEY_ADD) {

		btrfs_node_key(eb, &tm->key, slot);

		tm->blockptr = btrfs_node_blockptr(eb, slot);

		goto free_tms;

	}

	tm->index = eb->start >> PAGE_CACHE_SHIFT;

	tm->logical = eb->start;

	tm->slot = src_slot;

	tm->move.dst_slot = dst_slot;

	tm->move.nr_items = nr_items;

		goto free_tms;

	}

	tm->index = new_root->start >> PAGE_CACHE_SHIFT;

	tm->logical = new_root->start;

	tm->old_root.logical = old_root->start;

	tm->old_root.level = btrfs_header_level(old_root);

	tm->generation = btrfs_header_generation(old_root);

	struct rb_node *node;

	struct tree_mod_elem *cur = NULL;

	struct tree_mod_elem *found = NULL;

	u64 index = start >> PAGE_CACHE_SHIFT;

	tree_mod_log_read_lock(fs_info);

	tm_root = &fs_info->tree_mod_log;

	node = tm_root->rb_node;

	while (node) {

		cur = container_of(node, struct tree_mod_elem, node);

		if (cur->index < index) {

		if (cur->logical < start) {

			node = node->rb_left;

		} else if (cur->index > index) {

		} else if (cur->logical > start) {

			node = node->rb_right;

		} else if (cur->seq < min_seq) {

			node = node->rb_left;

		return NULL;

	/*

	 * the very last operation that's logged for a root is the replacement

	 * operation (if it is replaced at all). this has the index of the *new*

	 * root, making it the very first operation that's logged for this root.

	 * the very last operation that's logged for a root is the

	 * replacement operation (if it is replaced at all). this has

	 * the logical address of the *new* root, making it the very

	 * first operation that's logged for this root.

	 */

	while (1) {

		tm = tree_mod_log_search_oldest(fs_info, root_logical,

		if (!next)

			break;

		tm = container_of(next, struct tree_mod_elem, node);

		if (tm->index != first_tm->index)

		if (tm->logical != first_tm->logical)

			break;

	}

	tree_mod_log_read_unlock(fs_info);

		goto out;

	}

	tmp_buf = kmalloc(left_root->nodesize, GFP_NOFS);

	tmp_buf = kmalloc(left_root->nodesize, GFP_KERNEL);

	if (!tmp_buf) {

		ret = -ENOMEM;

		goto out;

/* tracks free space in block groups. */

#define BTRFS_FREE_SPACE_TREE_OBJECTID 10ULL

/* device stats in the device tree */

#define BTRFS_DEV_STATS_OBJECTID 0ULL

/* for storing balance parameters in the root tree */

#define BTRFS_BALANCE_OBJECTID -4ULL

	pid_t lock_owner;

	atomic_t nesting_level;

	struct mutex lock_finishing_cancel_unmount;

	struct mutex lock_management_lock;

	struct mutex lock;

	rwlock_t lock;

	atomic_t read_locks;

	atomic_t blocking_readers;

	wait_queue_head_t read_lock_wq;

	struct btrfs_scrub_progress scrub_progress;

};

	spinlock_t reada_lock;

	struct radix_tree_root reada_tree;

	/* readahead works cnt */

	atomic_t reada_works_cnt;

	/* Extent buffer radix tree */

	spinlock_t buffer_lock;

	struct radix_tree_root buffer_radix;

 */

#define BTRFS_QGROUP_RELATION_KEY       246

/*

 * Obsolete name, see BTRFS_TEMPORARY_ITEM_KEY.

 */

#define BTRFS_BALANCE_ITEM_KEY	248

/*

 * Persistantly stores the io stats in the device tree.

 * One key for all stats, (0, BTRFS_DEV_STATS_KEY, devid).

 * The key type for tree items that are stored persistently, but do not need to

 * exist for extended period of time. The items can exist in any tree.

 *

 * [subtype, BTRFS_TEMPORARY_ITEM_KEY, data]

 *

 * Existing items:

 *

 * - balance status item

 *   (BTRFS_BALANCE_OBJECTID, BTRFS_TEMPORARY_ITEM_KEY, 0)

 */

#define BTRFS_TEMPORARY_ITEM_KEY	248

/*

 * Obsolete name, see BTRFS_PERSISTENT_ITEM_KEY

 */

#define BTRFS_DEV_STATS_KEY		249

/*

 * The key type for tree items that are stored persistently and usually exist

 * for a long period, eg. filesystem lifetime. The item kinds can be status

 * information, stats or preference values. The item can exist in any tree.

 *

 * [subtype, BTRFS_PERSISTENT_ITEM_KEY, data]

 *

 * Existing items:

 *

 * - device statistics, store IO stats in the device tree, one key for all

 *   stats

 *   (BTRFS_DEV_STATS_OBJECTID, BTRFS_DEV_STATS_KEY, 0)

 */

#define BTRFS_PERSISTENT_ITEM_KEY	249

/*

 * Persistantly stores the device replace state in the device tree.

 * The key is built like this: (0, BTRFS_DEV_REPLACE_KEY, 0).

#define BTRFS_MOUNT_ENOSPC_DEBUG	 (1 << 15)

#define BTRFS_MOUNT_AUTO_DEFRAG		(1 << 16)

#define BTRFS_MOUNT_INODE_MAP_CACHE	(1 << 17)

#define BTRFS_MOUNT_RECOVERY		(1 << 18)

#define BTRFS_MOUNT_USEBACKUPROOT	(1 << 18)

#define BTRFS_MOUNT_SKIP_BALANCE	(1 << 19)

#define BTRFS_MOUNT_CHECK_INTEGRITY	(1 << 20)

#define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21)

#define BTRFS_MOUNT_FRAGMENT_DATA	(1 << 24)

#define BTRFS_MOUNT_FRAGMENT_METADATA	(1 << 25)

#define BTRFS_MOUNT_FREE_SPACE_TREE	(1 << 26)

#define BTRFS_MOUNT_NOLOGREPLAY		(1 << 27)

#define BTRFS_DEFAULT_COMMIT_INTERVAL	(30)

#define BTRFS_DEFAULT_MAX_INLINE	(8192)

#define BTRFS_DEFAULT_MAX_INLINE	(2048)

#define btrfs_clear_opt(o, opt)		((o) &= ~BTRFS_MOUNT_##opt)

#define btrfs_set_opt(o, opt)		((o) |= BTRFS_MOUNT_##opt)

	unsigned long offset;

};

#define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \

				((bytes) >> (fs_info)->sb->s_blocksize_bits)

static inline void btrfs_init_map_token (struct btrfs_map_token *token)

{

	token->kaddr = NULL;

static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root,

						 unsigned num_items)

{

	return (root->nodesize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *

		2 * num_items;

	return root->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;

}

/*

			struct btrfs_root *root,

			struct inode *dir, u64 objectid,

			const char *name, int name_len);

int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,

int btrfs_truncate_block(struct inode *inode, loff_t from, loff_t len,

			int front);

int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,

			       struct btrfs_root *root,

/* ioctl.c */

long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

int btrfs_ioctl_get_supported_features(void __user *arg);

void btrfs_update_iflags(struct inode *inode);

void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);

int btrfs_is_empty_uuid(u8 *uuid);

ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);

/* super.c */

int btrfs_parse_options(struct btrfs_root *root, char *options);

int btrfs_parse_options(struct btrfs_root *root, char *options,

			unsigned long new_flags);

int btrfs_sync_fs(struct super_block *sb, int wait);

#ifdef CONFIG_PRINTK

			      struct btrfs_key *start, struct btrfs_key *end);

int btrfs_reada_wait(void *handle);

void btrfs_reada_detach(void *handle);

int btree_readahead_hook(struct btrfs_root *root, struct extent_buffer *eb,

			 u64 start, int err);

int btree_readahead_hook(struct btrfs_fs_info *fs_info,

			 struct extent_buffer *eb, u64 start, int err);

static inline int is_fstree(u64 rootid)

{

void btrfs_delayed_inode_exit(void)

{

	if (delayed_node_cache)

	kmem_cache_destroy(delayed_node_cache);

}