Merge branch 'for-2.6.40/core' of git://git.kernel.dk/linux-2.6-block (798ce8f1) · Commits · 戴 / test

Documentation/ABI/testing/sysfs-block

+64 −0

Original line number	Diff line number	Diff line
		@@ -142,3 +142,67 @@ Description:
		with the previous I/O request are enabled. When set to 2,
		all merge tries are disabled. The default value is 0 -
		which enables all types of merge tries.

		What: /sys/block/<disk>/discard_alignment
		Date: May 2011
		Contact: Martin K. Petersen <martin.petersen@oracle.com>
		Description:
		Devices that support discard functionality may
		internally allocate space in units that are bigger than
		the exported logical block size. The discard_alignment
		parameter indicates how many bytes the beginning of the
		device is offset from the internal allocation unit's
		natural alignment.

		What: /sys/block/<disk>/<partition>/discard_alignment
		Date: May 2011
		Contact: Martin K. Petersen <martin.petersen@oracle.com>
		Description:
		Devices that support discard functionality may
		internally allocate space in units that are bigger than
		the exported logical block size. The discard_alignment
		parameter indicates how many bytes the beginning of the
		partition is offset from the internal allocation unit's
		natural alignment.

		What: /sys/block/<disk>/queue/discard_granularity
		Date: May 2011
		Contact: Martin K. Petersen <martin.petersen@oracle.com>
		Description:
		Devices that support discard functionality may
		internally allocate space using units that are bigger
		than the logical block size. The discard_granularity
		parameter indicates the size of the internal allocation
		unit in bytes if reported by the device. Otherwise the
		discard_granularity will be set to match the device's
		physical block size. A discard_granularity of 0 means
		that the device does not support discard functionality.

		What: /sys/block/<disk>/queue/discard_max_bytes
		Date: May 2011
		Contact: Martin K. Petersen <martin.petersen@oracle.com>
		Description:
		Devices that support discard functionality may have
		internal limits on the number of bytes that can be
		trimmed or unmapped in a single operation. Some storage
		protocols also have inherent limits on the number of
		blocks that can be described in a single command. The
		discard_max_bytes parameter is set by the device driver
		to the maximum number of bytes that can be discarded in
		a single operation. Discard requests issued to the
		device must not exceed this limit. A discard_max_bytes
		value of 0 means that the device does not support
		discard functionality.

		What: /sys/block/<disk>/queue/discard_zeroes_data
		Date: May 2011
		Contact: Martin K. Petersen <martin.petersen@oracle.com>
		Description:
		Devices that support discard functionality may return
		stale or random data when a previously discarded block
		is read back. This can cause problems if the filesystem
		expects discarded blocks to be explicitly cleared. If a
		device reports that it deterministically returns zeroes
		when a discarded area is read the discard_zeroes_data
		parameter will be set to one. Otherwise it will be 0 and
		the result of reading a discarded area is undefined.

block/blk-cgroup.c

+162 −38

Original line number	Diff line number	Diff line
		@@ -385,25 +385,40 @@ void blkiocg_update_timeslice_used(struct blkio_group *blkg, unsigned long time,

		spin_lock_irqsave(&blkg->stats_lock, flags);
		blkg->stats.time += time;
		#ifdef CONFIG_DEBUG_BLK_CGROUP
		blkg->stats.unaccounted_time += unaccounted_time;
		#endif
		spin_unlock_irqrestore(&blkg->stats_lock, flags);
		}
		EXPORT_SYMBOL_GPL(blkiocg_update_timeslice_used);

		/*
		* should be called under rcu read lock or queue lock to make sure blkg pointer
		* is valid.
		*/
		void blkiocg_update_dispatch_stats(struct blkio_group *blkg,
		uint64_t bytes, bool direction, bool sync)
		{
		struct blkio_group_stats *stats;
		struct blkio_group_stats_cpu *stats_cpu;
		unsigned long flags;

		spin_lock_irqsave(&blkg->stats_lock, flags);
		stats = &blkg->stats;
		stats->sectors += bytes >> 9;
		blkio_add_stat(stats->stat_arr[BLKIO_STAT_SERVICED], 1, direction,
		sync);
		blkio_add_stat(stats->stat_arr[BLKIO_STAT_SERVICE_BYTES], bytes,
		direction, sync);
		spin_unlock_irqrestore(&blkg->stats_lock, flags);
		/*
		* Disabling interrupts to provide mutual exclusion between two
		* writes on same cpu. It probably is not needed for 64bit. Not
		* optimizing that case yet.
		*/
		local_irq_save(flags);

		stats_cpu = this_cpu_ptr(blkg->stats_cpu);

		u64_stats_update_begin(&stats_cpu->syncp);
		stats_cpu->sectors += bytes >> 9;
		blkio_add_stat(stats_cpu->stat_arr_cpu[BLKIO_STAT_CPU_SERVICED],
		1, direction, sync);
		blkio_add_stat(stats_cpu->stat_arr_cpu[BLKIO_STAT_CPU_SERVICE_BYTES],
		bytes, direction, sync);
		u64_stats_update_end(&stats_cpu->syncp);
		local_irq_restore(flags);
		}
		EXPORT_SYMBOL_GPL(blkiocg_update_dispatch_stats);

		@@ -426,18 +441,44 @@ void blkiocg_update_completion_stats(struct blkio_group *blkg,
		}
		EXPORT_SYMBOL_GPL(blkiocg_update_completion_stats);

		/* Merged stats are per cpu. */
		void blkiocg_update_io_merged_stats(struct blkio_group *blkg, bool direction,
		bool sync)
		{
		struct blkio_group_stats_cpu *stats_cpu;
		unsigned long flags;

		spin_lock_irqsave(&blkg->stats_lock, flags);
		blkio_add_stat(blkg->stats.stat_arr[BLKIO_STAT_MERGED], 1, direction,
		sync);
		spin_unlock_irqrestore(&blkg->stats_lock, flags);
		/*
		* Disabling interrupts to provide mutual exclusion between two
		* writes on same cpu. It probably is not needed for 64bit. Not
		* optimizing that case yet.
		*/
		local_irq_save(flags);

		stats_cpu = this_cpu_ptr(blkg->stats_cpu);

		u64_stats_update_begin(&stats_cpu->syncp);
		blkio_add_stat(stats_cpu->stat_arr_cpu[BLKIO_STAT_CPU_MERGED], 1,
		direction, sync);
		u64_stats_update_end(&stats_cpu->syncp);
		local_irq_restore(flags);
		}
		EXPORT_SYMBOL_GPL(blkiocg_update_io_merged_stats);

		/*
		* This function allocates the per cpu stats for blkio_group. Should be called
		* from sleepable context as alloc_per_cpu() requires that.
		*/
		int blkio_alloc_blkg_stats(struct blkio_group *blkg)
		{
		/* Allocate memory for per cpu stats */
		blkg->stats_cpu = alloc_percpu(struct blkio_group_stats_cpu);
		if (!blkg->stats_cpu)
		return -ENOMEM;
		return 0;
		}
		EXPORT_SYMBOL_GPL(blkio_alloc_blkg_stats);

		void blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,
		struct blkio_group blkg, void key, dev_t dev,
		enum blkio_policy_id plid)
		@@ -508,6 +549,30 @@ struct blkio_group blkiocg_lookup_group(struct blkio_cgroup blkcg, void *key)
		}
		EXPORT_SYMBOL_GPL(blkiocg_lookup_group);

		static void blkio_reset_stats_cpu(struct blkio_group *blkg)
		{
		struct blkio_group_stats_cpu *stats_cpu;
		int i, j, k;
		/*
		* Note: On 64 bit arch this should not be an issue. This has the
		* possibility of returning some inconsistent value on 32bit arch
		* as 64bit update on 32bit is non atomic. Taking care of this
		* corner case makes code very complicated, like sending IPIs to
		* cpus, taking care of stats of offline cpus etc.
		*
		* reset stats is anyway more of a debug feature and this sounds a
		* corner case. So I am not complicating the code yet until and
		* unless this becomes a real issue.
		*/
		for_each_possible_cpu(i) {
		stats_cpu = per_cpu_ptr(blkg->stats_cpu, i);
		stats_cpu->sectors = 0;
		for(j = 0; j < BLKIO_STAT_CPU_NR; j++)
		for (k = 0; k < BLKIO_STAT_TOTAL; k++)
		stats_cpu->stat_arr_cpu[j][k] = 0;
		}
		}

		static int
		blkiocg_reset_stats(struct cgroup cgroup, struct cftype cftype, u64 val)
		{
		@@ -552,7 +617,11 @@ blkiocg_reset_stats(struct cgroup cgroup, struct cftype cftype, u64 val)
		}
		#endif
		spin_unlock(&blkg->stats_lock);

		/* Reset Per cpu stats which don't take blkg->stats_lock */
		blkio_reset_stats_cpu(blkg);
		}

		spin_unlock_irq(&blkcg->lock);
		return 0;
		}
		@@ -598,6 +667,59 @@ static uint64_t blkio_fill_stat(char *str, int chars_left, uint64_t val,
		return val;
		}


		static uint64_t blkio_read_stat_cpu(struct blkio_group *blkg,
		enum stat_type_cpu type, enum stat_sub_type sub_type)
		{
		int cpu;
		struct blkio_group_stats_cpu *stats_cpu;
		u64 val = 0, tval;

		for_each_possible_cpu(cpu) {
		unsigned int start;
		stats_cpu = per_cpu_ptr(blkg->stats_cpu, cpu);

		do {
		start = u64_stats_fetch_begin(&stats_cpu->syncp);
		if (type == BLKIO_STAT_CPU_SECTORS)
		tval = stats_cpu->sectors;
		else
		tval = stats_cpu->stat_arr_cpu[type][sub_type];
		} while(u64_stats_fetch_retry(&stats_cpu->syncp, start));

		val += tval;
		}

		return val;
		}

		static uint64_t blkio_get_stat_cpu(struct blkio_group *blkg,
		struct cgroup_map_cb *cb, dev_t dev, enum stat_type_cpu type)
		{
		uint64_t disk_total, val;
		char key_str[MAX_KEY_LEN];
		enum stat_sub_type sub_type;

		if (type == BLKIO_STAT_CPU_SECTORS) {
		val = blkio_read_stat_cpu(blkg, type, 0);
		return blkio_fill_stat(key_str, MAX_KEY_LEN - 1, val, cb, dev);
		}

		for (sub_type = BLKIO_STAT_READ; sub_type < BLKIO_STAT_TOTAL;
		sub_type++) {
		blkio_get_key_name(sub_type, dev, key_str, MAX_KEY_LEN, false);
		val = blkio_read_stat_cpu(blkg, type, sub_type);
		cb->fill(cb, key_str, val);
		}

		disk_total = blkio_read_stat_cpu(blkg, type, BLKIO_STAT_READ) +
		blkio_read_stat_cpu(blkg, type, BLKIO_STAT_WRITE);

		blkio_get_key_name(BLKIO_STAT_TOTAL, dev, key_str, MAX_KEY_LEN, false);
		cb->fill(cb, key_str, disk_total);
		return disk_total;
		}

		/* This should be called with blkg->stats_lock held */
		static uint64_t blkio_get_stat(struct blkio_group *blkg,
		struct cgroup_map_cb *cb, dev_t dev, enum stat_type type)
		@@ -609,9 +731,6 @@ static uint64_t blkio_get_stat(struct blkio_group *blkg,
		if (type == BLKIO_STAT_TIME)
		return blkio_fill_stat(key_str, MAX_KEY_LEN - 1,
		blkg->stats.time, cb, dev);
		if (type == BLKIO_STAT_SECTORS)
		return blkio_fill_stat(key_str, MAX_KEY_LEN - 1,
		blkg->stats.sectors, cb, dev);
		#ifdef CONFIG_DEBUG_BLK_CGROUP
		if (type == BLKIO_STAT_UNACCOUNTED_TIME)
		return blkio_fill_stat(key_str, MAX_KEY_LEN - 1,
		@@ -1075,8 +1194,8 @@ static int blkiocg_file_read(struct cgroup cgrp, struct cftype cft,
		}

		static int blkio_read_blkg_stats(struct blkio_cgroup *blkcg,
		struct cftype cft, struct cgroup_map_cb cb, enum stat_type type,
		bool show_total)
		struct cftype cft, struct cgroup_map_cb cb,
		enum stat_type type, bool show_total, bool pcpu)
		{
		struct blkio_group *blkg;
		struct hlist_node *n;
		@@ -1087,12 +1206,17 @@ static int blkio_read_blkg_stats(struct blkio_cgroup *blkcg,
		if (blkg->dev) {
		if (!cftype_blkg_same_policy(cft, blkg))
		continue;
		if (pcpu)
		cgroup_total += blkio_get_stat_cpu(blkg, cb,
		blkg->dev, type);
		else {
		spin_lock_irq(&blkg->stats_lock);
		cgroup_total += blkio_get_stat(blkg, cb, blkg->dev,
		type);
		cgroup_total += blkio_get_stat(blkg, cb,
		blkg->dev, type);
		spin_unlock_irq(&blkg->stats_lock);
		}
		}
		}
		if (show_total)
		cb->fill(cb, "Total", cgroup_total);
		rcu_read_unlock();
		@@ -1114,47 +1238,47 @@ static int blkiocg_file_read_map(struct cgroup cgrp, struct cftype cft,
		switch(name) {
		case BLKIO_PROP_time:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_TIME, 0);
		BLKIO_STAT_TIME, 0, 0);
		case BLKIO_PROP_sectors:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_SECTORS, 0);
		BLKIO_STAT_CPU_SECTORS, 0, 1);
		case BLKIO_PROP_io_service_bytes:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_SERVICE_BYTES, 1);
		BLKIO_STAT_CPU_SERVICE_BYTES, 1, 1);
		case BLKIO_PROP_io_serviced:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_SERVICED, 1);
		BLKIO_STAT_CPU_SERVICED, 1, 1);
		case BLKIO_PROP_io_service_time:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_SERVICE_TIME, 1);
		BLKIO_STAT_SERVICE_TIME, 1, 0);
		case BLKIO_PROP_io_wait_time:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_WAIT_TIME, 1);
		BLKIO_STAT_WAIT_TIME, 1, 0);
		case BLKIO_PROP_io_merged:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_MERGED, 1);
		BLKIO_STAT_CPU_MERGED, 1, 1);
		case BLKIO_PROP_io_queued:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_QUEUED, 1);
		BLKIO_STAT_QUEUED, 1, 0);
		#ifdef CONFIG_DEBUG_BLK_CGROUP
		case BLKIO_PROP_unaccounted_time:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_UNACCOUNTED_TIME, 0);
		BLKIO_STAT_UNACCOUNTED_TIME, 0, 0);
		case BLKIO_PROP_dequeue:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_DEQUEUE, 0);
		BLKIO_STAT_DEQUEUE, 0, 0);
		case BLKIO_PROP_avg_queue_size:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_AVG_QUEUE_SIZE, 0);
		BLKIO_STAT_AVG_QUEUE_SIZE, 0, 0);
		case BLKIO_PROP_group_wait_time:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_GROUP_WAIT_TIME, 0);
		BLKIO_STAT_GROUP_WAIT_TIME, 0, 0);
		case BLKIO_PROP_idle_time:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_IDLE_TIME, 0);
		BLKIO_STAT_IDLE_TIME, 0, 0);
		case BLKIO_PROP_empty_time:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_EMPTY_TIME, 0);
		BLKIO_STAT_EMPTY_TIME, 0, 0);
		#endif
		default:
		BUG();
		@@ -1164,10 +1288,10 @@ static int blkiocg_file_read_map(struct cgroup cgrp, struct cftype cft,
		switch(name){
		case BLKIO_THROTL_io_service_bytes:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_SERVICE_BYTES, 1);
		BLKIO_STAT_CPU_SERVICE_BYTES, 1, 1);
		case BLKIO_THROTL_io_serviced:
		return blkio_read_blkg_stats(blkcg, cft, cb,
		BLKIO_STAT_SERVICED, 1);
		BLKIO_STAT_CPU_SERVICED, 1, 1);
		default:
		BUG();
		}

block/blk-cgroup.h

+29 −11

Original line number	Diff line number	Diff line
		@@ -14,6 +14,7 @@
		*/

		#include <linux/cgroup.h>
		#include <linux/u64_stats_sync.h>

		enum blkio_policy_id {
		BLKIO_POLICY_PROP = 0, /* Proportional Bandwidth division */
		@@ -36,22 +37,15 @@ enum stat_type {
		* request completion for IOs doen by this cgroup. This may not be
		* accurate when NCQ is turned on. */
		BLKIO_STAT_SERVICE_TIME = 0,
		/* Total bytes transferred */
		BLKIO_STAT_SERVICE_BYTES,
		/* Total IOs serviced, post merge */
		BLKIO_STAT_SERVICED,
		/* Total time spent waiting in scheduler queue in ns */
		BLKIO_STAT_WAIT_TIME,
		/* Number of IOs merged */
		BLKIO_STAT_MERGED,
		/* Number of IOs queued up */
		BLKIO_STAT_QUEUED,
		/* All the single valued stats go below this */
		BLKIO_STAT_TIME,
		BLKIO_STAT_SECTORS,
		#ifdef CONFIG_DEBUG_BLK_CGROUP
		/* Time not charged to this cgroup */
		BLKIO_STAT_UNACCOUNTED_TIME,
		#ifdef CONFIG_DEBUG_BLK_CGROUP
		BLKIO_STAT_AVG_QUEUE_SIZE,
		BLKIO_STAT_IDLE_TIME,
		BLKIO_STAT_EMPTY_TIME,
		@@ -60,6 +54,18 @@ enum stat_type {
		#endif
		};

		/* Per cpu stats */
		enum stat_type_cpu {
		BLKIO_STAT_CPU_SECTORS,
		/* Total bytes transferred */
		BLKIO_STAT_CPU_SERVICE_BYTES,
		/* Total IOs serviced, post merge */
		BLKIO_STAT_CPU_SERVICED,
		/* Number of IOs merged */
		BLKIO_STAT_CPU_MERGED,
		BLKIO_STAT_CPU_NR
		};

		enum stat_sub_type {
		BLKIO_STAT_READ = 0,
		BLKIO_STAT_WRITE,
		@@ -116,11 +122,11 @@ struct blkio_cgroup {
		struct blkio_group_stats {
		/* total disk time and nr sectors dispatched by this group */
		uint64_t time;
		uint64_t sectors;
		/* Time not charged to this cgroup */
		uint64_t unaccounted_time;
		uint64_t stat_arr[BLKIO_STAT_QUEUED + 1][BLKIO_STAT_TOTAL];
		#ifdef CONFIG_DEBUG_BLK_CGROUP
		/* Time not charged to this cgroup */
		uint64_t unaccounted_time;

		/* Sum of number of IOs queued across all samples */
		uint64_t avg_queue_size_sum;
		/* Count of samples taken for average */
		@@ -145,6 +151,13 @@ struct blkio_group_stats {
		#endif
		};

		/* Per cpu blkio group stats */
		struct blkio_group_stats_cpu {
		uint64_t sectors;
		uint64_t stat_arr_cpu[BLKIO_STAT_CPU_NR][BLKIO_STAT_TOTAL];
		struct u64_stats_sync syncp;
		};

		struct blkio_group {
		/* An rcu protected unique identifier for the group */
		void *key;
		@@ -160,6 +173,8 @@ struct blkio_group {
		/* Need to serialize the stats in the case of reset/update */
		spinlock_t stats_lock;
		struct blkio_group_stats stats;
		/* Per cpu stats pointer */
		struct blkio_group_stats_cpu __percpu *stats_cpu;
		};

		struct blkio_policy_node {
		@@ -295,6 +310,7 @@ extern struct blkio_cgroup task_blkio_cgroup(struct task_struct tsk);
		extern void blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,
		struct blkio_group blkg, void key, dev_t dev,
		enum blkio_policy_id plid);
		extern int blkio_alloc_blkg_stats(struct blkio_group *blkg);
		extern int blkiocg_del_blkio_group(struct blkio_group *blkg);
		extern struct blkio_group blkiocg_lookup_group(struct blkio_cgroup blkcg,
		void *key);
		@@ -322,6 +338,8 @@ static inline void blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,
		struct blkio_group blkg, void key, dev_t dev,
		enum blkio_policy_id plid) {}

		static inline int blkio_alloc_blkg_stats(struct blkio_group *blkg) { return 0; }

		static inline int
		blkiocg_del_blkio_group(struct blkio_group *blkg) { return 0; }

block/blk-core.c

+4 −28

Original line number	Diff line number	Diff line
		@@ -569,8 +569,6 @@ int blk_get_queue(struct request_queue *q)

		static inline void blk_free_request(struct request_queue q, struct request rq)
		{
		BUG_ON(rq->cmd_flags & REQ_ON_PLUG);

		if (rq->cmd_flags & REQ_ELVPRIV)
		elv_put_request(q, rq);
		mempool_free(rq, q->rq.rq_pool);
		@@ -1110,14 +1108,6 @@ static bool bio_attempt_back_merge(struct request_queue q, struct request req,
		{
		const int ff = bio->bi_rw & REQ_FAILFAST_MASK;

		/*
		* Debug stuff, kill later
		*/
		if (!rq_mergeable(req)) {
		blk_dump_rq_flags(req, "back");
		return false;
		}

		if (!ll_back_merge_fn(q, req, bio))
		return false;

		@@ -1132,6 +1122,7 @@ static bool bio_attempt_back_merge(struct request_queue q, struct request req,
		req->ioprio = ioprio_best(req->ioprio, bio_prio(bio));

		drive_stat_acct(req, 0);
		elv_bio_merged(q, req, bio);
		return true;
		}

		@@ -1141,14 +1132,6 @@ static bool bio_attempt_front_merge(struct request_queue *q,
		const int ff = bio->bi_rw & REQ_FAILFAST_MASK;
		sector_t sector;

		/*
		* Debug stuff, kill later
		*/
		if (!rq_mergeable(req)) {
		blk_dump_rq_flags(req, "front");
		return false;
		}

		if (!ll_front_merge_fn(q, req, bio))
		return false;

		@@ -1173,6 +1156,7 @@ static bool bio_attempt_front_merge(struct request_queue *q,
		req->ioprio = ioprio_best(req->ioprio, bio_prio(bio));

		drive_stat_acct(req, 0);
		elv_bio_merged(q, req, bio);
		return true;
		}

		@@ -1258,14 +1242,12 @@ static int __make_request(struct request_queue q, struct bio bio)

		el_ret = elv_merge(q, &req, bio);
		if (el_ret == ELEVATOR_BACK_MERGE) {
		BUG_ON(req->cmd_flags & REQ_ON_PLUG);
		if (bio_attempt_back_merge(q, req, bio)) {
		if (!attempt_back_merge(q, req))
		elv_merged_request(q, req, el_ret);
		goto out_unlock;
		}
		} else if (el_ret == ELEVATOR_FRONT_MERGE) {
		BUG_ON(req->cmd_flags & REQ_ON_PLUG);
		if (bio_attempt_front_merge(q, req, bio)) {
		if (!attempt_front_merge(q, req))
		elv_merged_request(q, req, el_ret);
		@@ -1320,10 +1302,6 @@ get_rq:
		if (__rq->q != q)
		plug->should_sort = 1;
		}
		/*
		* Debug flag, kill later
		*/
		req->cmd_flags \|= REQ_ON_PLUG;
		list_add_tail(&req->queuelist, &plug->list);
		drive_stat_acct(req, 1);
		} else {
		@@ -1550,7 +1528,8 @@ static inline void __generic_make_request(struct bio *bio)
		goto end_io;
		}

		blk_throtl_bio(q, &bio);
		if (blk_throtl_bio(q, &bio))
		goto end_io;

		/*
		* If bio = NULL, bio has been throttled and will be submitted
		@@ -2748,7 +2727,6 @@ void blk_flush_plug_list(struct blk_plug *plug, bool from_schedule)
		while (!list_empty(&list)) {
		rq = list_entry_rq(list.next);
		list_del_init(&rq->queuelist);
		BUG_ON(!(rq->cmd_flags & REQ_ON_PLUG));
		BUG_ON(!rq->q);
		if (rq->q != q) {
		/*
		@@ -2760,8 +2738,6 @@ void blk_flush_plug_list(struct blk_plug *plug, bool from_schedule)
		depth = 0;
		spin_lock(q->queue_lock);
		}
		rq->cmd_flags &= ~REQ_ON_PLUG;

		/*
		* rq is already accounted, so use raw insert
		*/

block/blk-exec.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -56,7 +56,7 @@ void blk_execute_rq_nowait(struct request_queue q, struct gendisk bd_disk,
		spin_lock_irq(q->queue_lock);
		__elv_add_request(q, rq, where);
		__blk_run_queue(q);
		/* the queue is stopped so it won't be plugged+unplugged */
		/* the queue is stopped so it won't be run */
		if (rq->cmd_type == REQ_TYPE_PM_RESUME)
		q->request_fn(q);
		spin_unlock_irq(q->queue_lock);

Admin message