Commit 1fb00cbc authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull btrfs fixes from Chris Mason:
 "The biggest of these comes from Liu Bo, who tracked down a hang we've
  been hitting since moving to kernel workqueues (it's a btrfs bug, not
  in the generic code).  His patch needs backporting to 3.16 and 3.15
  stable, which I'll send once this is in.

  Otherwise these are assorted fixes.  Most were integrated last week
  during KS, but I wanted to give everyone the chance to test the
  result, so I waited for rc2 to come out before sending"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (24 commits)
  Btrfs: fix task hang under heavy compressed write
  Btrfs: fix filemap_flush call in btrfs_file_release
  Btrfs: fix crash on endio of reading corrupted block
  btrfs: fix leak in qgroup_subtree_accounting() error path
  btrfs: Use right extent length when inserting overlap extent map.
  Btrfs: clone, don't create invalid hole extent map
  Btrfs: don't monopolize a core when evicting inode
  Btrfs: fix hole detection during file fsync
  Btrfs: ensure tmpfile inode is always persisted with link count of 0
  Btrfs: race free update of commit root for ro snapshots
  Btrfs: fix regression of btrfs device replace
  Btrfs: don't consider the missing device when allocating new chunks
  Btrfs: Fix wrong device size when we are resizing the device
  Btrfs: don't write any data into a readonly device when scrub
  Btrfs: Fix the problem that the replace destroys the seed filesystem
  btrfs: Return right extent when fiemap gives unaligned offset and len.
  Btrfs: fix wrong extent mapping for DirectIO
  Btrfs: fix wrong write range for filemap_fdatawrite_range()
  Btrfs: fix wrong missing device counter decrease
  Btrfs: fix unzeroed members in fs_devices when creating a fs from seed fs
  ...
parents c0fe5dcb 9e0af237

fs/btrfs/async-thread.c

+36 −8
Original line number Diff line number Diff line
@@ -22,7 +22,6 @@ 
#include <linux/list.h>

#include <linux/spinlock.h>

#include <linux/freezer.h>

#include <linux/workqueue.h>

#include "async-thread.h"

#include "ctree.h"
@@ -55,8 +54,39 @@ struct btrfs_workqueue { 
	struct __btrfs_workqueue *high;

};



static inline struct __btrfs_workqueue

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

static void normal_work_helper(struct btrfs_work *work);



#define BTRFS_WORK_HELPER(name)					\

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

{									\

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

					       normal_work);		\

	normal_work_helper(work);					\

}



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



static struct __btrfs_workqueue *

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

			 int thresh)

{

	struct __btrfs_workqueue *ret = kzalloc(sizeof(*ret), GFP_NOFS);
@@ -232,13 +262,11 @@ static void run_ordered_work(struct __btrfs_workqueue *wq) 
	spin_unlock_irqrestore(lock, flags);

}



static void normal_work_helper(struct work_struct *arg)

static void normal_work_helper(struct btrfs_work *work)

{

	struct btrfs_work *work;

	struct __btrfs_workqueue *wq;

	int need_order = 0;



	work = container_of(arg, struct btrfs_work, normal_work);

	/*

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

	 * 1) after work->func() if it has no ordered_free
@@ -262,7 +290,7 @@ static void normal_work_helper(struct work_struct *arg) 
		trace_btrfs_all_work_done(work);

}



void btrfs_init_work(struct btrfs_work *work,

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)
@@ -270,7 +298,7 @@ void btrfs_init_work(struct btrfs_work *work, 
	work->func = func;

	work->ordered_func = ordered_func;

	work->ordered_free = ordered_free;

	INIT_WORK(&work->normal_work, normal_work_helper);

	INIT_WORK(&work->normal_work, uniq_func);

	INIT_LIST_HEAD(&work->ordered_list);

	work->flags = 0;

}

fs/btrfs/async-thread.h

+27 −1
Original line number Diff line number Diff line
@@ -19,12 +19,14 @@ 


#ifndef __BTRFS_ASYNC_THREAD_

#define __BTRFS_ASYNC_THREAD_

#include <linux/workqueue.h>



struct btrfs_workqueue;

/* Internal use only */

struct __btrfs_workqueue;

struct btrfs_work;

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

typedef void (*btrfs_work_func_t)(struct work_struct *arg);



struct btrfs_work {

	btrfs_func_t func;
@@ -38,11 +40,35 @@ 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(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);



struct btrfs_workqueue *btrfs_alloc_workqueue(const char *name,

					      int flags,

					      int max_active,

					      int thresh);

void btrfs_init_work(struct btrfs_work *work,

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

fs/btrfs/delayed-inode.c

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

			NULL, NULL);

	btrfs_init_work(&async_work->work, btrfs_delayed_meta_helper,

			btrfs_async_run_delayed_root, NULL, NULL);

	async_work->nr = nr;



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

fs/btrfs/disk-io.c

+31 −25
Original line number Diff line number Diff line
@@ -39,7 +39,6 @@ 
#include "btrfs_inode.h"

#include "volumes.h"

#include "print-tree.h"

#include "async-thread.h"

#include "locking.h"

#include "tree-log.h"

#include "free-space-cache.h"
@@ -693,35 +692,41 @@ static void end_workqueue_bio(struct bio *bio, int err) 
{

	struct 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->error = err;

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



	if (bio->bi_rw & REQ_WRITE) {

		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA)

			btrfs_queue_work(fs_info->endio_meta_write_workers,

					 &end_io_wq->work);

		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_FREE_SPACE)

			btrfs_queue_work(fs_info->endio_freespace_worker,

					 &end_io_wq->work);

		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)

			btrfs_queue_work(fs_info->endio_raid56_workers,

					 &end_io_wq->work);

		else

			btrfs_queue_work(fs_info->endio_write_workers,

					 &end_io_wq->work);

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

			wq = fs_info->endio_freespace_worker;

			func = btrfs_freespace_write_helper;

		} 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 == BTRFS_WQ_ENDIO_RAID56)

			btrfs_queue_work(fs_info->endio_raid56_workers,

					 &end_io_wq->work);

		else if (end_io_wq->metadata)

			btrfs_queue_work(fs_info->endio_meta_workers,

					 &end_io_wq->work);

		else

			btrfs_queue_work(fs_info->endio_workers,

					 &end_io_wq->work);

			wq = fs_info->endio_write_workers;

			func = btrfs_endio_write_helper;

		}

	} 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) {

			wq = fs_info->endio_meta_workers;

			func = btrfs_endio_meta_helper;

		} else {

			wq = fs_info->endio_workers;

			func = btrfs_endio_helper;

		}

	}



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

	btrfs_queue_work(wq, &end_io_wq->work);

}



/*
@@ -828,7 +833,7 @@ int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode, 
	async->submit_bio_start = submit_bio_start;

	async->submit_bio_done = submit_bio_done;



	btrfs_init_work(&async->work, run_one_async_start,

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

			run_one_async_done, run_one_async_free);



	async->bio_flags = bio_flags;
@@ -3450,7 +3455,8 @@ static int write_all_supers(struct btrfs_root *root, int max_mirrors) 
		btrfs_set_stack_device_generation(dev_item, 0);

		btrfs_set_stack_device_type(dev_item, dev->type);

		btrfs_set_stack_device_id(dev_item, dev->devid);

		btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);

		btrfs_set_stack_device_total_bytes(dev_item,

						   dev->disk_total_bytes);

		btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);

		btrfs_set_stack_device_io_align(dev_item, dev->io_align);

		btrfs_set_stack_device_io_width(dev_item, dev->io_width);

fs/btrfs/extent-tree.c

+6 −17
Original line number Diff line number Diff line
@@ -552,7 +552,8 @@ static int cache_block_group(struct btrfs_block_group_cache *cache, 
	caching_ctl->block_group = cache;

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

	atomic_set(&caching_ctl->count, 1);

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

	btrfs_init_work(&caching_ctl->work, btrfs_cache_helper,

			caching_thread, NULL, NULL);



	spin_lock(&cache->lock);

	/*
@@ -2749,8 +2750,8 @@ int btrfs_async_run_delayed_refs(struct btrfs_root *root, 
		async->sync = 0;

	init_completion(&async->wait);



	btrfs_init_work(&async->work, delayed_ref_async_start,

			NULL, NULL);

	btrfs_init_work(&async->work, btrfs_extent_refs_helper,

			delayed_ref_async_start, NULL, NULL);



	btrfs_queue_work(root->fs_info->extent_workers, &async->work);
@@ -3586,13 +3587,7 @@ static u64 get_restripe_target(struct btrfs_fs_info *fs_info, u64 flags) 
 */

static u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags)

{

	/*

	 * we add in the count of missing devices because we want

	 * to make sure that any RAID levels on a degraded FS

	 * continue to be honored.

	 */

	u64 num_devices = root->fs_info->fs_devices->rw_devices +

		root->fs_info->fs_devices->missing_devices;

	u64 num_devices = root->fs_info->fs_devices->rw_devices;

	u64 target;

	u64 tmp;
@@ -8440,13 +8435,7 @@ static u64 update_block_group_flags(struct btrfs_root *root, u64 flags) 
	if (stripped)

		return extended_to_chunk(stripped);



	/*

	 * we add in the count of missing devices because we want

	 * to make sure that any RAID levels on a degraded FS

	 * continue to be honored.

	 */

	num_devices = root->fs_info->fs_devices->rw_devices +

		root->fs_info->fs_devices->missing_devices;

	num_devices = root->fs_info->fs_devices->rw_devices;



	stripped = BTRFS_BLOCK_GROUP_RAID0 |

		BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6 |

CRA Git | Maintained and supported by SUSTech CRA and CCSE