Commit 078b8b90 authored by David Sterba's avatar David Sterba
Browse files

btrfs: merge ordered work callbacks in btrfs_work into one 



There are two callbacks defined in btrfs_work but only two actually make
use of them, otherwise there are NULLs. We can get rid of the freeing
callback making it a special case of the normal work. This reduces the
size of btrfs_work by 8 bytes, final layout:

struct btrfs_work {
        btrfs_func_t               func;                 /*     0     8 */
        btrfs_ordered_func_t       ordered_func;         /*     8     8 */
        struct work_struct         normal_work;          /*    16    32 */
        struct list_head           ordered_list;         /*    48    16 */
        /* --- cacheline 1 boundary (64 bytes) --- */
        struct btrfs_workqueue *   wq;                   /*    64     8 */
        long unsigned int          flags;                /*    72     8 */

        /* size: 80, cachelines: 2, members: 6 */
        /* last cacheline: 16 bytes */
};

This in turn reduces size of other structures (on a release config):

- async_chunk			 160 ->  152
- async_submit_bio		 152 ->  144
- btrfs_async_delayed_work	 104 ->   96
- btrfs_caching_control		 176 ->  168
- btrfs_delalloc_work		 144 ->  136
- btrfs_fs_info			3608 -> 3600
- btrfs_ordered_extent		 440 ->  424
- btrfs_writepage_fixup		 104 ->   96

Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent e9b9b911

fs/btrfs/async-thread.c

+5 −6
Original line number Diff line number Diff line
@@ -243,7 +243,7 @@ static void run_ordered_work(struct btrfs_workqueue *wq, 
			break;

		trace_btrfs_ordered_sched(work);

		spin_unlock_irqrestore(lock, flags);

		work->ordered_func(work);

		work->ordered_func(work, false);



		/* now take the lock again and drop our item from the list */

		spin_lock_irqsave(lock, flags);
@@ -278,7 +278,7 @@ static void run_ordered_work(struct btrfs_workqueue *wq, 
			 * We don't want to call the ordered free functions with

			 * the lock held.

			 */

			work->ordered_free(work);

			work->ordered_func(work, true);

			/* NB: work must not be dereferenced past this point. */

			trace_btrfs_all_work_done(wq->fs_info, work);

		}
@@ -286,7 +286,7 @@ static void run_ordered_work(struct btrfs_workqueue *wq, 
	spin_unlock_irqrestore(lock, flags);



	if (free_self) {

		self->ordered_free(self);

		self->ordered_func(self, true);

		/* NB: self must not be dereferenced past this point. */

		trace_btrfs_all_work_done(wq->fs_info, self);

	}
@@ -301,7 +301,7 @@ static void btrfs_work_helper(struct work_struct *normal_work) 


	/*

	 * We should not touch things inside work in the following cases:

	 * 1) after work->func() if it has no ordered_free

	 * 1) after work->func() if it has no ordered_func(..., true) to free

	 *    Since the struct is freed in work->func().

	 * 2) after setting WORK_DONE_BIT

	 *    The work may be freed in other threads almost instantly.
@@ -330,11 +330,10 @@ static void btrfs_work_helper(struct work_struct *normal_work) 
}



void btrfs_init_work(struct btrfs_work *work, btrfs_func_t func,

		     btrfs_func_t ordered_func, btrfs_func_t ordered_free)

		     btrfs_ordered_func_t ordered_func)

{

	work->func = func;

	work->ordered_func = ordered_func;

	work->ordered_free = ordered_free;

	INIT_WORK(&work->normal_work, btrfs_work_helper);

	INIT_LIST_HEAD(&work->ordered_list);

	work->flags = 0;

fs/btrfs/async-thread.h

+3 −3
Original line number Diff line number Diff line
@@ -13,11 +13,11 @@ struct btrfs_fs_info; 
struct btrfs_workqueue;

struct btrfs_work;

typedef void (*btrfs_func_t)(struct btrfs_work *arg);

typedef void (*btrfs_ordered_func_t)(struct btrfs_work *arg, bool);



struct btrfs_work {

	btrfs_func_t func;

	btrfs_func_t ordered_func;

	btrfs_func_t ordered_free;

	btrfs_ordered_func_t ordered_func;



	/* Don't touch things below */

	struct work_struct normal_work;
@@ -35,7 +35,7 @@ struct btrfs_workqueue *btrfs_alloc_ordered_workqueue( 
				struct btrfs_fs_info *fs_info, const char *name,

				unsigned int flags);

void btrfs_init_work(struct btrfs_work *work, btrfs_func_t func,

		     btrfs_func_t ordered_func, btrfs_func_t ordered_free);

		     btrfs_ordered_func_t ordered_func);

void btrfs_queue_work(struct btrfs_workqueue *wq,

		      struct btrfs_work *work);

void btrfs_destroy_workqueue(struct btrfs_workqueue *wq);

fs/btrfs/bio.c

+9 −8
Original line number Diff line number Diff line
@@ -574,13 +574,20 @@ static void run_one_async_start(struct btrfs_work *work) 
 *

 * At IO completion time the csums attached on the ordered extent record are

 * inserted into the tree.

 *

 * If called with @do_free == true, then it will free the work struct.

 */

static void run_one_async_done(struct btrfs_work *work)

static void run_one_async_done(struct btrfs_work *work, bool do_free)

{

	struct async_submit_bio *async =

		container_of(work, struct async_submit_bio, work);

	struct bio *bio = &async->bbio->bio;



	if (do_free) {

		kfree(container_of(work, struct async_submit_bio, work));

		return;

	}



	/* If an error occurred we just want to clean up the bio and move on. */

	if (bio->bi_status) {

		btrfs_orig_bbio_end_io(async->bbio);
@@ -596,11 +603,6 @@ static void run_one_async_done(struct btrfs_work *work) 
	__btrfs_submit_bio(bio, async->bioc, &async->smap, async->mirror_num);

}



static void run_one_async_free(struct btrfs_work *work)

{

	kfree(container_of(work, struct async_submit_bio, work));

}



static bool should_async_write(struct btrfs_bio *bbio)

{

	/* Submit synchronously if the checksum implementation is fast. */
@@ -642,8 +644,7 @@ static bool btrfs_wq_submit_bio(struct btrfs_bio *bbio, 
	async->smap = *smap;

	async->mirror_num = mirror_num;



	btrfs_init_work(&async->work, 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);

	btrfs_queue_work(fs_info->workers, &async->work);

	return true;

}

fs/btrfs/block-group.c

+1 −1
Original line number Diff line number Diff line
@@ -935,7 +935,7 @@ int btrfs_cache_block_group(struct btrfs_block_group *cache, bool wait) 
	caching_ctl->block_group = cache;

	refcount_set(&caching_ctl->count, 2);

	atomic_set(&caching_ctl->progress, 0);

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

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



	spin_lock(&cache->lock);

	if (cache->cached != BTRFS_CACHE_NO) {

fs/btrfs/delayed-inode.c

+1 −2
Original line number Diff line number Diff line
@@ -1379,8 +1379,7 @@ 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_async_run_delayed_root, NULL,

			NULL);

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

	async_work->nr = nr;



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