block: Deprecate QUEUE_FLAG_CLUSTER and use queue_limits instead

When stacking devices, a request_queue is not always available. This forced us to have a no_cluster flag in the queue_limits that could be used as a carrier until the request_queue had been set up for a metadevice. There were several problems with that approach. First of all it was up to the stacking device to remember to set queue flag after stacking had completed. Also, the queue flag and the queue limits had to be kept in sync at all times. We got that wrong, which could lead to us issuing commands that went beyond the max scatterlist limit set by the driver. The proper fix is to avoid having two flags for tracking the same thing. We deprecate QUEUE_FLAG_CLUSTER and use the queue limit directly in the block layer merging functions. The queue_limit 'no_cluster' is turned into 'cluster' to avoid double negatives and to ease stacking. Clustering defaults to being enabled as before. The queue flag logic is removed from the stacking function, and explicitly setting the cluster flag is no longer necessary in DM and MD.

Martin K. Petersen committed 15 years ago

Commit e692cb61 parent 04a6b517 files · +13 −40Browse files

Unified · Split

7 files

block/blk-merge.c +3 −3
block/blk-settings.c +2 −23
block/blk-sysfs.c +1 −1
drivers/md/dm-table.c +0 −5
drivers/md/md.c +0 −3
drivers/scsi/scsi_lib.c +1 −2
include/linux/blkdev.h +6 −3

block/blk-merge.c+3−3

@@ -21,7 +21,7 @@ static unsigned int __blk_recalc_rq_segments(struct request_queue *q, · 20 unmodified lines
21	21	return 0;
22	22
23	23	fbio = bio;
24		− cluster = test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
	24	+ cluster = blk_queue_cluster(q);
25	25	seg_size = 0;
26	26	nr_phys_segs = 0;
27	27	for_each_bio(bio) {
@@ -87,7 +87,7 @@ EXPORT_SYMBOL(blk_recount_segments); · 59 unmodified lines
87	87	static int blk_phys_contig_segment(struct request_queue q, struct bio bio,
88	88	struct bio *nxt)
89	89	{
90		− if (!test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags))
	90	+ if (!blk_queue_cluster(q))
91	91	return 0;
92	92
93	93	if (bio->bi_seg_back_size + nxt->bi_seg_front_size >
@@ -123,7 +123,7 @@ int blk_rq_map_sg(struct request_queue q, struct request rq, · 29 unmodified lines
123	123	int nsegs, cluster;
124	124
125	125	nsegs = 0;
126		− cluster = test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
	126	+ cluster = blk_queue_cluster(q);
127	127
128	128	/*
129	129	* for each bio in rq

block/blk-settings.c+2−23

@@ -126,7 +126,7 @@ void blk_set_default_limits(struct queue_limits *lim) · 125 unmodified lines
126	126	lim->alignment_offset = 0;
127	127	lim->io_opt = 0;
128	128	lim->misaligned = 0;
129		− lim->no_cluster = 0;
	129	+ lim->cluster = 1;
130	130	}
131	131	EXPORT_SYMBOL(blk_set_default_limits);
132	132
@@ -464,15 +464,6 @@ EXPORT_SYMBOL(blk_queue_io_opt); · 331 unmodified lines
464	464	void blk_queue_stack_limits(struct request_queue t, struct request_queue b)
465	465	{
466	466	blk_stack_limits(&t->limits, &b->limits, 0);
467		−
468		− if (!t->queue_lock)
469		− WARN_ON_ONCE(1);
470		− else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
471		− unsigned long flags;
472		− spin_lock_irqsave(t->queue_lock, flags);
473		− queue_flag_clear(QUEUE_FLAG_CLUSTER, t);
474		− spin_unlock_irqrestore(t->queue_lock, flags);
475		− }
476	467	}
477	468	EXPORT_SYMBOL(blk_queue_stack_limits);
478	469
@@ -545,7 +536,7 @@ int blk_stack_limits(struct queue_limits t, struct queue_limits b, · 66 unmodified lines
545	536	t->io_min = max(t->io_min, b->io_min);
546	537	t->io_opt = lcm(t->io_opt, b->io_opt);
547	538
548		− t->no_cluster \|= b->no_cluster;
	539	+ t->cluster &= b->cluster;
549	540	t->discard_zeroes_data &= b->discard_zeroes_data;
550	541
551	542	/* Physical block size a multiple of the logical block size? */
@@ -641,7 +632,6 @@ void disk_stack_limits(struct gendisk disk, struct block_device bdev, · 89 unmodified lines
641	632	sector_t offset)
642	633	{
643	634	struct request_queue *t = disk->queue;
644		− struct request_queue *b = bdev_get_queue(bdev);
645	635
646	636	if (bdev_stack_limits(&t->limits, bdev, offset >> 9) < 0) {
647	637	char top[BDEVNAME_SIZE], bottom[BDEVNAME_SIZE];
@@ -652,17 +642,6 @@ void disk_stack_limits(struct gendisk disk, struct block_device bdev, · 4 unmodified lines
652	642	printk(KERN_NOTICE "%s: Warning: Device %s is misaligned\n",
653	643	top, bottom);
654	644	}
655		−
656		− if (!t->queue_lock)
657		− WARN_ON_ONCE(1);
658		− else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
659		− unsigned long flags;
660		−
661		− spin_lock_irqsave(t->queue_lock, flags);
662		− if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags))
663		− queue_flag_clear(QUEUE_FLAG_CLUSTER, t);
664		− spin_unlock_irqrestore(t->queue_lock, flags);
665		− }
666	645	}
667	646	EXPORT_SYMBOL(disk_stack_limits);
668	647

block/blk-sysfs.c+1−1

@@ -119,7 +119,7 @@ static ssize_t queue_max_integrity_segments_show(struct request_queue q, char · 118 unmodified lines
119	119
120	120	static ssize_t queue_max_segment_size_show(struct request_queue q, char page)
121	121	{
122		− if (test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags))
	122	+ if (blk_queue_cluster(q))
123	123	return queue_var_show(queue_max_segment_size(q), (page));
124	124
125	125	return queue_var_show(PAGE_CACHE_SIZE, (page));

drivers/md/dm-table.c+0−5

@@ -1131,11 +1131,6 @@ void dm_table_set_restrictions(struct dm_table t, struct request_queue q, · 1130 unmodified lines
1131	1131	*/
1132	1132	q->limits = *limits;
1133	1133
1134		− if (limits->no_cluster)
1135		− queue_flag_clear_unlocked(QUEUE_FLAG_CLUSTER, q);
1136		− else
1137		− queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, q);
1138		−
1139	1134	if (!dm_table_supports_discards(t))
1140	1135	queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q);
1141	1136	else

drivers/md/md.c+0−3

@@ -4296,9 +4296,6 @@ static int md_alloc(dev_t dev, char *name) · 4295 unmodified lines
4296	4296	goto abort;
4297	4297	mddev->queue->queuedata = mddev;
4298	4298
4299		− /* Can be unlocked because the queue is new: no concurrency */
4300		− queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, mddev->queue);
4301		−
4302	4299	blk_queue_make_request(mddev->queue, md_make_request);
4303	4300
4304	4301	disk = alloc_disk(1 << shift);

drivers/scsi/scsi_lib.c+1−2

@@ -1642,9 +1642,8 @@ struct request_queue __scsi_alloc_queue(struct Scsi_Host shost, · 1641 unmodified lines
1642	1642
1643	1643	blk_queue_max_segment_size(q, dma_get_max_seg_size(dev));
1644	1644
1645		− /* New queue, no concurrency on queue_flags */
1646	1645	if (!shost->use_clustering)
1647		− queue_flag_clear_unlocked(QUEUE_FLAG_CLUSTER, q);
	1646	+ q->limits.cluster = 0;
1648	1647
1649	1648	/*
1650	1649	* set a reasonable default alignment on word boundaries: the

include/linux/blkdev.h+6−3

@@ -250,7 +250,7 @@ struct queue_limits { · 249 unmodified lines
250	250
251	251	unsigned char misaligned;
252	252	unsigned char discard_misaligned;
253		− unsigned char no_cluster;
	253	+ unsigned char cluster;
254	254	signed char discard_zeroes_data;
255	255	};
256	256
@@ -380,7 +380,6 @@ struct request_queue · 123 unmodified lines
380	380	#endif
381	381	};
382	382
383		−#define QUEUE_FLAG_CLUSTER 0 /* cluster several segments into 1 */
384	383	#define QUEUE_FLAG_QUEUED 1 /* uses generic tag queueing */
385	384	#define QUEUE_FLAG_STOPPED 2 /* queue is stopped */
386	385	#define QUEUE_FLAG_SYNCFULL 3 /* read queue has been filled */
@@ -403,7 +402,6 @@ struct request_queue · 16 unmodified lines
403	402	#define QUEUE_FLAG_SECDISCARD 19 /* supports SECDISCARD */
404	403
405	404	#define QUEUE_FLAG_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) \| \
406		− (1 << QUEUE_FLAG_CLUSTER) \| \
407	405	(1 << QUEUE_FLAG_STACKABLE) \| \
408	406	(1 << QUEUE_FLAG_SAME_COMP) \| \
409	407	(1 << QUEUE_FLAG_ADD_RANDOM))
@@ -510,6 +508,11 @@ static inline void queue_flag_clear(unsigned int flag, struct request_queue *q) · 100 unmodified lines
510	508
511	509	#define rq_data_dir(rq) ((rq)->cmd_flags & 1)
512	510
	511	+static inline unsigned int blk_queue_cluster(struct request_queue *q)
	512	+{
	513	+ return q->limits.cluster;
	514	+}
	515	+
513	516	/*
514	517	* We regard a request as sync, if either a read or a sync write
515	518	*/