Commit c9a7fe96 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branches 'for-linus' and 'for-linus-3.2' of... 

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

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs:
  Btrfs: unplug every once and a while
  Btrfs: deal with NULL srv_rsv in the delalloc inode reservation code
  Btrfs: only set cache_generation if we setup the block group
  Btrfs: don't panic if orphan item already exists
  Btrfs: fix leaked space in truncate
  Btrfs: fix how we do delalloc reservations and how we free reservations on error
  Btrfs: deal with enospc from dirtying inodes properly
  Btrfs: fix num_workers_starting bug and other bugs in async thread
  BTRFS: Establish i_ops before calling d_instantiate
  Btrfs: add a cond_resched() into the worker loop
  Btrfs: fix ctime update of on-disk inode
  btrfs: keep orphans for subvolume deletion
  Btrfs: fix inaccurate available space on raid0 profile
  Btrfs: fix wrong disk space information of the files
  Btrfs: fix wrong i_size when truncating a file to a larger size
  Btrfs: fix btrfs_end_bio to deal with write errors to a single mirror

* 'for-linus-3.2' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs:
  btrfs: lower the dirty balance poll interval
parents 2cfab8d7 d85c8a6f 142349f5

fs/btrfs/async-thread.c

+55 −62
Original line number Diff line number Diff line
@@ -64,6 +64,8 @@ struct btrfs_worker_thread { 
	int idle;

};



static int __btrfs_start_workers(struct btrfs_workers *workers);



/*

 * btrfs_start_workers uses kthread_run, which can block waiting for memory

 * for a very long time.  It will actually throttle on page writeback,
@@ -88,27 +90,10 @@ static void start_new_worker_func(struct btrfs_work *work) 
{

	struct worker_start *start;

	start = container_of(work, struct worker_start, work);

	btrfs_start_workers(start->queue, 1);

	__btrfs_start_workers(start->queue);

	kfree(start);

}



static int start_new_worker(struct btrfs_workers *queue)

{

	struct worker_start *start;

	int ret;



	start = kzalloc(sizeof(*start), GFP_NOFS);

	if (!start)

		return -ENOMEM;



	start->work.func = start_new_worker_func;

	start->queue = queue;

	ret = btrfs_queue_worker(queue->atomic_worker_start, &start->work);

	if (ret)

		kfree(start);

	return ret;

}



/*

 * helper function to move a thread onto the idle list after it

 * has finished some requests.
@@ -153,12 +138,20 @@ static void check_busy_worker(struct btrfs_worker_thread *worker) 
static void check_pending_worker_creates(struct btrfs_worker_thread *worker)

{

	struct btrfs_workers *workers = worker->workers;

	struct worker_start *start;

	unsigned long flags;



	rmb();

	if (!workers->atomic_start_pending)

		return;



	start = kzalloc(sizeof(*start), GFP_NOFS);

	if (!start)

		return;



	start->work.func = start_new_worker_func;

	start->queue = workers;



	spin_lock_irqsave(&workers->lock, flags);

	if (!workers->atomic_start_pending)

		goto out;
@@ -170,10 +163,11 @@ static void check_pending_worker_creates(struct btrfs_worker_thread *worker) 


	workers->num_workers_starting += 1;

	spin_unlock_irqrestore(&workers->lock, flags);

	start_new_worker(workers);

	btrfs_queue_worker(workers->atomic_worker_start, &start->work);

	return;



out:

	kfree(start);

	spin_unlock_irqrestore(&workers->lock, flags);

}
@@ -331,7 +325,7 @@ again: 
			run_ordered_completions(worker->workers, work);



			check_pending_worker_creates(worker);



			cond_resched();

		}



		spin_lock_irq(&worker->lock);
@@ -462,14 +456,11 @@ void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max, 
 * starts new worker threads.  This does not enforce the max worker

 * count in case you need to temporarily go past it.

 */

static int __btrfs_start_workers(struct btrfs_workers *workers,

				 int num_workers)

static int __btrfs_start_workers(struct btrfs_workers *workers)

{

	struct btrfs_worker_thread *worker;

	int ret = 0;

	int i;



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

	worker = kzalloc(sizeof(*worker), GFP_NOFS);

	if (!worker) {

		ret = -ENOMEM;
@@ -486,7 +477,7 @@ static int __btrfs_start_workers(struct btrfs_workers *workers, 
	worker->workers = workers;

	worker->task = kthread_run(worker_loop, worker,

				   "btrfs-%s-%d", workers->name,

					   workers->num_workers + i);

				   workers->num_workers + 1);

	if (IS_ERR(worker->task)) {

		ret = PTR_ERR(worker->task);

		kfree(worker);
@@ -499,19 +490,21 @@ static int __btrfs_start_workers(struct btrfs_workers *workers, 
	workers->num_workers_starting--;

	WARN_ON(workers->num_workers_starting < 0);

	spin_unlock_irq(&workers->lock);

	}



	return 0;

fail:

	btrfs_stop_workers(workers);

	spin_lock_irq(&workers->lock);

	workers->num_workers_starting--;

	spin_unlock_irq(&workers->lock);

	return ret;

}



int btrfs_start_workers(struct btrfs_workers *workers, int num_workers)

int btrfs_start_workers(struct btrfs_workers *workers)

{

	spin_lock_irq(&workers->lock);

	workers->num_workers_starting += num_workers;

	workers->num_workers_starting++;

	spin_unlock_irq(&workers->lock);

	return __btrfs_start_workers(workers, num_workers);

	return __btrfs_start_workers(workers);

}



/*
@@ -568,6 +561,7 @@ static struct btrfs_worker_thread *find_worker(struct btrfs_workers *workers) 
	struct btrfs_worker_thread *worker;

	unsigned long flags;

	struct list_head *fallback;

	int ret;



again:

	spin_lock_irqsave(&workers->lock, flags);
@@ -584,7 +578,9 @@ again: 
			workers->num_workers_starting++;

			spin_unlock_irqrestore(&workers->lock, flags);

			/* we're below the limit, start another worker */

			__btrfs_start_workers(workers, 1);

			ret = __btrfs_start_workers(workers);

			if (ret)

				goto fallback;

			goto again;

		}

	}
@@ -665,7 +661,7 @@ void btrfs_set_work_high_prio(struct btrfs_work *work) 
/*

 * places a struct btrfs_work into the pending queue of one of the kthreads

 */

int btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work)

void btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work)

{

	struct btrfs_worker_thread *worker;

	unsigned long flags;
@@ -673,7 +669,7 @@ int btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work) 


	/* don't requeue something already on a list */

	if (test_and_set_bit(WORK_QUEUED_BIT, &work->flags))

		goto out;

		return;



	worker = find_worker(workers);

	if (workers->ordered) {
@@ -712,7 +708,4 @@ int btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work) 
	if (wake)

		wake_up_process(worker->task);

	spin_unlock_irqrestore(&worker->lock, flags);



out:

	return 0;

}

fs/btrfs/async-thread.h

+2 −2
Original line number Diff line number Diff line
@@ -109,8 +109,8 @@ struct btrfs_workers { 
	char *name;

};



int btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work);

int btrfs_start_workers(struct btrfs_workers *workers, int num_workers);

void btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work);

int btrfs_start_workers(struct btrfs_workers *workers);

int btrfs_stop_workers(struct btrfs_workers *workers);

void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max,

			struct btrfs_workers *async_starter);

fs/btrfs/ctree.h

+2 −1
Original line number Diff line number Diff line
@@ -2692,7 +2692,8 @@ int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf); 
int btrfs_readpage(struct file *file, struct page *page);

void btrfs_evict_inode(struct inode *inode);

int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);

void btrfs_dirty_inode(struct inode *inode, int flags);

int btrfs_dirty_inode(struct inode *inode);

int btrfs_update_time(struct file *file);

struct inode *btrfs_alloc_inode(struct super_block *sb);

void btrfs_destroy_inode(struct inode *inode);

int btrfs_drop_inode(struct inode *inode);

fs/btrfs/delayed-inode.c

+2 −2
Original line number Diff line number Diff line
@@ -640,8 +640,8 @@ static int btrfs_delayed_inode_reserve_metadata( 
	 * Now if src_rsv == delalloc_block_rsv we'll let it just steal since

	 * we're accounted for.

	 */

	if (!trans->bytes_reserved &&

	    src_rsv != &root->fs_info->delalloc_block_rsv) {

	if (!src_rsv || (!trans->bytes_reserved &&

	    src_rsv != &root->fs_info->delalloc_block_rsv)) {

		ret = btrfs_block_rsv_add_noflush(root, dst_rsv, num_bytes);

		/*

		 * Since we're under a transaction reserve_metadata_bytes could

fs/btrfs/disk-io.c

+21 −13
Original line number Diff line number Diff line
@@ -2194,19 +2194,27 @@ struct btrfs_root *open_ctree(struct super_block *sb, 
	fs_info->endio_meta_write_workers.idle_thresh = 2;

	fs_info->readahead_workers.idle_thresh = 2;



	btrfs_start_workers(&fs_info->workers, 1);

	btrfs_start_workers(&fs_info->generic_worker, 1);

	btrfs_start_workers(&fs_info->submit_workers, 1);

	btrfs_start_workers(&fs_info->delalloc_workers, 1);

	btrfs_start_workers(&fs_info->fixup_workers, 1);

	btrfs_start_workers(&fs_info->endio_workers, 1);

	btrfs_start_workers(&fs_info->endio_meta_workers, 1);

	btrfs_start_workers(&fs_info->endio_meta_write_workers, 1);

	btrfs_start_workers(&fs_info->endio_write_workers, 1);

	btrfs_start_workers(&fs_info->endio_freespace_worker, 1);

	btrfs_start_workers(&fs_info->delayed_workers, 1);

	btrfs_start_workers(&fs_info->caching_workers, 1);

	btrfs_start_workers(&fs_info->readahead_workers, 1);

	/*

	 * btrfs_start_workers can really only fail because of ENOMEM so just

	 * return -ENOMEM if any of these fail.

	 */

	ret = btrfs_start_workers(&fs_info->workers);

	ret |= btrfs_start_workers(&fs_info->generic_worker);

	ret |= btrfs_start_workers(&fs_info->submit_workers);

	ret |= btrfs_start_workers(&fs_info->delalloc_workers);

	ret |= btrfs_start_workers(&fs_info->fixup_workers);

	ret |= btrfs_start_workers(&fs_info->endio_workers);

	ret |= btrfs_start_workers(&fs_info->endio_meta_workers);

	ret |= btrfs_start_workers(&fs_info->endio_meta_write_workers);

	ret |= btrfs_start_workers(&fs_info->endio_write_workers);

	ret |= btrfs_start_workers(&fs_info->endio_freespace_worker);

	ret |= btrfs_start_workers(&fs_info->delayed_workers);

	ret |= btrfs_start_workers(&fs_info->caching_workers);

	ret |= btrfs_start_workers(&fs_info->readahead_workers);

	if (ret) {

		ret = -ENOMEM;

		goto fail_sb_buffer;

	}



	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);

	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,

CRA Git | Maintained and supported by SUSTech CRA and CCSE