History

block: Consolidate phys_segment and hw_segment limits

Except for SCSI no device drivers distinguish between physical and hardware segment limits. Consolidate the two into a single segment limit.

Martin K. Petersen committed 16 years ago

Commit 8a783621 parent 086fa5f35 files · +70 −136Browse files

Unified · Split

35 files
  1. arch/um/drivers/ubd_kern.c +1 −1
  2. block/blk-core.c +1 −2
  3. block/blk-merge.c +2 −6
  4. block/blk-settings.c +13 −47
  5. drivers/ata/sata_nv.c +1 −1
  6. drivers/block/DAC960.c +1 −1
  7. drivers/block/cciss.c +1 −4
  8. drivers/block/cpqarray.c +1 −4
  9. drivers/block/drbd/drbd_nl.c +1 −2
  10. drivers/block/paride/pf.c +1 −2
  11. drivers/block/pktcdvd.c +2 −2
  12. drivers/block/ps3disk.c +1 −2
  13. drivers/block/ps3vram.c +1 −2
  14. drivers/block/sunvdc.c +1 −2
  15. drivers/block/sx8.c +1 −2
  16. drivers/block/ub.c +1 −2
  17. drivers/block/viodasd.c +1 −2
  18. drivers/block/xen-blkfront.c +1 −2
  19. drivers/cdrom/gdrom.c +1 −1
  20. drivers/cdrom/viocd.c +1 −2
  21. drivers/ide/ide-probe.c +1 −2
  22. drivers/md/raid5.c +1 −1
  23. drivers/memstick/core/mspro_block.c +1 −2
  24. drivers/message/i2o/i2o_block.c +1 −2
  25. drivers/mmc/card/queue.c +2 −4
  26. drivers/s390/block/dasd.c +1 −2
  27. drivers/s390/char/tape_block.c +1 −2
  28. drivers/scsi/ibmvscsi/ibmvfc.c +2 −2
  29. drivers/scsi/scsi_lib.c +2 −2
  30. drivers/scsi/sg.c +2 −4
  31. drivers/scsi/st.c +1 −2
  32. drivers/staging/hv/blkvsc_drv.c +1 −4
  33. fs/bio.c +3 −6
  34. include/linux/blkdev.h +16 −11
  35. include/linux/i2o.h +1 −1
arch/um/drivers/ubd_kern.c+1−1
@@ -849,7 +849,7 @@ static int ubd_add(int n, char **error_out) · 848 unmodified lines
849849 }
850850 ubd_dev->queue->queuedata = ubd_dev;
851851
852− blk_queue_max_hw_segments(ubd_dev->queue, MAX_SG);
852+ blk_queue_max_segments(ubd_dev->queue, MAX_SG);
853853 err = ubd_disk_register(UBD_MAJOR, ubd_dev->size, n, &ubd_gendisk[n]);
854854 if(err){
855855 *error_out = "Failed to register device";
block/blk-core.c+1−2
@@ -1614,8 +1614,7 @@ int blk_rq_check_limits(struct request_queue *q, struct request *rq) · 1613 unmodified lines
16141614 * limitation.
16151615 */
16161616 blk_recalc_rq_segments(rq);
1617− if (rq->nr_phys_segments > queue_max_phys_segments(q) ||
1618− rq->nr_phys_segments > queue_max_hw_segments(q)) {
1617+ if (rq->nr_phys_segments > queue_max_segments(q)) {
16191618 printk(KERN_ERR "%s: over max segments limit.\n", __func__);
16201619 return -EIO;
16211620 }
block/blk-merge.c+2−6
@@ -206,8 +206,7 @@ static inline int ll_new_hw_segment(struct request_queue *q, · 205 unmodified lines
206206 {
207207 int nr_phys_segs = bio_phys_segments(q, bio);
208208
209− if (req->nr_phys_segments + nr_phys_segs > queue_max_hw_segments(q) ||
210− req->nr_phys_segments + nr_phys_segs > queue_max_phys_segments(q)) {
209+ if (req->nr_phys_segments + nr_phys_segs > queue_max_segments(q)) {
211210 req->cmd_flags |= REQ_NOMERGE;
212211 if (req == q->last_merge)
213212 q->last_merge = NULL;
@@ -300,10 +299,7 @@ static int ll_merge_requests_fn(struct request_queue *q, struct request *req, · 86 unmodified lines
300299 total_phys_segments--;
301300 }
302301
303− if (total_phys_segments > queue_max_phys_segments(q))
304− return 0;
305−
306− if (total_phys_segments > queue_max_hw_segments(q))
302+ if (total_phys_segments > queue_max_segments(q))
307303 return 0;
308304
309305 /* Merge is OK... */
block/blk-settings.c+13−47
@@ -91,8 +91,7 @@ EXPORT_SYMBOL_GPL(blk_queue_lld_busy); · 90 unmodified lines
9191 */
9292 void blk_set_default_limits(struct queue_limits *lim)
9393 {
94− lim->max_phys_segments = MAX_PHYS_SEGMENTS;
95− lim->max_hw_segments = MAX_HW_SEGMENTS;
94+ lim->max_segments = BLK_MAX_SEGMENTS;
9695 lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
9796 lim->max_segment_size = BLK_MAX_SEGMENT_SIZE;
9897 lim->max_sectors = BLK_DEF_MAX_SECTORS;
@@ -252,17 +251,15 @@ void blk_queue_max_discard_sectors(struct request_queue *q, · 153 unmodified lines
252251 EXPORT_SYMBOL(blk_queue_max_discard_sectors);
253252
254253 /**
255− * blk_queue_max_phys_segments - set max phys segments for a request for this queue
254+ * blk_queue_max_segments - set max hw segments for a request for this queue
256255 * @q: the request queue for the device
257256 * @max_segments: max number of segments
258257 *
259258 * Description:
260259 * Enables a low level driver to set an upper limit on the number of
261− * physical data segments in a request. This would be the largest sized
262− * scatter list the driver could handle.
260+ * hw data segments in a request.
263261 **/
264−void blk_queue_max_phys_segments(struct request_queue *q,
265− unsigned short max_segments)
262+void blk_queue_max_segments(struct request_queue *q, unsigned short max_segments)
266263 {
267264 if (!max_segments) {
268265 max_segments = 1;
@@ -270,33 +267,9 @@ void blk_queue_max_phys_segments(struct request_queue *q, · 1 unmodified line
270267 __func__, max_segments);
271268 }
272269
273− q->limits.max_phys_segments = max_segments;
270+ q->limits.max_segments = max_segments;
274271 }
275−EXPORT_SYMBOL(blk_queue_max_phys_segments);
276−
277−/**
278− * blk_queue_max_hw_segments - set max hw segments for a request for this queue
279− * @q: the request queue for the device
280− * @max_segments: max number of segments
281− *
282− * Description:
283− * Enables a low level driver to set an upper limit on the number of
284− * hw data segments in a request. This would be the largest number of
285− * address/length pairs the host adapter can actually give at once
286− * to the device.
287− **/
288−void blk_queue_max_hw_segments(struct request_queue *q,
289− unsigned short max_segments)
290−{
291− if (!max_segments) {
292− max_segments = 1;
293− printk(KERN_INFO "%s: set to minimum %d\n",
294− __func__, max_segments);
295− }
296−
297− q->limits.max_hw_segments = max_segments;
298−}
299−EXPORT_SYMBOL(blk_queue_max_hw_segments);
272+EXPORT_SYMBOL(blk_queue_max_segments);
300273
301274 /**
302275 * blk_queue_max_segment_size - set max segment size for blk_rq_map_sg
@@ -531,11 +504,7 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, · 228 unmodified lines
531504 t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask,
532505 b->seg_boundary_mask);
533506
534− t->max_phys_segments = min_not_zero(t->max_phys_segments,
535− b->max_phys_segments);
536−
537− t->max_hw_segments = min_not_zero(t->max_hw_segments,
538− b->max_hw_segments);
507+ t->max_segments = min_not_zero(t->max_segments, b->max_segments);
539508
540509 t->max_segment_size = min_not_zero(t->max_segment_size,
541510 b->max_segment_size);
@@ -739,22 +708,19 @@ EXPORT_SYMBOL(blk_queue_update_dma_pad); · 197 unmodified lines
739708 * does is adjust the queue so that the buf is always appended
740709 * silently to the scatterlist.
741710 *
742− * Note: This routine adjusts max_hw_segments to make room for
743− * appending the drain buffer. If you call
744− * blk_queue_max_hw_segments() or blk_queue_max_phys_segments() after
745− * calling this routine, you must set the limit to one fewer than your
746− * device can support otherwise there won't be room for the drain
747− * buffer.
711+ * Note: This routine adjusts max_hw_segments to make room for appending
712+ * the drain buffer. If you call blk_queue_max_segments() after calling
713+ * this routine, you must set the limit to one fewer than your device
714+ * can support otherwise there won't be room for the drain buffer.
748715 */
749716 int blk_queue_dma_drain(struct request_queue *q,
750717 dma_drain_needed_fn *dma_drain_needed,
751718 void *buf, unsigned int size)
752719 {
753− if (queue_max_hw_segments(q) < 2 || queue_max_phys_segments(q) < 2)
720+ if (queue_max_segments(q) < 2)
754721 return -EINVAL;
755722 /* make room for appending the drain */
756− blk_queue_max_hw_segments(q, queue_max_hw_segments(q) - 1);
757− blk_queue_max_phys_segments(q, queue_max_phys_segments(q) - 1);
723+ blk_queue_max_segments(q, queue_max_segments(q) - 1);
758724 q->dma_drain_needed = dma_drain_needed;
759725 q->dma_drain_buffer = buf;
760726 q->dma_drain_size = size;
drivers/ata/sata_nv.c+1−1
@@ -772,7 +772,7 @@ static int nv_adma_slave_config(struct scsi_device *sdev) · 771 unmodified lines
772772 }
773773
774774 blk_queue_segment_boundary(sdev->request_queue, segment_boundary);
775− blk_queue_max_hw_segments(sdev->request_queue, sg_tablesize);
775+ blk_queue_max_segments(sdev->request_queue, sg_tablesize);
776776 ata_port_printk(ap, KERN_INFO,
777777 "DMA mask 0x%llX, segment boundary 0x%lX, hw segs %hu\n",
778778 (unsigned long long)*ap->host->dev->dma_mask,
drivers/block/DAC960.c+1−1
@@ -2534,7 +2534,7 @@ static bool DAC960_RegisterBlockDevice(DAC960_Controller_T *Controller) · 2533 unmodified lines
25342534 blk_queue_bounce_limit(RequestQueue, Controller->BounceBufferLimit);
25352535 RequestQueue->queuedata = Controller;
25362536 blk_queue_max_hw_segments(RequestQueue, Controller->DriverScatterGatherLimit);
2537− blk_queue_max_phys_segments(RequestQueue, Controller->DriverScatterGatherLimit);
2537+ blk_queue_max_segments(RequestQueue, Controller->DriverScatterGatherLimit);
25382538 blk_queue_max_hw_sectors(RequestQueue, Controller->MaxBlocksPerCommand);
25392539 disk->queue = RequestQueue;
25402540 sprintf(disk->disk_name, "rd/c%dd%d", Controller->ControllerNumber, n);
drivers/block/cciss.c+1−4
@@ -1797,10 +1797,7 @@ static int cciss_add_disk(ctlr_info_t *h, struct gendisk *disk, · 1796 unmodified lines
17971797 blk_queue_bounce_limit(disk->queue, h->pdev->dma_mask);
17981798
17991799 /* This is a hardware imposed limit. */
1800− blk_queue_max_hw_segments(disk->queue, h->maxsgentries);
1801−
1802− /* This is a limit in the driver and could be eliminated. */
1803− blk_queue_max_phys_segments(disk->queue, h->maxsgentries);
1800+ blk_queue_max_segments(disk->queue, h->maxsgentries);
18041801
18051802 blk_queue_max_hw_sectors(disk->queue, h->cciss_max_sectors);
18061803
drivers/block/cpqarray.c+1−4
@@ -448,11 +448,8 @@ static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev) · 447 unmodified lines
448448 blk_queue_bounce_limit(q, hba[i]->pci_dev->dma_mask);
449449
450450 /* This is a hardware imposed limit. */
451− blk_queue_max_hw_segments(q, SG_MAX);
451+ blk_queue_max_segments(q, SG_MAX);
452452
453− /* This is a driver limit and could be eliminated. */
454− blk_queue_max_phys_segments(q, SG_MAX);
455−
456453 init_timer(&hba[i]->timer);
457454 hba[i]->timer.expires = jiffies + IDA_TIMER;
458455 hba[i]->timer.data = (unsigned long)hba[i];
drivers/block/drbd/drbd_nl.c+1−2
@@ -710,8 +710,7 @@ void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_seg_s) __mu · 709 unmodified lines
710710 max_seg_s = min(queue_max_sectors(b) * queue_logical_block_size(b), max_seg_s);
711711
712712 blk_queue_max_hw_sectors(q, max_seg_s >> 9);
713− blk_queue_max_phys_segments(q, max_segments ? max_segments : MAX_PHYS_SEGMENTS);
714− blk_queue_max_hw_segments(q, max_segments ? max_segments : MAX_HW_SEGMENTS);
713+ blk_queue_max_segments(q, max_segments ? max_segments : BLK_MAX_SEGMENTS);
715714 blk_queue_max_segment_size(q, max_seg_s);
716715 blk_queue_logical_block_size(q, 512);
717716 blk_queue_segment_boundary(q, PAGE_SIZE-1);
drivers/block/paride/pf.c+1−2
@@ -956,8 +956,7 @@ static int __init pf_init(void) · 955 unmodified lines
956956 return -ENOMEM;
957957 }
958958
959− blk_queue_max_phys_segments(pf_queue, cluster);
960− blk_queue_max_hw_segments(pf_queue, cluster);
959+ blk_queue_max_segments(pf_queue, cluster);
961960
962961 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
963962 struct gendisk *disk = pf->disk;
drivers/block/pktcdvd.c+2−2
@@ -950,14 +950,14 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd) · 949 unmodified lines
950950 static int pkt_set_segment_merging(struct pktcdvd_device *pd, struct request_queue *q)
951951 {
952952 if ((pd->settings.size << 9) / CD_FRAMESIZE
953− <= queue_max_phys_segments(q)) {
953+ <= queue_max_segments(q)) {
954954 /*
955955 * The cdrom device can handle one segment/frame
956956 */
957957 clear_bit(PACKET_MERGE_SEGS, &pd->flags);
958958 return 0;
959959 } else if ((pd->settings.size << 9) / PAGE_SIZE
960− <= queue_max_phys_segments(q)) {
960+ <= queue_max_segments(q)) {
961961 /*
962962 * We can handle this case at the expense of some extra memory
963963 * copies during write operations
drivers/block/ps3disk.c+1−2
@@ -482,8 +482,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev) · 481 unmodified lines
482482 blk_queue_ordered(queue, QUEUE_ORDERED_DRAIN_FLUSH,
483483 ps3disk_prepare_flush);
484484
485− blk_queue_max_phys_segments(queue, -1);
486− blk_queue_max_hw_segments(queue, -1);
485+ blk_queue_max_segments(queue, -1);
487486 blk_queue_max_segment_size(queue, dev->bounce_size);
488487
489488 gendisk = alloc_disk(PS3DISK_MINORS);
drivers/block/ps3vram.c+1−2
@@ -751,8 +751,7 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev) · 750 unmodified lines
751751 priv->queue = queue;
752752 queue->queuedata = dev;
753753 blk_queue_make_request(queue, ps3vram_make_request);
754− blk_queue_max_phys_segments(queue, MAX_PHYS_SEGMENTS);
755− blk_queue_max_hw_segments(queue, MAX_HW_SEGMENTS);
754+ blk_queue_max_segments(queue, BLK_MAX_HW_SEGMENTS);
756755 blk_queue_max_segment_size(queue, BLK_MAX_SEGMENT_SIZE);
757756 blk_queue_max_hw_sectors(queue, BLK_SAFE_MAX_SECTORS);
758757
drivers/block/sunvdc.c+1−2
@@ -691,8 +691,7 @@ static int probe_disk(struct vdc_port *port) · 690 unmodified lines
691691
692692 port->disk = g;
693693
694− blk_queue_max_hw_segments(q, port->ring_cookies);
695− blk_queue_max_phys_segments(q, port->ring_cookies);
694+ blk_queue_max_segments(q, port->ring_cookies);
696695 blk_queue_max_hw_sectors(q, port->max_xfer_size);
697696 g->major = vdc_major;
698697 g->first_minor = port->vio.vdev->dev_no << PARTITION_SHIFT;
drivers/block/sx8.c+1−2
@@ -1518,8 +1518,7 @@ static int carm_init_disks(struct carm_host *host) · 1517 unmodified lines
15181518 break;
15191519 }
15201520 disk->queue = q;
1521− blk_queue_max_hw_segments(q, CARM_MAX_REQ_SG);
1522− blk_queue_max_phys_segments(q, CARM_MAX_REQ_SG);
1521+ blk_queue_max_segments(q, CARM_MAX_REQ_SG);
15231522 blk_queue_segment_boundary(q, CARM_SG_BOUNDARY);
15241523
15251524 q->queuedata = port;
drivers/block/ub.c+1−2
@@ -2320,8 +2320,7 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum) · 2319 unmodified lines
23202320 disk->queue = q;
23212321
23222322 blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH);
2323− blk_queue_max_hw_segments(q, UB_MAX_REQ_SG);
2324− blk_queue_max_phys_segments(q, UB_MAX_REQ_SG);
2323+ blk_queue_max_segments(q, UB_MAX_REQ_SG);
23252324 blk_queue_segment_boundary(q, 0xffffffff); /* Dubious. */
23262325 blk_queue_max_hw_sectors(q, UB_MAX_SECTORS);
23272326 blk_queue_logical_block_size(q, lun->capacity.bsize);
drivers/block/viodasd.c+1−2
@@ -471,8 +471,7 @@ retry: · 470 unmodified lines
471471 }
472472
473473 d->disk = g;
474− blk_queue_max_hw_segments(q, VIOMAXBLOCKDMA);
475− blk_queue_max_phys_segments(q, VIOMAXBLOCKDMA);
474+ blk_queue_max_segments(q, VIOMAXBLOCKDMA);
476475 blk_queue_max_hw_sectors(q, VIODASD_MAXSECTORS);
477476 g->major = VIODASD_MAJOR;
478477 g->first_minor = dev_no << PARTITION_SHIFT;
drivers/block/xen-blkfront.c+1−2
@@ -353,8 +353,7 @@ static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size) · 352 unmodified lines
353353 blk_queue_max_segment_size(rq, PAGE_SIZE);
354354
355355 /* Ensure a merged request will fit in a single I/O ring slot. */
356− blk_queue_max_phys_segments(rq, BLKIF_MAX_SEGMENTS_PER_REQUEST);
357− blk_queue_max_hw_segments(rq, BLKIF_MAX_SEGMENTS_PER_REQUEST);
356+ blk_queue_max_segments(rq, BLKIF_MAX_SEGMENTS_PER_REQUEST);
358357
359358 /* Make sure buffer addresses are sector-aligned. */
360359 blk_queue_dma_alignment(rq, 511);
drivers/cdrom/gdrom.c+1−1
@@ -741,7 +741,7 @@ static int __devinit probe_gdrom_setupqueue(void) · 740 unmodified lines
741741 {
742742 blk_queue_logical_block_size(gd.gdrom_rq, GDROM_HARD_SECTOR);
743743 /* using DMA so memory will need to be contiguous */
744− blk_queue_max_hw_segments(gd.gdrom_rq, 1);
744+ blk_queue_max_segments(gd.gdrom_rq, 1);
745745 /* set a large max size to get most from DMA */
746746 blk_queue_max_segment_size(gd.gdrom_rq, 0x40000);
747747 gd.disk->queue = gd.gdrom_rq;
drivers/cdrom/viocd.c+1−2
@@ -616,8 +616,7 @@ static int viocd_probe(struct vio_dev *vdev, const struct vio_device_id *id) · 615 unmodified lines
616616 gendisk->first_minor = deviceno;
617617 strncpy(gendisk->disk_name, c->name,
618618 sizeof(gendisk->disk_name));
619− blk_queue_max_hw_segments(q, 1);
620− blk_queue_max_phys_segments(q, 1);
619+ blk_queue_max_segments(q, 1);
621620 blk_queue_max_hw_sectors(q, 4096 / 512);
622621 gendisk->queue = q;
623622 gendisk->fops = &viocd_fops;
drivers/ide/ide-probe.c+1−2
@@ -790,8 +790,7 @@ static int ide_init_queue(ide_drive_t *drive) · 789 unmodified lines
790790 max_sg_entries >>= 1;
791791 #endif /* CONFIG_PCI */
792792
793− blk_queue_max_hw_segments(q, max_sg_entries);
794− blk_queue_max_phys_segments(q, max_sg_entries);
793+ blk_queue_max_segments(q, max_sg_entries);
795794
796795 /* assign drive queue */
797796 drive->queue = q;
drivers/md/raid5.c+1−1
@@ -3739,7 +3739,7 @@ static int bio_fits_rdev(struct bio *bi) · 3738 unmodified lines
37393739 if ((bi->bi_size>>9) > queue_max_sectors(q))
37403740 return 0;
37413741 blk_recount_segments(q, bi);
3742− if (bi->bi_phys_segments > queue_max_phys_segments(q))
3742+ if (bi->bi_phys_segments > queue_max_segments(q))
37433743 return 0;
37443744
37453745 if (q->merge_bvec_fn)
drivers/memstick/core/mspro_block.c+1−2
@@ -1227,8 +1227,7 @@ static int mspro_block_init_disk(struct memstick_dev *card) · 1226 unmodified lines
12271227
12281228 blk_queue_bounce_limit(msb->queue, limit);
12291229 blk_queue_max_hw_sectors(msb->queue, MSPRO_BLOCK_MAX_PAGES);
1230− blk_queue_max_phys_segments(msb->queue, MSPRO_BLOCK_MAX_SEGS);
1231− blk_queue_max_hw_segments(msb->queue, MSPRO_BLOCK_MAX_SEGS);
1230+ blk_queue_max_segments(msb->queue, MSPRO_BLOCK_MAX_SEGS);
12321231 blk_queue_max_segment_size(msb->queue,
12331232 MSPRO_BLOCK_MAX_PAGES * msb->page_size);
12341233
drivers/message/i2o/i2o_block.c+1−2
@@ -1065,9 +1065,8 @@ static int i2o_block_probe(struct device *dev) · 1064 unmodified lines
10651065 queue = gd->queue;
10661066 queue->queuedata = i2o_blk_dev;
10671067
1068− blk_queue_max_phys_segments(queue, I2O_MAX_PHYS_SEGMENTS);
10691068 blk_queue_max_hw_sectors(queue, max_sectors);
1070− blk_queue_max_hw_segments(queue, i2o_sg_tablesize(c, body_size));
1069+ blk_queue_max_segments(queue, i2o_sg_tablesize(c, body_size));
10711070
10721071 osm_debug("max sectors = %d\n", queue->max_sectors);
10731072 osm_debug("phys segments = %d\n", queue->max_phys_segments);
drivers/mmc/card/queue.c+2−4
@@ -155,8 +155,7 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock · 154 unmodified lines
155155 if (mq->bounce_buf) {
156156 blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_ANY);
157157 blk_queue_max_hw_sectors(mq->queue, bouncesz / 512);
158− blk_queue_max_phys_segments(mq->queue, bouncesz / 512);
159− blk_queue_max_hw_segments(mq->queue, bouncesz / 512);
158+ blk_queue_max_segments(mq->queue, bouncesz / 512);
160159 blk_queue_max_segment_size(mq->queue, bouncesz);
161160
162161 mq->sg = kmalloc(sizeof(struct scatterlist),
@@ -182,8 +181,7 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock · 19 unmodified lines
182181 blk_queue_bounce_limit(mq->queue, limit);
183182 blk_queue_max_hw_sectors(mq->queue,
184183 min(host->max_blk_count, host->max_req_size / 512));
185− blk_queue_max_phys_segments(mq->queue, host->max_phys_segs);
186− blk_queue_max_hw_segments(mq->queue, host->max_hw_segs);
184+ blk_queue_max_segments(mq->queue, host->max_hw_segs);
187185 blk_queue_max_segment_size(mq->queue, host->max_seg_size);
188186
189187 mq->sg = kmalloc(sizeof(struct scatterlist) *
drivers/s390/block/dasd.c+1−2
@@ -2130,8 +2130,7 @@ static void dasd_setup_queue(struct dasd_block *block) · 2129 unmodified lines
21302130 blk_queue_logical_block_size(block->request_queue, block->bp_block);
21312131 max = block->base->discipline->max_blocks << block->s2b_shift;
21322132 blk_queue_max_hw_sectors(block->request_queue, max);
2133− blk_queue_max_phys_segments(block->request_queue, -1L);
2134− blk_queue_max_hw_segments(block->request_queue, -1L);
2133+ blk_queue_max_segments(block->request_queue, -1L);
21352134 /* with page sized segments we can translate each segement into
21362135 * one idaw/tidaw
21372136 */
drivers/s390/char/tape_block.c+1−2
@@ -223,8 +223,7 @@ tapeblock_setup_device(struct tape_device * device) · 222 unmodified lines
223223
224224 blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
225225 blk_queue_max_hw_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
226− blk_queue_max_phys_segments(blkdat->request_queue, -1L);
227− blk_queue_max_hw_segments(blkdat->request_queue, -1L);
226+ blk_queue_max_segments(blkdat->request_queue, -1L);
228227 blk_queue_max_segment_size(blkdat->request_queue, -1L);
229228 blk_queue_segment_boundary(blkdat->request_queue, -1L);
230229
drivers/scsi/ibmvscsi/ibmvfc.c+2−2
@@ -4195,7 +4195,7 @@ static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt) · 4194 unmodified lines
41954195 if (tgt->service_parms.class3_parms[0] & 0x80000000)
41964196 rport->supported_classes |= FC_COS_CLASS3;
41974197 if (rport->rqst_q)
4198− blk_queue_max_hw_segments(rport->rqst_q, 1);
4198+ blk_queue_max_segments(rport->rqst_q, 1);
41994199 } else
42004200 tgt_dbg(tgt, "rport add failed\n");
42014201 spin_unlock_irqrestore(vhost->host->host_lock, flags);
@@ -4669,7 +4669,7 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id) · 467 unmodified lines
46694669 }
46704670
46714671 if (shost_to_fc_host(shost)->rqst_q)
4672− blk_queue_max_hw_segments(shost_to_fc_host(shost)->rqst_q, 1);
4672+ blk_queue_max_segments(shost_to_fc_host(shost)->rqst_q, 1);
46734673 dev_set_drvdata(dev, vhost);
46744674 spin_lock(&ibmvfc_driver_lock);
46754675 list_add_tail(&vhost->queue, &ibmvfc_head);
drivers/scsi/scsi_lib.c+2−2
@@ -1624,8 +1624,8 @@ struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost, · 1623 unmodified lines
16241624 /*
16251625 * this limit is imposed by hardware restrictions
16261626 */
1627− blk_queue_max_hw_segments(q, shost->sg_tablesize);
1628− blk_queue_max_phys_segments(q, SCSI_MAX_SG_CHAIN_SEGMENTS);
1627+ blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,
1628+ SCSI_MAX_SG_CHAIN_SEGMENTS));
16291629
16301630 blk_queue_max_hw_sectors(q, shost->max_sectors);
16311631 blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));
drivers/scsi/sg.c+2−4
@@ -287,8 +287,7 @@ sg_open(struct inode *inode, struct file *filp) · 286 unmodified lines
287287 if (list_empty(&sdp->sfds)) { /* no existing opens on this device */
288288 sdp->sgdebug = 0;
289289 q = sdp->device->request_queue;
290− sdp->sg_tablesize = min(queue_max_hw_segments(q),
291− queue_max_phys_segments(q));
290+ sdp->sg_tablesize = queue_max_segments(q);
292291 }
293292 if ((sfp = sg_add_sfp(sdp, dev)))
294293 filp->private_data = sfp;
@@ -1376,8 +1375,7 @@ static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp) · 1081 unmodified lines
13761375 sdp->device = scsidp;
13771376 INIT_LIST_HEAD(&sdp->sfds);
13781377 init_waitqueue_head(&sdp->o_excl_wait);
1379− sdp->sg_tablesize = min(queue_max_hw_segments(q),
1380− queue_max_phys_segments(q));
1378+ sdp->sg_tablesize = queue_max_segments(q);
13811379 sdp->index = k;
13821380 kref_init(&sdp->d_ref);
13831381
drivers/scsi/st.c+1−2
@@ -3983,8 +3983,7 @@ static int st_probe(struct device *dev) · 3982 unmodified lines
39833983 return -ENODEV;
39843984 }
39853985
3986− i = min(queue_max_hw_segments(SDp->request_queue),
3987− queue_max_phys_segments(SDp->request_queue));
3986+ i = queue_max_segments(SDp->request_queue);
39883987 if (st_max_sg_segs < i)
39893988 i = st_max_sg_segs;
39903989 buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
drivers/staging/hv/blkvsc_drv.c+1−4
@@ -363,10 +363,7 @@ static int blkvsc_probe(struct device *device) · 362 unmodified lines
363363 blkdev->gd->queue = blk_init_queue(blkvsc_request, &blkdev->lock);
364364
365365 blk_queue_max_segment_size(blkdev->gd->queue, PAGE_SIZE);
366− blk_queue_max_phys_segments(blkdev->gd->queue,
367− MAX_MULTIPAGE_BUFFER_COUNT);
368− blk_queue_max_hw_segments(blkdev->gd->queue,
369− MAX_MULTIPAGE_BUFFER_COUNT);
366+ blk_queue_max_segments(blkdev->gd->queue, MAX_MULTIPAGE_BUFFER_COUNT);
370367 blk_queue_segment_boundary(blkdev->gd->queue, PAGE_SIZE-1);
371368 blk_queue_bounce_limit(blkdev->gd->queue, BLK_BOUNCE_ANY);
372369 blk_queue_dma_alignment(blkdev->gd->queue, 511);
fs/bio.c+3−6
@@ -507,10 +507,8 @@ int bio_get_nr_vecs(struct block_device *bdev) · 506 unmodified lines
507507 int nr_pages;
508508
509509 nr_pages = ((queue_max_sectors(q) << 9) + PAGE_SIZE - 1) >> PAGE_SHIFT;
510− if (nr_pages > queue_max_phys_segments(q))
511− nr_pages = queue_max_phys_segments(q);
512− if (nr_pages > queue_max_hw_segments(q))
513− nr_pages = queue_max_hw_segments(q);
510+ if (nr_pages > queue_max_segments(q))
511+ nr_pages = queue_max_segments(q);
514512
515513 return nr_pages;
516514 }
@@ -575,8 +573,7 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page · 58 unmodified lines
575573 * make this too complex.
576574 */
577575
578− while (bio->bi_phys_segments >= queue_max_phys_segments(q)
579− || bio->bi_phys_segments >= queue_max_hw_segments(q)) {
576+ while (bio->bi_phys_segments >= queue_max_segments(q)) {
580577
581578 if (retried_segments)
582579 return 0;
include/linux/blkdev.h+16−11
@@ -316,8 +316,7 @@ struct queue_limits { · 315 unmodified lines
316316 unsigned int discard_alignment;
317317
318318 unsigned short logical_block_size;
319− unsigned short max_hw_segments;
320− unsigned short max_phys_segments;
319+ unsigned short max_segments;
321320
322321 unsigned char misaligned;
323322 unsigned char discard_misaligned;
@@ -929,8 +928,19 @@ static inline void blk_queue_max_sectors(struct request_queue *q, unsigned int m · 605 unmodified lines
929928 blk_queue_max_hw_sectors(q, max);
930929 }
931930
932−extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
933−extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
931+extern void blk_queue_max_segments(struct request_queue *, unsigned short);
932+
933+static inline void blk_queue_max_phys_segments(struct request_queue *q, unsigned short max)
934+{
935+ blk_queue_max_segments(q, max);
936+}
937+
938+static inline void blk_queue_max_hw_segments(struct request_queue *q, unsigned short max)
939+{
940+ blk_queue_max_segments(q, max);
941+}
942+
943+
934944 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
935945 extern void blk_queue_max_discard_sectors(struct request_queue *q,
936946 unsigned int max_discard_sectors);
@@ -1055,14 +1065,9 @@ static inline unsigned int queue_max_hw_sectors(struct request_queue *q) · 118 unmodified lines
10551065 return q->limits.max_hw_sectors;
10561066 }
10571067
1058−static inline unsigned short queue_max_hw_segments(struct request_queue *q)
1059−{
1060− return q->limits.max_hw_segments;
1061−}
1062−
1063−static inline unsigned short queue_max_phys_segments(struct request_queue *q)
1068+static inline unsigned short queue_max_segments(struct request_queue *q)
10641069 {
1065− return q->limits.max_phys_segments;
1070+ return q->limits.max_segments;
10661071 }
10671072
10681073 static inline unsigned int queue_max_segment_size(struct request_queue *q)
include/linux/i2o.h+1−1
@@ -385,7 +385,7 @@ · 384 unmodified lines
385385 /* defines for max_sectors and max_phys_segments */
386386 #define I2O_MAX_SECTORS 1024
387387 #define I2O_MAX_SECTORS_LIMITED 128
388−#define I2O_MAX_PHYS_SEGMENTS MAX_PHYS_SEGMENTS
388+#define I2O_MAX_PHYS_SEGMENTS BLK_MAX_SEGMENTS
389389
390390 /*
391391 * Message structures

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t