Merge branch 'cfq-merge' of git://brick.kernel.dk/data/git/linux-2.6-block (7baf398f) · Commits · e / devices / android_kernel_samsung_exynos5433

block/cfq-iosched.c

+192 −165

Original line number	Original line	Diff line number	Diff line
	@@ -26,18 +26,12 @@ static const int cfq_back_penalty = 2; /* penalty of a backwards seek */
	static const int cfq_slice_sync = HZ / 10;		static const int cfq_slice_sync = HZ / 10;
	static int cfq_slice_async = HZ / 25;		static int cfq_slice_async = HZ / 25;
	static const int cfq_slice_async_rq = 2;		static const int cfq_slice_async_rq = 2;
	static int cfq_slice_idle = HZ / 100;		static int cfq_slice_idle = HZ / 70;

	#define CFQ_IDLE_GRACE (HZ / 10)		#define CFQ_IDLE_GRACE (HZ / 10)
	#define CFQ_SLICE_SCALE (5)		#define CFQ_SLICE_SCALE (5)

	#define CFQ_KEY_ASYNC (0)		#define CFQ_KEY_ASYNC (0)
	#define CFQ_KEY_ANY (0xffff)

	/*
	* disable queueing at the driver/hardware level
	*/
	static const int cfq_max_depth = 2;

	static DEFINE_RWLOCK(cfq_exit_lock);		static DEFINE_RWLOCK(cfq_exit_lock);

	@@ -102,6 +96,8 @@ static struct completion *ioc_gone;
	#define cfq_cfqq_sync(cfqq) \		#define cfq_cfqq_sync(cfqq) \
	(cfq_cfqq_class_sync(cfqq) \|\| (cfqq)->on_dispatch[SYNC])		(cfq_cfqq_class_sync(cfqq) \|\| (cfqq)->on_dispatch[SYNC])

			#define sample_valid(samples) ((samples) > 80)

	/*		/*
	* Per block device queue structure		* Per block device queue structure
	*/		*/
	@@ -170,7 +166,6 @@ struct cfq_data {
	unsigned int cfq_slice[2];		unsigned int cfq_slice[2];
	unsigned int cfq_slice_async_rq;		unsigned int cfq_slice_async_rq;
	unsigned int cfq_slice_idle;		unsigned int cfq_slice_idle;
	unsigned int cfq_max_depth;

	struct list_head cic_list;		struct list_head cic_list;
	};		};
	@@ -343,17 +338,27 @@ static int cfq_queue_empty(request_queue_t *q)
	return !cfqd->busy_queues;		return !cfqd->busy_queues;
	}		}

			static inline pid_t cfq_queue_pid(struct task_struct *task, int rw)
			{
			if (rw == READ \|\| process_sync(task))
			return task->pid;

			return CFQ_KEY_ASYNC;
			}

	/*		/*
	* Lifted from AS - choose which of crq1 and crq2 that is best served now.		* Lifted from AS - choose which of crq1 and crq2 that is best served now.
	* We choose the request that is closest to the head right now. Distance		* We choose the request that is closest to the head right now. Distance
	* behind the head are penalized and only allowed to a certain extent.		* behind the head is penalized and only allowed to a certain extent.
	*/		*/
	static struct cfq_rq *		static struct cfq_rq *
	cfq_choose_req(struct cfq_data cfqd, struct cfq_rq crq1, struct cfq_rq *crq2)		cfq_choose_req(struct cfq_data cfqd, struct cfq_rq crq1, struct cfq_rq *crq2)
	{		{
	sector_t last, s1, s2, d1 = 0, d2 = 0;		sector_t last, s1, s2, d1 = 0, d2 = 0;
	int r1_wrap = 0, r2_wrap = 0; /* requests are behind the disk head */
	unsigned long back_max;		unsigned long back_max;
			#define CFQ_RQ1_WRAP 0x01 /* request 1 wraps */
			#define CFQ_RQ2_WRAP 0x02 /* request 2 wraps */
			unsigned wrap = 0; /* bit mask: requests behind the disk head? */

	if (crq1 == NULL \|\| crq1 == crq2)		if (crq1 == NULL \|\| crq1 == crq2)
	return crq2;		return crq2;
	@@ -385,35 +390,47 @@ cfq_choose_req(struct cfq_data cfqd, struct cfq_rq crq1, struct cfq_rq *crq2)
	else if (s1 + back_max >= last)		else if (s1 + back_max >= last)
	d1 = (last - s1) * cfqd->cfq_back_penalty;		d1 = (last - s1) * cfqd->cfq_back_penalty;
	else		else
	r1_wrap = 1;		wrap \|= CFQ_RQ1_WRAP;

	if (s2 >= last)		if (s2 >= last)
	d2 = s2 - last;		d2 = s2 - last;
	else if (s2 + back_max >= last)		else if (s2 + back_max >= last)
	d2 = (last - s2) * cfqd->cfq_back_penalty;		d2 = (last - s2) * cfqd->cfq_back_penalty;
	else		else
	r2_wrap = 1;		wrap \|= CFQ_RQ2_WRAP;

	/* Found required data */		/* Found required data */
	if (!r1_wrap && r2_wrap)
			/*
			* By doing switch() on the bit mask "wrap" we avoid having to
			* check two variables for all permutations: --> faster!
			*/
			switch (wrap) {
			case 0: /* common case for CFQ: crq1 and crq2 not wrapped */
			if (d1 < d2)
	return crq1;		return crq1;
	else if (!r2_wrap && r1_wrap)		else if (d2 < d1)
	return crq2;		return crq2;
	else if (r1_wrap && r2_wrap) {		else {
	/* both behind the head */		if (s1 >= s2)
	if (s1 <= s2)
	return crq1;		return crq1;
	else		else
	return crq2;		return crq2;
	}		}

	/* Both requests in front of the head */		case CFQ_RQ2_WRAP:
	if (d1 < d2)
	return crq1;		return crq1;
	else if (d2 < d1)		case CFQ_RQ1_WRAP:
	return crq2;		return crq2;
	else {		case (CFQ_RQ1_WRAP\|CFQ_RQ2_WRAP): /* both crqs wrapped */
	if (s1 >= s2)		default:
			/*
			* Since both rqs are wrapped,
			* start with the one that's further behind head
			* (--> only one back seek required),
			* since back seek takes more time than forward.
			*/
			if (s1 <= s2)
	return crq1;		return crq1;
	else		else
	return crq2;		return crq2;
	@@ -612,15 +629,20 @@ cfq_reposition_crq_rb(struct cfq_queue cfqq, struct cfq_rq crq)
	cfq_add_crq_rb(crq);		cfq_add_crq_rb(crq);
	}		}

	static struct request cfq_find_rq_rb(struct cfq_data cfqd, sector_t sector)		static struct request *
			cfq_find_rq_fmerge(struct cfq_data cfqd, struct bio bio)
	{		{
	struct cfq_queue *cfqq = cfq_find_cfq_hash(cfqd, current->pid, CFQ_KEY_ANY);		struct task_struct *tsk = current;
			pid_t key = cfq_queue_pid(tsk, bio_data_dir(bio));
			struct cfq_queue *cfqq;
	struct rb_node *n;		struct rb_node *n;
			sector_t sector;

			cfqq = cfq_find_cfq_hash(cfqd, key, tsk->ioprio);
	if (!cfqq)		if (!cfqq)
	goto out;		goto out;

			sector = bio->bi_sector + bio_sectors(bio);
	n = cfqq->sort_list.rb_node;		n = cfqq->sort_list.rb_node;
	while (n) {		while (n) {
	struct cfq_rq *crq = rb_entry_crq(n);		struct cfq_rq *crq = rb_entry_crq(n);
	@@ -674,7 +696,7 @@ cfq_merge(request_queue_t q, struct request req, struct bio bio)
	goto out;		goto out;
	}		}

	__rq = cfq_find_rq_rb(cfqd, bio->bi_sector + bio_sectors(bio));		__rq = cfq_find_rq_fmerge(cfqd, bio);
	if (__rq && elv_rq_merge_ok(__rq, bio)) {		if (__rq && elv_rq_merge_ok(__rq, bio)) {
	ret = ELEVATOR_FRONT_MERGE;		ret = ELEVATOR_FRONT_MERGE;
	goto out;		goto out;
	@@ -877,6 +899,7 @@ static struct cfq_queue cfq_set_active_queue(struct cfq_data cfqd)
	static int cfq_arm_slice_timer(struct cfq_data cfqd, struct cfq_queue cfqq)		static int cfq_arm_slice_timer(struct cfq_data cfqd, struct cfq_queue cfqq)

	{		{
			struct cfq_io_context *cic;
	unsigned long sl;		unsigned long sl;

	WARN_ON(!RB_EMPTY(&cfqq->sort_list));		WARN_ON(!RB_EMPTY(&cfqq->sort_list));
	@@ -892,13 +915,23 @@ static int cfq_arm_slice_timer(struct cfq_data cfqd, struct cfq_queue cfqq)
	/*		/*
	* task has exited, don't wait		* task has exited, don't wait
	*/		*/
	if (cfqd->active_cic && !cfqd->active_cic->ioc->task)		cic = cfqd->active_cic;
			if (!cic \|\| !cic->ioc->task)
	return 0;		return 0;

	cfq_mark_cfqq_must_dispatch(cfqq);		cfq_mark_cfqq_must_dispatch(cfqq);
	cfq_mark_cfqq_wait_request(cfqq);		cfq_mark_cfqq_wait_request(cfqq);

	sl = min(cfqq->slice_end - 1, (unsigned long) cfqd->cfq_slice_idle);		sl = min(cfqq->slice_end - 1, (unsigned long) cfqd->cfq_slice_idle);

			/*
			* we don't want to idle for seeks, but we do want to allow
			* fair distribution of slice time for a process doing back-to-back
			* seeks. so allow a little bit of time for him to submit a new rq
			*/
			if (sample_valid(cic->seek_samples) && cic->seek_mean > 131072)
			sl = 2;

	mod_timer(&cfqd->idle_slice_timer, jiffies + sl);		mod_timer(&cfqd->idle_slice_timer, jiffies + sl);
	return 1;		return 1;
	}		}
	@@ -1115,13 +1148,6 @@ cfq_dispatch_requests(request_queue_t *q, int force)
	if (cfqq) {		if (cfqq) {
	int max_dispatch;		int max_dispatch;

	/*
	* if idle window is disabled, allow queue buildup
	*/
	if (!cfq_cfqq_idle_window(cfqq) &&
	cfqd->rq_in_driver >= cfqd->cfq_max_depth)
	return 0;

	cfq_clear_cfqq_must_dispatch(cfqq);		cfq_clear_cfqq_must_dispatch(cfqq);
	cfq_clear_cfqq_wait_request(cfqq);		cfq_clear_cfqq_wait_request(cfqq);
	del_timer(&cfqd->idle_slice_timer);		del_timer(&cfqd->idle_slice_timer);
	@@ -1171,13 +1197,13 @@ __cfq_find_cfq_hash(struct cfq_data *cfqd, unsigned int key, unsigned int prio,
	const int hashval)		const int hashval)
	{		{
	struct hlist_head *hash_list = &cfqd->cfq_hash[hashval];		struct hlist_head *hash_list = &cfqd->cfq_hash[hashval];
	struct hlist_node entry, next;		struct hlist_node *entry;
			struct cfq_queue *__cfqq;

	hlist_for_each_safe(entry, next, hash_list) {		hlist_for_each_entry(__cfqq, entry, hash_list, cfq_hash) {
	struct cfq_queue *__cfqq = list_entry_qhash(entry);
	const unsigned short __p = IOPRIO_PRIO_VALUE(__cfqq->org_ioprio_class, __cfqq->org_ioprio);		const unsigned short __p = IOPRIO_PRIO_VALUE(__cfqq->org_ioprio_class, __cfqq->org_ioprio);

	if (__cfqq->key == key && (__p == prio \|\| prio == CFQ_KEY_ANY))		if (__cfqq->key == key && (__p == prio \|\| !prio))
	return __cfqq;		return __cfqq;
	}		}

	@@ -1190,19 +1216,19 @@ cfq_find_cfq_hash(struct cfq_data *cfqd, unsigned int key, unsigned short prio)
	return __cfq_find_cfq_hash(cfqd, key, prio, hash_long(key, CFQ_QHASH_SHIFT));		return __cfq_find_cfq_hash(cfqd, key, prio, hash_long(key, CFQ_QHASH_SHIFT));
	}		}

	static void cfq_free_io_context(struct cfq_io_context *cic)		static void cfq_free_io_context(struct io_context *ioc)
	{		{
	struct cfq_io_context *__cic;		struct cfq_io_context *__cic;
	struct list_head entry, next;		struct rb_node *n;
	int freed = 1;		int freed = 0;

	list_for_each_safe(entry, next, &cic->list) {		while ((n = rb_first(&ioc->cic_root)) != NULL) {
	__cic = list_entry(entry, struct cfq_io_context, list);		__cic = rb_entry(n, struct cfq_io_context, rb_node);
			rb_erase(&__cic->rb_node, &ioc->cic_root);
	kmem_cache_free(cfq_ioc_pool, __cic);		kmem_cache_free(cfq_ioc_pool, __cic);
	freed++;		freed++;
	}		}

	kmem_cache_free(cfq_ioc_pool, cic);
	if (atomic_sub_and_test(freed, &ioc_count) && ioc_gone)		if (atomic_sub_and_test(freed, &ioc_count) && ioc_gone)
	complete(ioc_gone);		complete(ioc_gone);
	}		}
	@@ -1210,8 +1236,7 @@ static void cfq_free_io_context(struct cfq_io_context *cic)
	static void cfq_trim(struct io_context *ioc)		static void cfq_trim(struct io_context *ioc)
	{		{
	ioc->set_ioprio = NULL;		ioc->set_ioprio = NULL;
	if (ioc->cic)		cfq_free_io_context(ioc);
	cfq_free_io_context(ioc->cic);
	}		}

	/*		/*
	@@ -1250,26 +1275,26 @@ static void cfq_exit_single_io_context(struct cfq_io_context *cic)
	spin_unlock(q->queue_lock);		spin_unlock(q->queue_lock);
	}		}

	static void cfq_exit_io_context(struct cfq_io_context *cic)		static void cfq_exit_io_context(struct io_context *ioc)
	{		{
	struct cfq_io_context *__cic;		struct cfq_io_context *__cic;
	struct list_head *entry;
	unsigned long flags;		unsigned long flags;
			struct rb_node *n;
	local_irq_save(flags);

	/*		/*
	* put the reference this task is holding to the various queues		* put the reference this task is holding to the various queues
	*/		*/
	read_lock(&cfq_exit_lock);		read_lock_irqsave(&cfq_exit_lock, flags);
	list_for_each(entry, &cic->list) {
	__cic = list_entry(entry, struct cfq_io_context, list);		n = rb_first(&ioc->cic_root);
			while (n != NULL) {
			__cic = rb_entry(n, struct cfq_io_context, rb_node);

	cfq_exit_single_io_context(__cic);		cfq_exit_single_io_context(__cic);
			n = rb_next(n);
	}		}

	cfq_exit_single_io_context(cic);		read_unlock_irqrestore(&cfq_exit_lock, flags);
	read_unlock(&cfq_exit_lock);
	local_irq_restore(flags);
	}		}

	static struct cfq_io_context *		static struct cfq_io_context *
	@@ -1278,10 +1303,10 @@ cfq_alloc_io_context(struct cfq_data *cfqd, gfp_t gfp_mask)
	struct cfq_io_context *cic = kmem_cache_alloc(cfq_ioc_pool, gfp_mask);		struct cfq_io_context *cic = kmem_cache_alloc(cfq_ioc_pool, gfp_mask);

	if (cic) {		if (cic) {
	INIT_LIST_HEAD(&cic->list);		RB_CLEAR(&cic->rb_node);
			cic->key = NULL;
	cic->cfqq[ASYNC] = NULL;		cic->cfqq[ASYNC] = NULL;
	cic->cfqq[SYNC] = NULL;		cic->cfqq[SYNC] = NULL;
	cic->key = NULL;
	cic->last_end_request = jiffies;		cic->last_end_request = jiffies;
	cic->ttime_total = 0;		cic->ttime_total = 0;
	cic->ttime_samples = 0;		cic->ttime_samples = 0;
	@@ -1373,15 +1398,17 @@ static inline void changed_ioprio(struct cfq_io_context *cic)
	static int cfq_ioc_set_ioprio(struct io_context *ioc, unsigned int ioprio)		static int cfq_ioc_set_ioprio(struct io_context *ioc, unsigned int ioprio)
	{		{
	struct cfq_io_context *cic;		struct cfq_io_context *cic;
			struct rb_node *n;

	write_lock(&cfq_exit_lock);		write_lock(&cfq_exit_lock);

	cic = ioc->cic;		n = rb_first(&ioc->cic_root);
			while (n != NULL) {
			cic = rb_entry(n, struct cfq_io_context, rb_node);

	changed_ioprio(cic);		changed_ioprio(cic);
			n = rb_next(n);
	list_for_each_entry(cic, &cic->list, list)		}
	changed_ioprio(cic);

	write_unlock(&cfq_exit_lock);		write_unlock(&cfq_exit_lock);

	@@ -1445,106 +1472,86 @@ out:
	return cfqq;		return cfqq;
	}		}

	/*
	* Setup general io context and cfq io context. There can be several cfq
	* io contexts per general io context, if this process is doing io to more
	* than one device managed by cfq. Note that caller is holding a reference to
	* cfqq, so we don't need to worry about it disappearing
	*/
	static struct cfq_io_context *		static struct cfq_io_context *
	cfq_get_io_context(struct cfq_data *cfqd, pid_t pid, gfp_t gfp_mask)		cfq_cic_rb_lookup(struct cfq_data cfqd, struct io_context ioc)
	{		{
	struct io_context *ioc = NULL;		struct rb_node *n = ioc->cic_root.rb_node;
	struct cfq_io_context *cic;		struct cfq_io_context *cic;
			void *key = cfqd;

	might_sleep_if(gfp_mask & __GFP_WAIT);		while (n) {
			cic = rb_entry(n, struct cfq_io_context, rb_node);

			if (key < cic->key)
			n = n->rb_left;
			else if (key > cic->key)
			n = n->rb_right;
			else
			return cic;
			}

	ioc = get_io_context(gfp_mask);
	if (!ioc)
	return NULL;		return NULL;
			}

	restart:		static inline void
	if ((cic = ioc->cic) == NULL) {		cfq_cic_link(struct cfq_data cfqd, struct io_context ioc,
	cic = cfq_alloc_io_context(cfqd, gfp_mask);		struct cfq_io_context *cic)
			{
			struct rb_node **p = &ioc->cic_root.rb_node;
			struct rb_node *parent = NULL;
			struct cfq_io_context *__cic;

	if (cic == NULL)		read_lock(&cfq_exit_lock);
	goto err;

	/*
	* manually increment generic io_context usage count, it
	* cannot go away since we are already holding one ref to it
	*/
	cic->ioc = ioc;		cic->ioc = ioc;
	cic->key = cfqd;		cic->key = cfqd;
	read_lock(&cfq_exit_lock);
	ioc->set_ioprio = cfq_ioc_set_ioprio;		ioc->set_ioprio = cfq_ioc_set_ioprio;
	ioc->cic = cic;
	list_add(&cic->queue_list, &cfqd->cic_list);
	read_unlock(&cfq_exit_lock);
	} else {
	struct cfq_io_context *__cic;

	/*		while (*p) {
	* the first cic on the list is actually the head itself		parent = *p;
	*/		__cic = rb_entry(parent, struct cfq_io_context, rb_node);
	if (cic->key == cfqd)
	goto out;

	if (unlikely(!cic->key)) {		if (cic->key < __cic->key)
	read_lock(&cfq_exit_lock);		p = &(*p)->rb_left;
	if (list_empty(&cic->list))		else if (cic->key > __cic->key)
	ioc->cic = NULL;		p = &(*p)->rb_right;
	else		else
	ioc->cic = list_entry(cic->list.next,		BUG();
	struct cfq_io_context,
	list);
	read_unlock(&cfq_exit_lock);
	kmem_cache_free(cfq_ioc_pool, cic);
	atomic_dec(&ioc_count);
	goto restart;
	}		}

	/*		rb_link_node(&cic->rb_node, parent, p);
	* cic exists, check if we already are there. linear search		rb_insert_color(&cic->rb_node, &ioc->cic_root);
	* should be ok here, the list will usually not be more than		list_add(&cic->queue_list, &cfqd->cic_list);
	* 1 or a few entries long
	*/
	list_for_each_entry(__cic, &cic->list, list) {
	/*
	* this process is already holding a reference to
	* this queue, so no need to get one more
	*/
	if (__cic->key == cfqd) {
	cic = __cic;
	goto out;
	}
	if (unlikely(!__cic->key)) {
	read_lock(&cfq_exit_lock);
	list_del(&__cic->list);
	read_unlock(&cfq_exit_lock);		read_unlock(&cfq_exit_lock);
	kmem_cache_free(cfq_ioc_pool, __cic);
	atomic_dec(&ioc_count);
	goto restart;
	}
	}		}

	/*		/*
	* nope, process doesn't have a cic assoicated with this		* Setup general io context and cfq io context. There can be several cfq
	* cfqq yet. get a new one and add to list		* io contexts per general io context, if this process is doing io to more
			* than one device managed by cfq.
	*/		*/
	__cic = cfq_alloc_io_context(cfqd, gfp_mask);		static struct cfq_io_context *
	if (__cic == NULL)		cfq_get_io_context(struct cfq_data *cfqd, gfp_t gfp_mask)
	goto err;		{
			struct io_context *ioc = NULL;
			struct cfq_io_context *cic;

	__cic->ioc = ioc;		might_sleep_if(gfp_mask & __GFP_WAIT);
	__cic->key = cfqd;
	read_lock(&cfq_exit_lock);		ioc = get_io_context(gfp_mask);
	list_add(&__cic->list, &cic->list);		if (!ioc)
	list_add(&__cic->queue_list, &cfqd->cic_list);		return NULL;
	read_unlock(&cfq_exit_lock);
	cic = __cic;		cic = cfq_cic_rb_lookup(cfqd, ioc);
	}		if (cic)
			goto out;

			cic = cfq_alloc_io_context(cfqd, gfp_mask);
			if (cic == NULL)
			goto err;

			cfq_cic_link(cfqd, ioc, cic);
	out:		out:
	return cic;		return cic;
	err:		err:
	@@ -1577,7 +1584,33 @@ cfq_update_io_thinktime(struct cfq_data cfqd, struct cfq_io_context cic)
	cic->ttime_mean = (cic->ttime_total + 128) / cic->ttime_samples;		cic->ttime_mean = (cic->ttime_total + 128) / cic->ttime_samples;
	}		}

	#define sample_valid(samples) ((samples) > 80)		static void
			cfq_update_io_seektime(struct cfq_data cfqd, struct cfq_io_context cic,
			struct cfq_rq *crq)
			{
			sector_t sdist;
			u64 total;

			if (cic->last_request_pos < crq->request->sector)
			sdist = crq->request->sector - cic->last_request_pos;
			else
			sdist = cic->last_request_pos - crq->request->sector;

			/*
			* Don't allow the seek distance to get too large from the
			* odd fragment, pagein, etc
			*/
			if (cic->seek_samples <= 60) /* second&third seek */
			sdist = min(sdist, (cic->seek_mean * 4) + 210241024);
			else
			sdist = min(sdist, (cic->seek_mean * 4) + 2102464);

			cic->seek_samples = (7*cic->seek_samples + 256) / 8;
			cic->seek_total = (7cic->seek_total + (u64)256sdist) / 8;
			total = cic->seek_total + (cic->seek_samples/2);
			do_div(total, cic->seek_samples);
			cic->seek_mean = (sector_t)total;
			}

	/*		/*
	* Disable idle window if the process thinks too long or seeks so much that		* Disable idle window if the process thinks too long or seeks so much that
	@@ -1690,9 +1723,11 @@ cfq_crq_enqueued(struct cfq_data cfqd, struct cfq_queue cfqq,
	cic = crq->io_context;		cic = crq->io_context;

	cfq_update_io_thinktime(cfqd, cic);		cfq_update_io_thinktime(cfqd, cic);
			cfq_update_io_seektime(cfqd, cic, crq);
	cfq_update_idle_window(cfqd, cfqq, cic);		cfq_update_idle_window(cfqd, cfqq, cic);

	cic->last_queue = jiffies;		cic->last_queue = jiffies;
			cic->last_request_pos = crq->request->sector + crq->request->nr_sectors;

	if (cfqq == cfqd->active_queue) {		if (cfqq == cfqd->active_queue) {
	/*		/*
	@@ -1825,14 +1860,6 @@ static void cfq_prio_boost(struct cfq_queue *cfqq)
	cfq_resort_rr_list(cfqq, 0);		cfq_resort_rr_list(cfqq, 0);
	}		}

	static inline pid_t cfq_queue_pid(struct task_struct *task, int rw)
	{
	if (rw == READ \|\| process_sync(task))
	return task->pid;

	return CFQ_KEY_ASYNC;
	}

	static inline int		static inline int
	__cfq_may_queue(struct cfq_data cfqd, struct cfq_queue cfqq,		__cfq_may_queue(struct cfq_data cfqd, struct cfq_queue cfqq,
	struct task_struct *task, int rw)		struct task_struct *task, int rw)
	@@ -1965,7 +1992,7 @@ cfq_set_request(request_queue_t q, struct request rq, struct bio *bio,

	might_sleep_if(gfp_mask & __GFP_WAIT);		might_sleep_if(gfp_mask & __GFP_WAIT);

	cic = cfq_get_io_context(cfqd, key, gfp_mask);		cic = cfq_get_io_context(cfqd, gfp_mask);

	spin_lock_irqsave(q->queue_lock, flags);		spin_lock_irqsave(q->queue_lock, flags);

	@@ -2133,10 +2160,13 @@ static void cfq_exit_queue(elevator_t *e)
	request_queue_t *q = cfqd->queue;		request_queue_t *q = cfqd->queue;

	cfq_shutdown_timer_wq(cfqd);		cfq_shutdown_timer_wq(cfqd);

	write_lock(&cfq_exit_lock);		write_lock(&cfq_exit_lock);
	spin_lock_irq(q->queue_lock);		spin_lock_irq(q->queue_lock);

	if (cfqd->active_queue)		if (cfqd->active_queue)
	__cfq_slice_expired(cfqd, cfqd->active_queue, 0);		__cfq_slice_expired(cfqd, cfqd->active_queue, 0);

	while (!list_empty(&cfqd->cic_list)) {		while (!list_empty(&cfqd->cic_list)) {
	struct cfq_io_context *cic = list_entry(cfqd->cic_list.next,		struct cfq_io_context *cic = list_entry(cfqd->cic_list.next,
	struct cfq_io_context,		struct cfq_io_context,
	@@ -2152,6 +2182,7 @@ static void cfq_exit_queue(elevator_t *e)
	cic->key = NULL;		cic->key = NULL;
	list_del_init(&cic->queue_list);		list_del_init(&cic->queue_list);
	}		}

	spin_unlock_irq(q->queue_lock);		spin_unlock_irq(q->queue_lock);
	write_unlock(&cfq_exit_lock);		write_unlock(&cfq_exit_lock);

	@@ -2227,7 +2258,6 @@ static int cfq_init_queue(request_queue_t q, elevator_t e)
	cfqd->cfq_slice[1] = cfq_slice_sync;		cfqd->cfq_slice[1] = cfq_slice_sync;
	cfqd->cfq_slice_async_rq = cfq_slice_async_rq;		cfqd->cfq_slice_async_rq = cfq_slice_async_rq;
	cfqd->cfq_slice_idle = cfq_slice_idle;		cfqd->cfq_slice_idle = cfq_slice_idle;
	cfqd->cfq_max_depth = cfq_max_depth;

	return 0;		return 0;
	out_crqpool:		out_crqpool:
	@@ -2310,7 +2340,6 @@ SHOW_FUNCTION(cfq_slice_idle_show, cfqd->cfq_slice_idle, 1);
	SHOW_FUNCTION(cfq_slice_sync_show, cfqd->cfq_slice[1], 1);		SHOW_FUNCTION(cfq_slice_sync_show, cfqd->cfq_slice[1], 1);
	SHOW_FUNCTION(cfq_slice_async_show, cfqd->cfq_slice[0], 1);		SHOW_FUNCTION(cfq_slice_async_show, cfqd->cfq_slice[0], 1);
	SHOW_FUNCTION(cfq_slice_async_rq_show, cfqd->cfq_slice_async_rq, 0);		SHOW_FUNCTION(cfq_slice_async_rq_show, cfqd->cfq_slice_async_rq, 0);
	SHOW_FUNCTION(cfq_max_depth_show, cfqd->cfq_max_depth, 0);
	#undef SHOW_FUNCTION		#undef SHOW_FUNCTION

	#define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, __CONV) \		#define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, __CONV) \
	@@ -2339,7 +2368,6 @@ STORE_FUNCTION(cfq_slice_idle_store, &cfqd->cfq_slice_idle, 0, UINT_MAX, 1);
	STORE_FUNCTION(cfq_slice_sync_store, &cfqd->cfq_slice[1], 1, UINT_MAX, 1);		STORE_FUNCTION(cfq_slice_sync_store, &cfqd->cfq_slice[1], 1, UINT_MAX, 1);
	STORE_FUNCTION(cfq_slice_async_store, &cfqd->cfq_slice[0], 1, UINT_MAX, 1);		STORE_FUNCTION(cfq_slice_async_store, &cfqd->cfq_slice[0], 1, UINT_MAX, 1);
	STORE_FUNCTION(cfq_slice_async_rq_store, &cfqd->cfq_slice_async_rq, 1, UINT_MAX, 0);		STORE_FUNCTION(cfq_slice_async_rq_store, &cfqd->cfq_slice_async_rq, 1, UINT_MAX, 0);
	STORE_FUNCTION(cfq_max_depth_store, &cfqd->cfq_max_depth, 1, UINT_MAX, 0);
	#undef STORE_FUNCTION		#undef STORE_FUNCTION

	#define CFQ_ATTR(name) \		#define CFQ_ATTR(name) \
	@@ -2356,7 +2384,6 @@ static struct elv_fs_entry cfq_attrs[] = {
	CFQ_ATTR(slice_async),		CFQ_ATTR(slice_async),
	CFQ_ATTR(slice_async_rq),		CFQ_ATTR(slice_async_rq),
	CFQ_ATTR(slice_idle),		CFQ_ATTR(slice_idle),
	CFQ_ATTR(max_depth),
	__ATTR_NULL		__ATTR_NULL
	};		};

block/ll_rw_blk.c

+15 −6

Original line number	Original line	Diff line number	Diff line
	@@ -3539,11 +3539,17 @@ void put_io_context(struct io_context *ioc)
	BUG_ON(atomic_read(&ioc->refcount) == 0);		BUG_ON(atomic_read(&ioc->refcount) == 0);

	if (atomic_dec_and_test(&ioc->refcount)) {		if (atomic_dec_and_test(&ioc->refcount)) {
			struct cfq_io_context *cic;

	rcu_read_lock();		rcu_read_lock();
	if (ioc->aic && ioc->aic->dtor)		if (ioc->aic && ioc->aic->dtor)
	ioc->aic->dtor(ioc->aic);		ioc->aic->dtor(ioc->aic);
	if (ioc->cic && ioc->cic->dtor)		if (ioc->cic_root.rb_node != NULL) {
	ioc->cic->dtor(ioc->cic);		struct rb_node *n = rb_first(&ioc->cic_root);

			cic = rb_entry(n, struct cfq_io_context, rb_node);
			cic->dtor(ioc);
			}
	rcu_read_unlock();		rcu_read_unlock();

	kmem_cache_free(iocontext_cachep, ioc);		kmem_cache_free(iocontext_cachep, ioc);
	@@ -3556,6 +3562,7 @@ void exit_io_context(void)
	{		{
	unsigned long flags;		unsigned long flags;
	struct io_context *ioc;		struct io_context *ioc;
			struct cfq_io_context *cic;

	local_irq_save(flags);		local_irq_save(flags);
	task_lock(current);		task_lock(current);
	@@ -3567,8 +3574,10 @@ void exit_io_context(void)

	if (ioc->aic && ioc->aic->exit)		if (ioc->aic && ioc->aic->exit)
	ioc->aic->exit(ioc->aic);		ioc->aic->exit(ioc->aic);
	if (ioc->cic && ioc->cic->exit)		if (ioc->cic_root.rb_node != NULL) {
	ioc->cic->exit(ioc->cic);		cic = rb_entry(rb_first(&ioc->cic_root), struct cfq_io_context, rb_node);
			cic->exit(ioc);
			}

	put_io_context(ioc);		put_io_context(ioc);
	}		}
	@@ -3598,7 +3607,7 @@ struct io_context *current_io_context(gfp_t gfp_flags)
	ret->last_waited = jiffies; /* doesn't matter... */		ret->last_waited = jiffies; /* doesn't matter... */
	ret->nr_batch_requests = 0; /* because this is 0 */		ret->nr_batch_requests = 0; /* because this is 0 */
	ret->aic = NULL;		ret->aic = NULL;
	ret->cic = NULL;		ret->cic_root.rb_node = NULL;
	tsk->io_context = ret;		tsk->io_context = ret;
	}		}

include/linux/blkdev.h

+13 −9

Original line number	Original line	Diff line number	Diff line
	@@ -55,25 +55,29 @@ struct as_io_context {

	struct cfq_queue;		struct cfq_queue;
	struct cfq_io_context {		struct cfq_io_context {
	/*		struct rb_node rb_node;
	* circular list of cfq_io_contexts belonging to a process io context
	*/
	struct list_head list;
	struct cfq_queue *cfqq[2];
	void *key;		void *key;

			struct cfq_queue *cfqq[2];

	struct io_context *ioc;		struct io_context *ioc;

	unsigned long last_end_request;		unsigned long last_end_request;
			sector_t last_request_pos;
	unsigned long last_queue;		unsigned long last_queue;

	unsigned long ttime_total;		unsigned long ttime_total;
	unsigned long ttime_samples;		unsigned long ttime_samples;
	unsigned long ttime_mean;		unsigned long ttime_mean;

			unsigned int seek_samples;
			u64 seek_total;
			sector_t seek_mean;

	struct list_head queue_list;		struct list_head queue_list;

	void (dtor)(struct cfq_io_context );		void (dtor)(struct io_context ); /* destructor */
	void (exit)(struct cfq_io_context );		void (exit)(struct io_context ); /* called on task exit */
	};		};

	/*		/*
	@@ -94,7 +98,7 @@ struct io_context {
	int nr_batch_requests; /* Number of requests left in the batch */		int nr_batch_requests; /* Number of requests left in the batch */

	struct as_io_context *aic;		struct as_io_context *aic;
	struct cfq_io_context *cic;		struct rb_root cic_root;
	};		};

	void put_io_context(struct io_context *ioc);		void put_io_context(struct io_context *ioc);