Commit a0cac0ec authored by Omar Sandoval's avatar Omar Sandoval Committed by David Sterba
Browse files

btrfs: get rid of unique workqueue helper functions 



Commit 9e0af237 ("Btrfs: fix task hang under heavy compressed
write") worked around the issue that a recycled work item could get a
false dependency on the original work item due to how the workqueue code
guarantees non-reentrancy. It did so by giving different work functions
to different types of work.

However, the fixes in the previous few patches are more complete, as
they prevent a work item from being recycled at all (except for a tiny
window that the kernel workqueue code handles for us). This obsoletes
the previous fix, so we don't need the unique helpers for correctness.
The only other reason to keep them would be so they show up in stack
traces, but they always seem to be optimized to a tail call, so they
don't show up anyways. So, let's just get rid of the extra indirection.

While we're here, rename normal_work_helper() to the more informative
btrfs_work_helper().

Reviewed-by: default avatarNikolay Borisov <nborisov@suse.com>
Reviewed-by: default avatarFilipe Manana <fdmanana@suse.com>
Signed-off-by: default avatarOmar Sandoval <osandov@fb.com>
Reviewed-by: default avatarDavid Sterba <dsterba@suse.com>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent 57d4f0b8

fs/btrfs/async-thread.c

+13 −45
Original line number Diff line number Diff line
@@ -53,16 +53,6 @@ struct btrfs_workqueue { 
	struct __btrfs_workqueue *high;

};



static void normal_work_helper(struct btrfs_work *work);



#define BTRFS_WORK_HELPER(name)					\

noinline_for_stack void btrfs_##name(struct work_struct *arg)		\

{									\

	struct btrfs_work *work = container_of(arg, struct btrfs_work,	\

					       normal_work);		\

	normal_work_helper(work);					\

}



struct btrfs_fs_info *

btrfs_workqueue_owner(const struct __btrfs_workqueue *wq)

{
@@ -89,29 +79,6 @@ bool btrfs_workqueue_normal_congested(const struct btrfs_workqueue *wq) 
	return atomic_read(&wq->normal->pending) > wq->normal->thresh * 2;

}



BTRFS_WORK_HELPER(worker_helper);

BTRFS_WORK_HELPER(delalloc_helper);

BTRFS_WORK_HELPER(flush_delalloc_helper);

BTRFS_WORK_HELPER(cache_helper);

BTRFS_WORK_HELPER(submit_helper);

BTRFS_WORK_HELPER(fixup_helper);

BTRFS_WORK_HELPER(endio_helper);

BTRFS_WORK_HELPER(endio_meta_helper);

BTRFS_WORK_HELPER(endio_meta_write_helper);

BTRFS_WORK_HELPER(endio_raid56_helper);

BTRFS_WORK_HELPER(endio_repair_helper);

BTRFS_WORK_HELPER(rmw_helper);

BTRFS_WORK_HELPER(endio_write_helper);

BTRFS_WORK_HELPER(freespace_write_helper);

BTRFS_WORK_HELPER(delayed_meta_helper);

BTRFS_WORK_HELPER(readahead_helper);

BTRFS_WORK_HELPER(qgroup_rescan_helper);

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(struct btrfs_fs_info *fs_info, const char *name,

			unsigned int flags, int limit_active, int thresh)
@@ -302,12 +269,13 @@ static void run_ordered_work(struct __btrfs_workqueue *wq, 
			 * original work item cannot depend on the recycled work

			 * item in that case (see find_worker_executing_work()).

			 *

			 * Note that the work of one Btrfs filesystem may depend

			 * on the work of another Btrfs filesystem via, e.g., a

			 * loop device. Therefore, we must not allow the current

			 * work item to be recycled until we are really done,

			 * otherwise we break the above assumption and can

			 * deadlock.

			 * Note that different types of Btrfs work can depend on

			 * each other, and one type of work on one Btrfs

			 * filesystem may even depend on the same type of work

			 * on another Btrfs filesystem via, e.g., a loop device.

			 * Therefore, we must not allow the current work item to

			 * be recycled until we are really done, otherwise we

			 * break the above assumption and can deadlock.

			 */

			free_self = true;

		} else {
@@ -331,8 +299,10 @@ static void run_ordered_work(struct __btrfs_workqueue *wq, 
	}

}



static void normal_work_helper(struct btrfs_work *work)

static void btrfs_work_helper(struct work_struct *normal_work)

{

	struct btrfs_work *work = container_of(normal_work, struct btrfs_work,

					       normal_work);

	struct __btrfs_workqueue *wq;

	void *wtag;

	int need_order = 0;
@@ -362,15 +332,13 @@ static void normal_work_helper(struct btrfs_work *work) 
		trace_btrfs_all_work_done(wq->fs_info, wtag);

}



void btrfs_init_work(struct btrfs_work *work, btrfs_work_func_t uniq_func,

		     btrfs_func_t func,

		     btrfs_func_t ordered_func,

		     btrfs_func_t ordered_free)

void btrfs_init_work(struct btrfs_work *work, btrfs_func_t func,

		     btrfs_func_t ordered_func, btrfs_func_t ordered_free)

{

	work->func = func;

	work->ordered_func = ordered_func;

	work->ordered_free = ordered_free;

	INIT_WORK(&work->normal_work, uniq_func);

	INIT_WORK(&work->normal_work, btrfs_work_helper);

	INIT_LIST_HEAD(&work->ordered_list);

	work->flags = 0;

}

fs/btrfs/async-thread.h

+2 −31
Original line number Diff line number Diff line
@@ -29,42 +29,13 @@ struct btrfs_work { 
	unsigned long flags;

};



#define BTRFS_WORK_HELPER_PROTO(name)					\

void btrfs_##name(struct work_struct *arg)



BTRFS_WORK_HELPER_PROTO(worker_helper);

BTRFS_WORK_HELPER_PROTO(delalloc_helper);

BTRFS_WORK_HELPER_PROTO(flush_delalloc_helper);

BTRFS_WORK_HELPER_PROTO(cache_helper);

BTRFS_WORK_HELPER_PROTO(submit_helper);

BTRFS_WORK_HELPER_PROTO(fixup_helper);

BTRFS_WORK_HELPER_PROTO(endio_helper);

BTRFS_WORK_HELPER_PROTO(endio_meta_helper);

BTRFS_WORK_HELPER_PROTO(endio_meta_write_helper);

BTRFS_WORK_HELPER_PROTO(endio_raid56_helper);

BTRFS_WORK_HELPER_PROTO(endio_repair_helper);

BTRFS_WORK_HELPER_PROTO(rmw_helper);

BTRFS_WORK_HELPER_PROTO(endio_write_helper);

BTRFS_WORK_HELPER_PROTO(freespace_write_helper);

BTRFS_WORK_HELPER_PROTO(delayed_meta_helper);

BTRFS_WORK_HELPER_PROTO(readahead_helper);

BTRFS_WORK_HELPER_PROTO(qgroup_rescan_helper);

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(struct btrfs_fs_info *fs_info,

					      const char *name,

					      unsigned int flags,

					      int limit_active,

					      int thresh);

void btrfs_init_work(struct btrfs_work *work, btrfs_work_func_t helper,

		     btrfs_func_t func,

		     btrfs_func_t ordered_func,

		     btrfs_func_t ordered_free);

void btrfs_init_work(struct btrfs_work *work, btrfs_func_t func,

		     btrfs_func_t ordered_func, btrfs_func_t ordered_free);

void btrfs_queue_work(struct btrfs_workqueue *wq,

		      struct btrfs_work *work);

void btrfs_destroy_workqueue(struct btrfs_workqueue *wq);

fs/btrfs/block-group.c

+1 −2
Original line number Diff line number Diff line
@@ -695,8 +695,7 @@ int btrfs_cache_block_group(struct btrfs_block_group_cache *cache, 
	caching_ctl->block_group = cache;

	caching_ctl->progress = cache->key.objectid;

	refcount_set(&caching_ctl->count, 1);

	btrfs_init_work(&caching_ctl->work, btrfs_cache_helper,

			caching_thread, NULL, NULL);

	btrfs_init_work(&caching_ctl->work, caching_thread, NULL, NULL);



	spin_lock(&cache->lock);

	/*

fs/btrfs/delayed-inode.c

+2 −2
Original line number Diff line number Diff line
@@ -1367,8 +1367,8 @@ static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root, 
		return -ENOMEM;



	async_work->delayed_root = delayed_root;

	btrfs_init_work(&async_work->work, btrfs_delayed_meta_helper,

			btrfs_async_run_delayed_root, NULL, NULL);

	btrfs_init_work(&async_work->work, btrfs_async_run_delayed_root, NULL,

			NULL);

	async_work->nr = nr;



	btrfs_queue_work(fs_info->delayed_workers, &async_work->work);

fs/btrfs/disk-io.c

+11 −23
Original line number Diff line number Diff line
@@ -706,43 +706,31 @@ static void end_workqueue_bio(struct bio *bio) 
	struct btrfs_end_io_wq *end_io_wq = bio->bi_private;

	struct btrfs_fs_info *fs_info;

	struct btrfs_workqueue *wq;

	btrfs_work_func_t func;



	fs_info = end_io_wq->info;

	end_io_wq->status = bio->bi_status;



	if (bio_op(bio) == REQ_OP_WRITE) {

		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA) {

		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA)

			wq = fs_info->endio_meta_write_workers;

			func = btrfs_endio_meta_write_helper;

		} else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_FREE_SPACE) {

		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_FREE_SPACE)

			wq = fs_info->endio_freespace_worker;

			func = btrfs_freespace_write_helper;

		} else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56) {

		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)

			wq = fs_info->endio_raid56_workers;

			func = btrfs_endio_raid56_helper;

		} else {

		else

			wq = fs_info->endio_write_workers;

			func = btrfs_endio_write_helper;

		}

	} else {

		if (unlikely(end_io_wq->metadata ==

			     BTRFS_WQ_ENDIO_DIO_REPAIR)) {

		if (unlikely(end_io_wq->metadata == BTRFS_WQ_ENDIO_DIO_REPAIR))

			wq = fs_info->endio_repair_workers;

			func = btrfs_endio_repair_helper;

		} else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56) {

		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)

			wq = fs_info->endio_raid56_workers;

			func = btrfs_endio_raid56_helper;

		} else if (end_io_wq->metadata) {

		else if (end_io_wq->metadata)

			wq = fs_info->endio_meta_workers;

			func = btrfs_endio_meta_helper;

		} else {

		else

			wq = fs_info->endio_workers;

			func = btrfs_endio_helper;

		}

	}



	btrfs_init_work(&end_io_wq->work, func, end_workqueue_fn, NULL, NULL);

	btrfs_init_work(&end_io_wq->work, end_workqueue_fn, NULL, NULL);

	btrfs_queue_work(wq, &end_io_wq->work);

}
@@ -835,8 +823,8 @@ blk_status_t btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct bio *bio, 
	async->mirror_num = mirror_num;

	async->submit_bio_start = submit_bio_start;



	btrfs_init_work(&async->work, btrfs_worker_helper, run_one_async_start,

			run_one_async_done, run_one_async_free);

	btrfs_init_work(&async->work, run_one_async_start, run_one_async_done,

			run_one_async_free);



	async->bio_offset = bio_offset;

CRA Git | Maintained and supported by SUSTech CRA and CCSE