Commit 043cd049 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus-4.2' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs 

Pull btrfs updates from Chris Mason:
 "Outside of our usual batch of fixes, this integrates the subvolume
  quota updates that Qu Wenruo from Fujitsu has been working on for a
  few releases now.  He gets an extra gold star for making btrfs smaller
  this time, and fixing a number of quota corners in the process.

  Dave Sterba tested and integrated Anand Jain's sysfs improvements.
  Outside of exporting a symbol (ack'd by Greg) these are all internal
  to btrfs and it's mostly cleanups and fixes.  Anand also attached some
  of our sysfs objects to our internal device management structs instead
  of an object off the super block.  It will make device management
  easier overall and it's a better fit for how the sysfs files are used.
  None of the existing sysfs files are moved around.

  Thanks for all the fixes everyone"

* 'for-linus-4.2' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (87 commits)
  btrfs: delayed-ref: double free in btrfs_add_delayed_tree_ref()
  Btrfs: Check if kobject is initialized before put
  lib: export symbol kobject_move()
  Btrfs: sysfs: add support to show replacing target in the sysfs
  Btrfs: free the stale device
  Btrfs: use received_uuid of parent during send
  Btrfs: fix use-after-free in btrfs_replay_log
  btrfs: wait for delayed iputs on no space
  btrfs: qgroup: Make snapshot accounting work with new extent-oriented qgroup.
  btrfs: qgroup: Add the ability to skip given qgroup for old/new_roots.
  btrfs: ulist: Add ulist_del() function.
  btrfs: qgroup: Cleanup the old ref_node-oriented mechanism.
  btrfs: qgroup: Switch self test to extent-oriented qgroup mechanism.
  btrfs: qgroup: Switch to new extent-oriented qgroup mechanism.
  btrfs: qgroup: Switch rescan to new mechanism.
  btrfs: qgroup: Add new qgroup calculation function btrfs_qgroup_account_extents().
  btrfs: backref: Add special time_seq == (u64)-1 case for btrfs_find_all_roots().
  btrfs: qgroup: Add new function to record old_roots.
  btrfs: qgroup: Record possible quota-related extent for qgroup.
  btrfs: qgroup: Add function qgroup_update_counters().
  ...
parents 43baed34 5a5003df

fs/btrfs/async-thread.c

+1 −0
Original line number Diff line number Diff line
@@ -85,6 +85,7 @@ BTRFS_WORK_HELPER(extent_refs_helper); 
BTRFS_WORK_HELPER(scrub_helper);

BTRFS_WORK_HELPER(scrubwrc_helper);

BTRFS_WORK_HELPER(scrubnc_helper);

BTRFS_WORK_HELPER(scrubparity_helper);



static struct __btrfs_workqueue *

__btrfs_alloc_workqueue(const char *name, unsigned int flags, int max_active,

fs/btrfs/async-thread.h

+2 −0
Original line number Diff line number Diff line
@@ -64,6 +64,8 @@ BTRFS_WORK_HELPER_PROTO(extent_refs_helper); 
BTRFS_WORK_HELPER_PROTO(scrub_helper);

BTRFS_WORK_HELPER_PROTO(scrubwrc_helper);

BTRFS_WORK_HELPER_PROTO(scrubnc_helper);

BTRFS_WORK_HELPER_PROTO(scrubparity_helper);





struct btrfs_workqueue *btrfs_alloc_workqueue(const char *name,

					      unsigned int flags,

fs/btrfs/backref.c

+41 −18
Original line number Diff line number Diff line
@@ -250,8 +250,12 @@ static int add_all_parents(struct btrfs_root *root, struct btrfs_path *path, 
	 * the first item to check. But sometimes, we may enter it with

	 * slot==nritems. In that case, go to the next leaf before we continue.

	 */

	if (path->slots[0] >= btrfs_header_nritems(path->nodes[0]))

	if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {

		if (time_seq == (u64)-1)

			ret = btrfs_next_leaf(root, path);

		else

			ret = btrfs_next_old_leaf(root, path, time_seq);

	}



	while (!ret && count < total_refs) {

		eb = path->nodes[0];
@@ -291,6 +295,9 @@ static int add_all_parents(struct btrfs_root *root, struct btrfs_path *path, 
			eie = NULL;

		}

next:

		if (time_seq == (u64)-1)

			ret = btrfs_next_item(root, path);

		else

			ret = btrfs_next_old_item(root, path, time_seq);

	}
@@ -334,6 +341,8 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info, 


	if (path->search_commit_root)

		root_level = btrfs_header_level(root->commit_root);

	else if (time_seq == (u64)-1)

		root_level = btrfs_header_level(root->node);

	else

		root_level = btrfs_old_root_level(root, time_seq);
@@ -343,7 +352,12 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info, 
	}



	path->lowest_level = level;

	ret = btrfs_search_old_slot(root, &ref->key_for_search, path, time_seq);

	if (time_seq == (u64)-1)

		ret = btrfs_search_slot(NULL, root, &ref->key_for_search, path,

					0, 0);

	else

		ret = btrfs_search_old_slot(root, &ref->key_for_search, path,

					    time_seq);



	/* root node has been locked, we can release @subvol_srcu safely here */

	srcu_read_unlock(&fs_info->subvol_srcu, index);
@@ -491,7 +505,9 @@ static int __add_missing_keys(struct btrfs_fs_info *fs_info, 
		BUG_ON(!ref->wanted_disk_byte);

		eb = read_tree_block(fs_info->tree_root, ref->wanted_disk_byte,

				     0);

		if (!eb || !extent_buffer_uptodate(eb)) {

		if (IS_ERR(eb)) {

			return PTR_ERR(eb);

		} else if (!extent_buffer_uptodate(eb)) {

			free_extent_buffer(eb);

			return -EIO;

		}
@@ -507,7 +523,7 @@ static int __add_missing_keys(struct btrfs_fs_info *fs_info, 
}



/*

 * merge two lists of backrefs and adjust counts accordingly

 * merge backrefs and adjust counts accordingly

 *

 * mode = 1: merge identical keys, if key is set

 *    FIXME: if we add more keys in __add_prelim_ref, we can merge more here.
@@ -535,9 +551,9 @@ static void __merge_refs(struct list_head *head, int mode) 


			ref2 = list_entry(pos2, struct __prelim_ref, list);



			if (mode == 1) {

			if (!ref_for_same_block(ref1, ref2))

				continue;

			if (mode == 1) {

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

					xchg = ref1;

					ref1 = ref2;
@@ -572,8 +588,8 @@ static int __add_delayed_refs(struct btrfs_delayed_ref_head *head, u64 seq, 
			      struct list_head *prefs, u64 *total_refs,

			      u64 inum)

{

	struct btrfs_delayed_ref_node *node;

	struct btrfs_delayed_extent_op *extent_op = head->extent_op;

	struct rb_node *n = &head->node.rb_node;

	struct btrfs_key key;

	struct btrfs_key op_key = {0};

	int sgn;
@@ -583,12 +599,7 @@ static int __add_delayed_refs(struct btrfs_delayed_ref_head *head, u64 seq, 
		btrfs_disk_key_to_cpu(&op_key, &extent_op->key);



	spin_lock(&head->lock);

	n = rb_first(&head->ref_root);

	while (n) {

		struct btrfs_delayed_ref_node *node;

		node = rb_entry(n, struct btrfs_delayed_ref_node,

				rb_node);

		n = rb_next(n);

	list_for_each_entry(node, &head->ref_list, list) {

		if (node->seq > seq)

			continue;
@@ -882,6 +893,11 @@ static int __add_keyed_refs(struct btrfs_fs_info *fs_info, 
 *

 * NOTE: This can return values > 0

 *

 * If time_seq is set to (u64)-1, it will not search delayed_refs, and behave

 * much like trans == NULL case, the difference only lies in it will not

 * commit root.

 * The special case is for qgroup to search roots in commit_transaction().

 *

 * FIXME some caching might speed things up

 */

static int find_parent_nodes(struct btrfs_trans_handle *trans,
@@ -920,6 +936,9 @@ static int find_parent_nodes(struct btrfs_trans_handle *trans, 
		path->skip_locking = 1;

	}



	if (time_seq == (u64)-1)

		path->skip_locking = 1;



	/*

	 * grab both a lock on the path and a lock on the delayed ref head.

	 * We need both to get a consistent picture of how the refs look
@@ -934,9 +953,10 @@ again: 
	BUG_ON(ret == 0);



#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS

	if (trans && likely(trans->type != __TRANS_DUMMY)) {

	if (trans && likely(trans->type != __TRANS_DUMMY) &&

	    time_seq != (u64)-1) {

#else

	if (trans) {

	if (trans && time_seq != (u64)-1) {

#endif

		/*

		 * look if there are updates for this ref queued and lock the
@@ -1034,7 +1054,10 @@ again: 


				eb = read_tree_block(fs_info->extent_root,

							   ref->parent, 0);

				if (!eb || !extent_buffer_uptodate(eb)) {

				if (IS_ERR(eb)) {

					ret = PTR_ERR(eb);

					goto out;

				} else if (!extent_buffer_uptodate(eb)) {

					free_extent_buffer(eb);

					ret = -EIO;

					goto out;

fs/btrfs/ctree.c

+10 −6
Original line number Diff line number Diff line
@@ -1439,7 +1439,8 @@ get_old_root(struct btrfs_root *root, u64 time_seq) 
		btrfs_tree_read_unlock(eb_root);

		free_extent_buffer(eb_root);

		old = read_tree_block(root, logical, 0);

		if (WARN_ON(!old || !extent_buffer_uptodate(old))) {

		if (WARN_ON(IS_ERR(old) || !extent_buffer_uptodate(old))) {

			if (!IS_ERR(old))

				free_extent_buffer(old);

			btrfs_warn(root->fs_info,

				"failed to read tree block %llu from get_old_root", logical);
@@ -1685,7 +1686,9 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans, 
		if (!cur || !uptodate) {

			if (!cur) {

				cur = read_tree_block(root, blocknr, gen);

				if (!cur || !extent_buffer_uptodate(cur)) {

				if (IS_ERR(cur)) {

					return PTR_ERR(cur);

				} else if (!extent_buffer_uptodate(cur)) {

					free_extent_buffer(cur);

					return -EIO;

				}
@@ -1864,7 +1867,8 @@ static noinline struct extent_buffer *read_node_slot(struct btrfs_root *root, 


	eb = read_tree_block(root, btrfs_node_blockptr(parent, slot),

			     btrfs_node_ptr_generation(parent, slot));

	if (eb && !extent_buffer_uptodate(eb)) {

	if (IS_ERR(eb) || !extent_buffer_uptodate(eb)) {

		if (!IS_ERR(eb))

			free_extent_buffer(eb);

		eb = NULL;

	}
@@ -2494,7 +2498,7 @@ read_block_for_search(struct btrfs_trans_handle *trans, 


	ret = -EAGAIN;

	tmp = read_tree_block(root, blocknr, 0);

	if (tmp) {

	if (!IS_ERR(tmp)) {

		/*

		 * If the read above didn't mark this buffer up to date,

		 * it will never end up being up to date.  Set ret to EIO now

fs/btrfs/ctree.h

+20 −8
Original line number Diff line number Diff line
@@ -174,7 +174,7 @@ struct btrfs_ordered_sum; 
/* csum types */

#define BTRFS_CSUM_TYPE_CRC32	0



static int btrfs_csum_sizes[] = { 4, 0 };

static int btrfs_csum_sizes[] = { 4 };



/* four bytes for CRC32 */

#define BTRFS_EMPTY_DIR_SIZE 0
@@ -1619,10 +1619,7 @@ struct btrfs_fs_info { 
	struct task_struct *cleaner_kthread;

	int thread_pool_size;



	struct kobject super_kobj;

	struct kobject *space_info_kobj;

	struct kobject *device_dir_kobj;

	struct completion kobj_unregister;

	int do_barriers;

	int closing;

	int log_root_recovering;
@@ -1698,6 +1695,7 @@ struct btrfs_fs_info { 
	struct btrfs_workqueue *scrub_workers;

	struct btrfs_workqueue *scrub_wr_completion_workers;

	struct btrfs_workqueue *scrub_nocow_workers;

	struct btrfs_workqueue *scrub_parity_workers;



#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY

	u32 check_integrity_print_mask;
@@ -1735,7 +1733,7 @@ struct btrfs_fs_info { 
	/* list of dirty qgroups to be written at next commit */

	struct list_head dirty_qgroups;



	/* used by btrfs_qgroup_record_ref for an efficient tree traversal */

	/* used by qgroup for an efficient tree traversal */

	u64 qgroup_seq;



	/* qgroup rescan items */
@@ -3458,6 +3456,7 @@ int btrfs_check_data_free_space(struct inode *inode, u64 bytes, u64 write_bytes) 
void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes);

void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,

				struct btrfs_root *root);

void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans);

int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,

				  struct inode *inode);

void btrfs_orphan_release_metadata(struct inode *inode);
@@ -3515,6 +3514,9 @@ int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans, 
int __get_raid_index(u64 flags);

int btrfs_start_write_no_snapshoting(struct btrfs_root *root);

void btrfs_end_write_no_snapshoting(struct btrfs_root *root);

void check_system_chunk(struct btrfs_trans_handle *trans,

			struct btrfs_root *root,

			const u64 type);

/* ctree.c */

int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,

		     int level, int *slot);
@@ -4050,6 +4052,7 @@ void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...) 


#ifdef CONFIG_BTRFS_ASSERT



__cold

static inline void assfail(char *expr, char *file, int line)

{

	pr_err("BTRFS: assertion failed: %s, file: %s, line: %d",
@@ -4065,10 +4068,12 @@ static inline void assfail(char *expr, char *file, int line) 


#define btrfs_assert()

__printf(5, 6)

__cold

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

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





__cold

void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,

			       struct btrfs_root *root, const char *function,

			       unsigned int line, int errno);
@@ -4111,11 +4116,17 @@ static inline int __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag) 
 * Call btrfs_abort_transaction as early as possible when an error condition is

 * detected, that way the exact line number is reported.

 */



#define btrfs_abort_transaction(trans, root, errno)		\

do {								\

	__btrfs_abort_transaction(trans, root, __func__,	\

				  __LINE__, errno);		\

	/* Report first abort since mount */			\

	if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,	\

			&((root)->fs_info->fs_state))) {	\

		WARN(1, KERN_DEBUG				\

		"BTRFS: Transaction aborted (error %d)\n",	\

		(errno));					\

	}							\

	__btrfs_abort_transaction((trans), (root), __func__,	\

				  __LINE__, (errno));		\

} while (0)



#define btrfs_std_error(fs_info, errno)				\
@@ -4132,6 +4143,7 @@ do { \ 
} while (0)



__printf(5, 6)

__cold

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

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

CRA Git | Maintained and supported by SUSTech CRA and CCSE