Merge branch 'for-3.1/core' of git://git.kernel.dk/linux-block (096a705b) · Commits · 戴 / test

Documentation/block/queue-sysfs.txt

+7 −3

Original line number	Diff line number	Diff line
		@@ -45,9 +45,13 @@ device.

		rq_affinity (RW)
		----------------
		If this option is enabled, the block layer will migrate request completions
		to the CPU that originally submitted the request. For some workloads
		this provides a significant reduction in CPU cycles due to caching effects.
		If this option is '1', the block layer will migrate request completions to the
		cpu "group" that originally submitted the request. For some workloads this
		provides a significant reduction in CPU cycles due to caching effects.

		For storage configurations that need to maximize distribution of completion
		processing setting this option to '2' forces the completion to run on the
		requesting cpu (bypassing the "group" aggregation logic).

		scheduler (RW)
		--------------

block/blk-core.c

+7 −4

Original line number	Diff line number	Diff line
		@@ -1282,10 +1282,8 @@ get_rq:
		init_request_from_bio(req, bio);

		if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags) \|\|
		bio_flagged(bio, BIO_CPU_AFFINE)) {
		req->cpu = blk_cpu_to_group(get_cpu());
		put_cpu();
		}
		bio_flagged(bio, BIO_CPU_AFFINE))
		req->cpu = smp_processor_id();

		plug = current->plug;
		if (plug) {
		@@ -1305,7 +1303,10 @@ get_rq:
		plug->should_sort = 1;
		}
		list_add_tail(&req->queuelist, &plug->list);
		plug->count++;
		drive_stat_acct(req, 1);
		if (plug->count >= BLK_MAX_REQUEST_COUNT)
		blk_flush_plug_list(plug, false);
		} else {
		spin_lock_irq(q->queue_lock);
		add_acct_request(q, req, where);
		@@ -2629,6 +2630,7 @@ void blk_start_plug(struct blk_plug *plug)
		INIT_LIST_HEAD(&plug->list);
		INIT_LIST_HEAD(&plug->cb_list);
		plug->should_sort = 0;
		plug->count = 0;

		/*
		* If this is a nested plug, don't actually assign it. It will be
		@@ -2712,6 +2714,7 @@ void blk_flush_plug_list(struct blk_plug *plug, bool from_schedule)
		return;

		list_splice_init(&plug->list, &list);
		plug->count = 0;

		if (plug->should_sort) {
		list_sort(NULL, &list, plug_rq_cmp);

block/blk-ioc.c

+20 −20

Original line number	Diff line number	Diff line
		@@ -82,26 +82,26 @@ void exit_io_context(struct task_struct *task)

		struct io_context *alloc_io_context(gfp_t gfp_flags, int node)
		{
		struct io_context *ret;
		struct io_context *ioc;

		ret = kmem_cache_alloc_node(iocontext_cachep, gfp_flags, node);
		if (ret) {
		atomic_long_set(&ret->refcount, 1);
		atomic_set(&ret->nr_tasks, 1);
		spin_lock_init(&ret->lock);
		ret->ioprio_changed = 0;
		ret->ioprio = 0;
		ret->last_waited = 0; /* doesn't matter... */
		ret->nr_batch_requests = 0; /* because this is 0 */
		INIT_RADIX_TREE(&ret->radix_root, GFP_ATOMIC \| __GFP_HIGH);
		INIT_HLIST_HEAD(&ret->cic_list);
		ret->ioc_data = NULL;
		ioc = kmem_cache_alloc_node(iocontext_cachep, gfp_flags, node);
		if (ioc) {
		atomic_long_set(&ioc->refcount, 1);
		atomic_set(&ioc->nr_tasks, 1);
		spin_lock_init(&ioc->lock);
		ioc->ioprio_changed = 0;
		ioc->ioprio = 0;
		ioc->last_waited = 0; /* doesn't matter... */
		ioc->nr_batch_requests = 0; /* because this is 0 */
		INIT_RADIX_TREE(&ioc->radix_root, GFP_ATOMIC \| __GFP_HIGH);
		INIT_HLIST_HEAD(&ioc->cic_list);
		ioc->ioc_data = NULL;
		#if defined(CONFIG_BLK_CGROUP) \|\| defined(CONFIG_BLK_CGROUP_MODULE)
		ret->cgroup_changed = 0;
		ioc->cgroup_changed = 0;
		#endif
		}

		return ret;
		return ioc;
		}

		/*
		@@ -139,19 +139,19 @@ struct io_context *current_io_context(gfp_t gfp_flags, int node)
		*/
		struct io_context *get_io_context(gfp_t gfp_flags, int node)
		{
		struct io_context *ret = NULL;
		struct io_context *ioc = NULL;

		/*
		* Check for unlikely race with exiting task. ioc ref count is
		* zero when ioc is being detached.
		*/
		do {
		ret = current_io_context(gfp_flags, node);
		if (unlikely(!ret))
		ioc = current_io_context(gfp_flags, node);
		if (unlikely(!ioc))
		break;
		} while (!atomic_long_inc_not_zero(&ret->refcount));
		} while (!atomic_long_inc_not_zero(&ioc->refcount));

		return ret;
		return ioc;
		}
		EXPORT_SYMBOL(get_io_context);

block/blk-lib.c

+4 −1

Original line number	Diff line number	Diff line
		@@ -59,7 +59,10 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
		* granularity
		*/
		max_discard_sectors = min(q->limits.max_discard_sectors, UINT_MAX >> 9);
		if (q->limits.discard_granularity) {
		if (unlikely(!max_discard_sectors)) {
		/* Avoid infinite loop below. Being cautious never hurts. */
		return -EOPNOTSUPP;
		} else if (q->limits.discard_granularity) {
		unsigned int disc_sects = q->limits.discard_granularity >> 9;

		max_discard_sectors &= ~(disc_sects - 1);

block/blk-softirq.c

+7 −4

Original line number	Diff line number	Diff line
		@@ -103,22 +103,25 @@ static struct notifier_block __cpuinitdata blk_cpu_notifier = {

		void __blk_complete_request(struct request *req)
		{
		int ccpu, cpu, group_cpu = NR_CPUS;
		struct request_queue *q = req->q;
		unsigned long flags;
		int ccpu, cpu, group_cpu;

		BUG_ON(!q->softirq_done_fn);

		local_irq_save(flags);
		cpu = smp_processor_id();
		group_cpu = blk_cpu_to_group(cpu);

		/*
		* Select completion CPU
		*/
		if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags) && req->cpu != -1)
		if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags) && req->cpu != -1) {
		ccpu = req->cpu;
		else
		if (!test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags)) {
		ccpu = blk_cpu_to_group(ccpu);
		group_cpu = blk_cpu_to_group(cpu);
		}
		} else
		ccpu = cpu;

		if (ccpu == cpu \|\| ccpu == group_cpu) {

Admin message