Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 27eb427b authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull btrfs updates from Chris Mason:
 "We have a lot of subvolume quota improvements in here, along with big
  piles of cleanups from Dave Sterba and Anand Jain and others.

  Josef pitched in a batch of allocator fixes based on production use
  here at FB.  We found that mount -o ssd_spread greatly improved our
  performance on hardware raid5/6, but it exposed some CPU bottlenecks
  in the allocator.  These patches make a huge difference"

* 'for-linus-4.4' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (100 commits)
  Btrfs: fix hole punching when using the no-holes feature
  Btrfs: find_free_extent: Do not erroneously skip LOOP_CACHING_WAIT state
  btrfs: Fix a data space underflow warning
  btrfs: qgroup: Fix a rebase bug which will cause qgroup double free
  btrfs: qgroup: Fix a race in delayed_ref which leads to abort trans
  btrfs: clear PF_NOFREEZE in cleaner_kthread()
  btrfs: qgroup: Don't copy extent buffer to do qgroup rescan
  btrfs: add balance filters limits, stripes and usage to supported mask
  btrfs: extend balance filter usage to take minimum and maximum
  btrfs: add balance filter for stripes
  btrfs: extend balance filter limit to take minimum and maximum
  btrfs: fix use after free iterating extrefs
  btrfs: check unsupported filters in balance arguments
  Btrfs: fix regression running delayed references when using qgroups
  Btrfs: fix regression when running delayed references
  Btrfs: don't do extra bitmap search in one bit case
  Btrfs: keep track of largest extent in bitmaps
  Btrfs: don't keep trying to build clusters if we are fragmented
  Btrfs: cut down on loops through the allocator
  Btrfs: don't continue setting up space cache when enospc
  ...
parents 71300980 2959a32a

fs/btrfs/backref.c

+6 −0
Original line number Diff line number Diff line
@@ -362,6 +362,12 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info, 
		goto out;

	}



	if (btrfs_test_is_dummy_root(root)) {

		srcu_read_unlock(&fs_info->subvol_srcu, index);

		ret = -ENOENT;

		goto out;

	}



	if (path->search_commit_root)

		root_level = btrfs_header_level(root->commit_root);

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

fs/btrfs/check-integrity.c

+4 −4
Original line number Diff line number Diff line
@@ -667,7 +667,7 @@ static int btrfsic_process_superblock(struct btrfsic_state *state, 
	selected_super = kzalloc(sizeof(*selected_super), GFP_NOFS);

	if (NULL == selected_super) {

		printk(KERN_INFO "btrfsic: error, kmalloc failed!\n");

		return -1;

		return -ENOMEM;

	}



	list_for_each_entry(device, dev_head, dev_list) {
@@ -845,8 +845,8 @@ static int btrfsic_process_superblock_dev_mirror( 
		superblock_tmp->never_written = 0;

		superblock_tmp->mirror_num = 1 + superblock_mirror_num;

		if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE)

			printk_in_rcu(KERN_INFO "New initial S-block (bdev %p, %s)"

				     " @%llu (%s/%llu/%d)\n",

			btrfs_info_in_rcu(device->dev_root->fs_info,

				"new initial S-block (bdev %p, %s) @%llu (%s/%llu/%d)",

				     superblock_bdev,

				     rcu_str_deref(device->name), dev_bytenr,

				     dev_state->name, dev_bytenr,
@@ -1660,7 +1660,7 @@ static int btrfsic_read_block(struct btrfsic_state *state, 
					  sizeof(*block_ctx->pagev)) *

					 num_pages, GFP_NOFS);

	if (!block_ctx->mem_to_free)

		return -1;

		return -ENOMEM;

	block_ctx->datav = block_ctx->mem_to_free;

	block_ctx->pagev = (struct page **)(block_ctx->datav + num_pages);

	for (i = 0; i < num_pages; i++) {

fs/btrfs/compression.c

+51 −46
Original line number Diff line number Diff line
@@ -745,11 +745,13 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
	return ret;

}



static struct list_head comp_idle_workspace[BTRFS_COMPRESS_TYPES];

static spinlock_t comp_workspace_lock[BTRFS_COMPRESS_TYPES];

static int comp_num_workspace[BTRFS_COMPRESS_TYPES];

static atomic_t comp_alloc_workspace[BTRFS_COMPRESS_TYPES];

static wait_queue_head_t comp_workspace_wait[BTRFS_COMPRESS_TYPES];

static struct {

	struct list_head idle_ws;

	spinlock_t ws_lock;

	int num_ws;

	atomic_t alloc_ws;

	wait_queue_head_t ws_wait;

} btrfs_comp_ws[BTRFS_COMPRESS_TYPES];



static const struct btrfs_compress_op * const btrfs_compress_op[] = {

	&btrfs_zlib_compress,
@@ -761,10 +763,10 @@ void __init btrfs_init_compress(void) 
	int i;



	for (i = 0; i < BTRFS_COMPRESS_TYPES; i++) {

		INIT_LIST_HEAD(&comp_idle_workspace[i]);

		spin_lock_init(&comp_workspace_lock[i]);

		atomic_set(&comp_alloc_workspace[i], 0);

		init_waitqueue_head(&comp_workspace_wait[i]);

		INIT_LIST_HEAD(&btrfs_comp_ws[i].idle_ws);

		spin_lock_init(&btrfs_comp_ws[i].ws_lock);

		atomic_set(&btrfs_comp_ws[i].alloc_ws, 0);

		init_waitqueue_head(&btrfs_comp_ws[i].ws_wait);

	}

}
@@ -778,38 +780,38 @@ static struct list_head *find_workspace(int type) 
	int cpus = num_online_cpus();

	int idx = type - 1;



	struct list_head *idle_workspace	= &comp_idle_workspace[idx];

	spinlock_t *workspace_lock		= &comp_workspace_lock[idx];

	atomic_t *alloc_workspace		= &comp_alloc_workspace[idx];

	wait_queue_head_t *workspace_wait	= &comp_workspace_wait[idx];

	int *num_workspace			= &comp_num_workspace[idx];

	struct list_head *idle_ws	= &btrfs_comp_ws[idx].idle_ws;

	spinlock_t *ws_lock		= &btrfs_comp_ws[idx].ws_lock;

	atomic_t *alloc_ws		= &btrfs_comp_ws[idx].alloc_ws;

	wait_queue_head_t *ws_wait	= &btrfs_comp_ws[idx].ws_wait;

	int *num_ws			= &btrfs_comp_ws[idx].num_ws;

again:

	spin_lock(workspace_lock);

	if (!list_empty(idle_workspace)) {

		workspace = idle_workspace->next;

	spin_lock(ws_lock);

	if (!list_empty(idle_ws)) {

		workspace = idle_ws->next;

		list_del(workspace);

		(*num_workspace)--;

		spin_unlock(workspace_lock);

		(*num_ws)--;

		spin_unlock(ws_lock);

		return workspace;



	}

	if (atomic_read(alloc_workspace) > cpus) {

	if (atomic_read(alloc_ws) > cpus) {

		DEFINE_WAIT(wait);



		spin_unlock(workspace_lock);

		prepare_to_wait(workspace_wait, &wait, TASK_UNINTERRUPTIBLE);

		if (atomic_read(alloc_workspace) > cpus && !*num_workspace)

		spin_unlock(ws_lock);

		prepare_to_wait(ws_wait, &wait, TASK_UNINTERRUPTIBLE);

		if (atomic_read(alloc_ws) > cpus && !*num_ws)

			schedule();

		finish_wait(workspace_wait, &wait);

		finish_wait(ws_wait, &wait);

		goto again;

	}

	atomic_inc(alloc_workspace);

	spin_unlock(workspace_lock);

	atomic_inc(alloc_ws);

	spin_unlock(ws_lock);



	workspace = btrfs_compress_op[idx]->alloc_workspace();

	if (IS_ERR(workspace)) {

		atomic_dec(alloc_workspace);

		wake_up(workspace_wait);

		atomic_dec(alloc_ws);

		wake_up(ws_wait);

	}

	return workspace;

}
@@ -821,27 +823,30 @@ static struct list_head *find_workspace(int type) 
static void free_workspace(int type, struct list_head *workspace)

{

	int idx = type - 1;

	struct list_head *idle_workspace	= &comp_idle_workspace[idx];

	spinlock_t *workspace_lock		= &comp_workspace_lock[idx];

	atomic_t *alloc_workspace		= &comp_alloc_workspace[idx];

	wait_queue_head_t *workspace_wait	= &comp_workspace_wait[idx];

	int *num_workspace			= &comp_num_workspace[idx];



	spin_lock(workspace_lock);

	if (*num_workspace < num_online_cpus()) {

		list_add(workspace, idle_workspace);

		(*num_workspace)++;

		spin_unlock(workspace_lock);

	struct list_head *idle_ws	= &btrfs_comp_ws[idx].idle_ws;

	spinlock_t *ws_lock		= &btrfs_comp_ws[idx].ws_lock;

	atomic_t *alloc_ws		= &btrfs_comp_ws[idx].alloc_ws;

	wait_queue_head_t *ws_wait	= &btrfs_comp_ws[idx].ws_wait;

	int *num_ws			= &btrfs_comp_ws[idx].num_ws;



	spin_lock(ws_lock);

	if (*num_ws < num_online_cpus()) {

		list_add(workspace, idle_ws);

		(*num_ws)++;

		spin_unlock(ws_lock);

		goto wake;

	}

	spin_unlock(workspace_lock);

	spin_unlock(ws_lock);



	btrfs_compress_op[idx]->free_workspace(workspace);

	atomic_dec(alloc_workspace);

	atomic_dec(alloc_ws);

wake:

	/*

	 * Make sure counter is updated before we wake up waiters.

	 */

	smp_mb();

	if (waitqueue_active(workspace_wait))

		wake_up(workspace_wait);

	if (waitqueue_active(ws_wait))

		wake_up(ws_wait);

}



/*
@@ -853,11 +858,11 @@ static void free_workspaces(void) 
	int i;



	for (i = 0; i < BTRFS_COMPRESS_TYPES; i++) {

		while (!list_empty(&comp_idle_workspace[i])) {

			workspace = comp_idle_workspace[i].next;

		while (!list_empty(&btrfs_comp_ws[i].idle_ws)) {

			workspace = btrfs_comp_ws[i].idle_ws.next;

			list_del(workspace);

			btrfs_compress_op[i]->free_workspace(workspace);

			atomic_dec(&comp_alloc_workspace[i]);

			atomic_dec(&btrfs_comp_ws[i].alloc_ws);

		}

	}

}

fs/btrfs/ctree.c

+5 −5
Original line number Diff line number Diff line
@@ -1011,7 +1011,7 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, 
			return ret;

		if (refs == 0) {

			ret = -EROFS;

			btrfs_std_error(root->fs_info, ret);

			btrfs_std_error(root->fs_info, ret, NULL);

			return ret;

		}

	} else {
@@ -1927,7 +1927,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
		child = read_node_slot(root, mid, 0);

		if (!child) {

			ret = -EROFS;

			btrfs_std_error(root->fs_info, ret);

			btrfs_std_error(root->fs_info, ret, NULL);

			goto enospc;

		}
@@ -2030,7 +2030,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
		 */

		if (!left) {

			ret = -EROFS;

			btrfs_std_error(root->fs_info, ret);

			btrfs_std_error(root->fs_info, ret, NULL);

			goto enospc;

		}

		wret = balance_node_right(trans, root, mid, left);
@@ -4940,8 +4940,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
{

	struct extent_buffer *leaf;

	struct btrfs_item *item;

	int last_off;

	int dsize = 0;

	u32 last_off;

	u32 dsize = 0;

	int ret = 0;

	int wret;

	int i;

fs/btrfs/ctree.h

+158 −22
Original line number Diff line number Diff line
@@ -823,8 +823,18 @@ struct btrfs_disk_balance_args { 
	 */

	__le64 profiles;



	/* usage filter */

	/*

	 * usage filter

	 * BTRFS_BALANCE_ARGS_USAGE with a single value means '0..N'

	 * BTRFS_BALANCE_ARGS_USAGE_RANGE - range syntax, min..max

	 */

	union {

		__le64 usage;

		struct {

			__le32 usage_min;

			__le32 usage_max;

		};

	};



	/* devid filter */

	__le64 devid;
@@ -846,10 +856,27 @@ struct btrfs_disk_balance_args { 
	/* BTRFS_BALANCE_ARGS_* */

	__le64 flags;



	/* BTRFS_BALANCE_ARGS_LIMIT value */

	/*

	 * BTRFS_BALANCE_ARGS_LIMIT with value 'limit'

	 * BTRFS_BALANCE_ARGS_LIMIT_RANGE - the extend version can use minimum

	 * and maximum

	 */

	union {

		__le64 limit;

		struct {

			__le32 limit_min;

			__le32 limit_max;

		};

	};



	/*

	 * Process chunks that cross stripes_min..stripes_max devices,

	 * BTRFS_BALANCE_ARGS_STRIPES_RANGE

	 */

	__le32 stripes_min;

	__le32 stripes_max;



	__le64 unused[7];

	__le64 unused[6];

} __attribute__ ((__packed__));



/*
@@ -1154,6 +1181,10 @@ struct btrfs_space_info { 
				   delalloc/allocations */

	u64 bytes_readonly;	/* total bytes that are read only */



	u64 max_extent_size;	/* This will hold the maximum extent size of

				   the space info if we had an ENOSPC in the

				   allocator. */



	unsigned int full:1;	/* indicates that we cannot allocate any more

				   chunks for this space */

	unsigned int chunk_alloc:1;	/* set if we are allocating a chunk */
@@ -1228,6 +1259,9 @@ struct btrfs_free_cluster { 
	/* first extent starting offset */

	u64 window_start;



	/* We did a full search and couldn't create a cluster */

	bool fragmented;



	struct btrfs_block_group_cache *block_group;

	/*

	 * when a cluster is allocated from a block group, we put the
@@ -1943,6 +1977,9 @@ struct btrfs_root { 
	int send_in_progress;

	struct btrfs_subvolume_writers *subv_writers;

	atomic_t will_be_snapshoted;



	/* For qgroup metadata space reserve */

	atomic_t qgroup_meta_rsv;

};



struct btrfs_ioctl_defrag_range_args {
@@ -2145,6 +2182,8 @@ struct btrfs_ioctl_defrag_range_args { 
#define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21)

#define BTRFS_MOUNT_PANIC_ON_FATAL_ERROR	(1 << 22)

#define BTRFS_MOUNT_RESCAN_UUID_TREE	(1 << 23)

#define BTRFS_MOUNT_FRAGMENT_DATA	(1 << 24)

#define BTRFS_MOUNT_FRAGMENT_METADATA	(1 << 25)



#define BTRFS_DEFAULT_COMMIT_INTERVAL	(30)

#define BTRFS_DEFAULT_MAX_INLINE	(8192)
@@ -2169,6 +2208,18 @@ struct btrfs_ioctl_defrag_range_args { 
	btrfs_clear_opt(root->fs_info->mount_opt, opt);			\

}



#ifdef CONFIG_BTRFS_DEBUG

static inline int

btrfs_should_fragment_free_space(struct btrfs_root *root,

				 struct btrfs_block_group_cache *block_group)

{

	return (btrfs_test_opt(root, FRAGMENT_METADATA) &&

		block_group->flags & BTRFS_BLOCK_GROUP_METADATA) ||

	       (btrfs_test_opt(root, FRAGMENT_DATA) &&

		block_group->flags &  BTRFS_BLOCK_GROUP_DATA);

}

#endif



/*

 * Requests for changes that need to be done during transaction commit.

 *
@@ -3379,7 +3430,8 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans, 
int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,

				     struct btrfs_root *root,

				     u64 root_objectid, u64 owner,

				     u64 offset, struct btrfs_key *ins);

				     u64 offset, u64 ram_bytes,

				     struct btrfs_key *ins);

int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,

				   struct btrfs_root *root,

				   u64 root_objectid, u64 owner, u64 offset,
@@ -3398,7 +3450,7 @@ int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans, 
int btrfs_free_extent(struct btrfs_trans_handle *trans,

		      struct btrfs_root *root,

		      u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,

		      u64 owner, u64 offset, int no_quota);

		      u64 owner, u64 offset);



int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len,

			       int delalloc);
@@ -3411,7 +3463,7 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, 
int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,

			 struct btrfs_root *root,

			 u64 bytenr, u64 num_bytes, u64 parent,

			 u64 root_objectid, u64 owner, u64 offset, int no_quota);

			 u64 root_objectid, u64 owner, u64 offset);



int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans,

				   struct btrfs_root *root);
@@ -3449,8 +3501,11 @@ enum btrfs_reserve_flush_enum { 
	BTRFS_RESERVE_FLUSH_ALL,

};



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);

int btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len);

int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes);

void btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len);

void btrfs_free_reserved_data_space_noquota(struct inode *inode, u64 start,

					    u64 len);

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);
@@ -3466,8 +3521,8 @@ void btrfs_subvolume_release_metadata(struct btrfs_root *root, 
				      u64 qgroup_reserved);

int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);

void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);

int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes);

void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes);

int btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len);

void btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len);

void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);

struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root,

					      unsigned short type);
@@ -4004,8 +4059,8 @@ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans, 
/* sysfs.c */

int btrfs_init_sysfs(void);

void btrfs_exit_sysfs(void);

int btrfs_sysfs_add_one(struct btrfs_fs_info *fs_info);

void btrfs_sysfs_remove_one(struct btrfs_fs_info *fs_info);

int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info);

void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info);



/* xattr.c */

ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
@@ -4039,14 +4094,102 @@ void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...) 
#define btrfs_info(fs_info, fmt, args...) \

	btrfs_printk(fs_info, KERN_INFO fmt, ##args)



/*

 * Wrappers that use printk_in_rcu

 */

#define btrfs_emerg_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_in_rcu(fs_info, KERN_EMERG fmt, ##args)

#define btrfs_alert_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_in_rcu(fs_info, KERN_ALERT fmt, ##args)

#define btrfs_crit_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_in_rcu(fs_info, KERN_CRIT fmt, ##args)

#define btrfs_err_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_in_rcu(fs_info, KERN_ERR fmt, ##args)

#define btrfs_warn_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_in_rcu(fs_info, KERN_WARNING fmt, ##args)

#define btrfs_notice_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_in_rcu(fs_info, KERN_NOTICE fmt, ##args)

#define btrfs_info_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_in_rcu(fs_info, KERN_INFO fmt, ##args)



/*

 * Wrappers that use a ratelimited printk_in_rcu

 */

#define btrfs_emerg_rl_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_rl_in_rcu(fs_info, KERN_EMERG fmt, ##args)

#define btrfs_alert_rl_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_rl_in_rcu(fs_info, KERN_ALERT fmt, ##args)

#define btrfs_crit_rl_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_rl_in_rcu(fs_info, KERN_CRIT fmt, ##args)

#define btrfs_err_rl_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_rl_in_rcu(fs_info, KERN_ERR fmt, ##args)

#define btrfs_warn_rl_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_rl_in_rcu(fs_info, KERN_WARNING fmt, ##args)

#define btrfs_notice_rl_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_rl_in_rcu(fs_info, KERN_NOTICE fmt, ##args)

#define btrfs_info_rl_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_rl_in_rcu(fs_info, KERN_INFO fmt, ##args)



/*

 * Wrappers that use a ratelimited printk

 */

#define btrfs_emerg_rl(fs_info, fmt, args...) \

	btrfs_printk_ratelimited(fs_info, KERN_EMERG fmt, ##args)

#define btrfs_alert_rl(fs_info, fmt, args...) \

	btrfs_printk_ratelimited(fs_info, KERN_ALERT fmt, ##args)

#define btrfs_crit_rl(fs_info, fmt, args...) \

	btrfs_printk_ratelimited(fs_info, KERN_CRIT fmt, ##args)

#define btrfs_err_rl(fs_info, fmt, args...) \

	btrfs_printk_ratelimited(fs_info, KERN_ERR fmt, ##args)

#define btrfs_warn_rl(fs_info, fmt, args...) \

	btrfs_printk_ratelimited(fs_info, KERN_WARNING fmt, ##args)

#define btrfs_notice_rl(fs_info, fmt, args...) \

	btrfs_printk_ratelimited(fs_info, KERN_NOTICE fmt, ##args)

#define btrfs_info_rl(fs_info, fmt, args...) \

	btrfs_printk_ratelimited(fs_info, KERN_INFO fmt, ##args)

#ifdef DEBUG

#define btrfs_debug(fs_info, fmt, args...) \

	btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)

#define btrfs_debug_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)

#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \

	btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt, ##args)

#define btrfs_debug_rl(fs_info, fmt, args...) \

	btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt, ##args)

#else

#define btrfs_debug(fs_info, fmt, args...) \

    no_printk(KERN_DEBUG fmt, ##args)

#define btrfs_debug_in_rcu(fs_info, fmt, args...) \

	no_printk(KERN_DEBUG fmt, ##args)

#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \

	no_printk(KERN_DEBUG fmt, ##args)

#define btrfs_debug_rl(fs_info, fmt, args...) \

	no_printk(KERN_DEBUG fmt, ##args)

#endif



#define btrfs_printk_in_rcu(fs_info, fmt, args...)	\

do {							\

	rcu_read_lock();				\

	btrfs_printk(fs_info, fmt, ##args);		\

	rcu_read_unlock();				\

} while (0)



#define btrfs_printk_ratelimited(fs_info, fmt, args...)		\

do {								\

	static DEFINE_RATELIMIT_STATE(_rs,			\

		DEFAULT_RATELIMIT_INTERVAL,			\

		DEFAULT_RATELIMIT_BURST);       		\

	if (__ratelimit(&_rs))					\

		btrfs_printk(fs_info, fmt, ##args);		\

} while (0)



#define btrfs_printk_rl_in_rcu(fs_info, fmt, args...)		\

do {								\

	rcu_read_lock();					\

	btrfs_printk_ratelimited(fs_info, fmt, ##args);		\

	rcu_read_unlock();					\

} while (0)



#ifdef CONFIG_BTRFS_ASSERT



__cold
@@ -4127,14 +4270,7 @@ do { \ 
				  __LINE__, (errno));		\

} while (0)



#define btrfs_std_error(fs_info, errno)				\

do {								\

	if ((errno))						\

		__btrfs_std_error((fs_info), __func__,		\

				   __LINE__, (errno), NULL);	\

} while (0)



#define btrfs_error(fs_info, errno, fmt, args...)		\

#define btrfs_std_error(fs_info, errno, fmt, args...)		\

do {								\

	__btrfs_std_error((fs_info), __func__, __LINE__,	\

			  (errno), fmt, ##args);		\