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.

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index c2051b0737cbdc43815842d035d2c2aa8f38dadf..c1ff6903b622126789945164c0a33101d0a7943a 100644 (file)
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -849,7 +849,7 @@ static int ubd_add(int n, char **error_out)
        }
        ubd_dev->queue->queuedata = ubd_dev;
 
-       blk_queue_max_hw_segments(ubd_dev->queue, MAX_SG);
+       blk_queue_max_segments(ubd_dev->queue, MAX_SG);
        err = ubd_disk_register(UBD_MAJOR, ubd_dev->size, n, &ubd_gendisk[n]);
        if(err){
                *error_out = "Failed to register device";

diff --git a/block/blk-core.c b/block/blk-core.c
index 36c0deebc2dc6764242c53f06de71c8dcb84319a..9fe174dc74d1dfecca76bb19eb9dda2af53f93bd 100644 (file)
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -1614,8 +1614,7 @@ int blk_rq_check_limits(struct request_queue *q, struct request *rq)
         * limitation.
         */
        blk_recalc_rq_segments(rq);
-       if (rq->nr_phys_segments > queue_max_phys_segments(q) ||
-           rq->nr_phys_segments > queue_max_hw_segments(q)) {
+       if (rq->nr_phys_segments > queue_max_segments(q)) {
                printk(KERN_ERR "%s: over max segments limit.\n", __func__);
                return -EIO;
        }

diff --git a/block/blk-merge.c b/block/blk-merge.c
index 99cb5cf1f447fa8759d73f06bf64fe4b20eec580..5e7dc9973458406c5159b8ea3b87033302bf5fcf 100644 (file)
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -206,8 +206,7 @@ static inline int ll_new_hw_segment(struct request_queue *q,
 {
        int nr_phys_segs = bio_phys_segments(q, bio);
 
-       if (req->nr_phys_segments + nr_phys_segs > queue_max_hw_segments(q) ||
-           req->nr_phys_segments + nr_phys_segs > queue_max_phys_segments(q)) {
+       if (req->nr_phys_segments + nr_phys_segs > queue_max_segments(q)) {
                req->cmd_flags |= REQ_NOMERGE;
                if (req == q->last_merge)
                        q->last_merge = NULL;
@@ -300,10 +299,7 @@ static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
                total_phys_segments--;
        }
 
-       if (total_phys_segments > queue_max_phys_segments(q))
-               return 0;
-
-       if (total_phys_segments > queue_max_hw_segments(q))
+       if (total_phys_segments > queue_max_segments(q))
                return 0;
 
        /* Merge is OK... */

diff --git a/block/blk-settings.c b/block/blk-settings.c
index 61afae9dbc6d373c93f866382187dabd136b4655..31e7a9375c1333cc35ab40d565c5c1ed4e8703e7 100644 (file)
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -91,8 +91,7 @@ EXPORT_SYMBOL_GPL(blk_queue_lld_busy);
  */
 void blk_set_default_limits(struct queue_limits *lim)
 {
-       lim->max_phys_segments = MAX_PHYS_SEGMENTS;
-       lim->max_hw_segments = MAX_HW_SEGMENTS;
+       lim->max_segments = BLK_MAX_SEGMENTS;
        lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
        lim->max_segment_size = BLK_MAX_SEGMENT_SIZE;
        lim->max_sectors = BLK_DEF_MAX_SECTORS;
@@ -252,17 +251,15 @@ void blk_queue_max_discard_sectors(struct request_queue *q,
 EXPORT_SYMBOL(blk_queue_max_discard_sectors);
 
 /**
- * blk_queue_max_phys_segments - set max phys segments for a request for this queue
+ * blk_queue_max_segments - set max hw segments for a request for this queue
  * @q:  the request queue for the device
  * @max_segments:  max number of segments
  *
  * Description:
  *    Enables a low level driver to set an upper limit on the number of
- *    physical data segments in a request.  This would be the largest sized
- *    scatter list the driver could handle.
+ *    hw data segments in a request.
  **/
-void blk_queue_max_phys_segments(struct request_queue *q,
-                                unsigned short max_segments)
+void blk_queue_max_segments(struct request_queue *q, unsigned short max_segments)
 {
        if (!max_segments) {
                max_segments = 1;
@@ -270,33 +267,9 @@ void blk_queue_max_phys_segments(struct request_queue *q,
                       __func__, max_segments);
        }
 
-       q->limits.max_phys_segments = max_segments;
+       q->limits.max_segments = max_segments;
 }
-EXPORT_SYMBOL(blk_queue_max_phys_segments);
-
-/**
- * blk_queue_max_hw_segments - set max hw segments for a request for this queue
- * @q:  the request queue for the device
- * @max_segments:  max number of segments
- *
- * Description:
- *    Enables a low level driver to set an upper limit on the number of
- *    hw data segments in a request.  This would be the largest number of
- *    address/length pairs the host adapter can actually give at once
- *    to the device.
- **/
-void blk_queue_max_hw_segments(struct request_queue *q,
-                              unsigned short max_segments)
-{
-       if (!max_segments) {
-               max_segments = 1;
-               printk(KERN_INFO "%s: set to minimum %d\n",
-                      __func__, max_segments);
-       }
-
-       q->limits.max_hw_segments = max_segments;
-}
-EXPORT_SYMBOL(blk_queue_max_hw_segments);
+EXPORT_SYMBOL(blk_queue_max_segments);
 
 /**
  * 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,
        t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask,
                                            b->seg_boundary_mask);
 
-       t->max_phys_segments = min_not_zero(t->max_phys_segments,
-                                           b->max_phys_segments);
-
-       t->max_hw_segments = min_not_zero(t->max_hw_segments,
-                                         b->max_hw_segments);
+       t->max_segments = min_not_zero(t->max_segments, b->max_segments);
 
        t->max_segment_size = min_not_zero(t->max_segment_size,
                                           b->max_segment_size);
@@ -739,22 +708,19 @@ EXPORT_SYMBOL(blk_queue_update_dma_pad);
  * does is adjust the queue so that the buf is always appended
  * silently to the scatterlist.
  *
- * Note: This routine adjusts max_hw_segments to make room for
- * appending the drain buffer.  If you call
- * blk_queue_max_hw_segments() or blk_queue_max_phys_segments() after
- * calling this routine, you must set the limit to one fewer than your
- * device can support otherwise there won't be room for the drain
- * buffer.
+ * Note: This routine adjusts max_hw_segments to make room for appending
+ * the drain buffer.  If you call blk_queue_max_segments() after calling
+ * this routine, you must set the limit to one fewer than your device
+ * can support otherwise there won't be room for the drain buffer.
  */
 int blk_queue_dma_drain(struct request_queue *q,
                               dma_drain_needed_fn *dma_drain_needed,
                               void *buf, unsigned int size)
 {
-       if (queue_max_hw_segments(q) < 2 || queue_max_phys_segments(q) < 2)
+       if (queue_max_segments(q) < 2)
                return -EINVAL;
        /* make room for appending the drain */
-       blk_queue_max_hw_segments(q, queue_max_hw_segments(q) - 1);
-       blk_queue_max_phys_segments(q, queue_max_phys_segments(q) - 1);
+       blk_queue_max_segments(q, queue_max_segments(q) - 1);
        q->dma_drain_needed = dma_drain_needed;
        q->dma_drain_buffer = buf;
        q->dma_drain_size = size;

diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 0c82d335c55d6c218acb9218fb54a298fd420a86..684fe04dbbb7f8200f710c578206d83bd6239030 100644 (file)
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -772,7 +772,7 @@ static int nv_adma_slave_config(struct scsi_device *sdev)
        }
 
        blk_queue_segment_boundary(sdev->request_queue, segment_boundary);
-       blk_queue_max_hw_segments(sdev->request_queue, sg_tablesize);
+       blk_queue_max_segments(sdev->request_queue, sg_tablesize);
        ata_port_printk(ap, KERN_INFO,
                "DMA mask 0x%llX, segment boundary 0x%lX, hw segs %hu\n",
                (unsigned long long)*ap->host->dev->dma_mask,

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 1c0cd35e1913daa4614ac3928d27d65ace3cf46e..459f1bc25a7b813e1094f54903d57852825983af 100644 (file)
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -2534,7 +2534,7 @@ static bool DAC960_RegisterBlockDevice(DAC960_Controller_T *Controller)
        blk_queue_bounce_limit(RequestQueue, Controller->BounceBufferLimit);
        RequestQueue->queuedata = Controller;
        blk_queue_max_hw_segments(RequestQueue, Controller->DriverScatterGatherLimit);
-       blk_queue_max_phys_segments(RequestQueue, Controller->DriverScatterGatherLimit);
+       blk_queue_max_segments(RequestQueue, Controller->DriverScatterGatherLimit);
        blk_queue_max_hw_sectors(RequestQueue, Controller->MaxBlocksPerCommand);
        disk->queue = RequestQueue;
        sprintf(disk->disk_name, "rd/c%dd%d", Controller->ControllerNumber, n);

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 030e52d722545b8b3f069d0386a56094154b6836..a29e69418a03f6fc479419e0f714a0d2cde19d15 100644 (file)
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -1797,10 +1797,7 @@ static int cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
        blk_queue_bounce_limit(disk->queue, h->pdev->dma_mask);
 
        /* This is a hardware imposed limit. */
-       blk_queue_max_hw_segments(disk->queue, h->maxsgentries);
-
-       /* This is a limit in the driver and could be eliminated. */
-       blk_queue_max_phys_segments(disk->queue, h->maxsgentries);
+       blk_queue_max_segments(disk->queue, h->maxsgentries);
 
        blk_queue_max_hw_sectors(disk->queue, h->cciss_max_sectors);
 

diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index 6422651ec364197ed9418f4a3bafb966208a8417..91d11631cec96a523f8f7f9504ce6405edba920a 100644 (file)
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -448,11 +448,8 @@ static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev)
                blk_queue_bounce_limit(q, hba[i]->pci_dev->dma_mask);
 
        /* This is a hardware imposed limit. */
-       blk_queue_max_hw_segments(q, SG_MAX);
+       blk_queue_max_segments(q, SG_MAX);
 
-       /* This is a driver limit and could be eliminated. */
-       blk_queue_max_phys_segments(q, SG_MAX);
-       
        init_timer(&hba[i]->timer);
        hba[i]->timer.expires = jiffies + IDA_TIMER;
        hba[i]->timer.data = (unsigned long)hba[i];

diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c
index 9b55e64196fcad92d241946cdd5c657af9275e1d..4df3b40b1057d225fe310601c77021a6f37f0d7c 100644 (file)
--- a/drivers/block/drbd/drbd_nl.c
+++ b/drivers/block/drbd/drbd_nl.c
@@ -710,8 +710,7 @@ void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_seg_s) __mu
        max_seg_s = min(queue_max_sectors(b) * queue_logical_block_size(b), max_seg_s);
 
        blk_queue_max_hw_sectors(q, max_seg_s >> 9);
-       blk_queue_max_phys_segments(q, max_segments ? max_segments : MAX_PHYS_SEGMENTS);
-       blk_queue_max_hw_segments(q, max_segments ? max_segments : MAX_HW_SEGMENTS);
+       blk_queue_max_segments(q, max_segments ? max_segments : BLK_MAX_SEGMENTS);
        blk_queue_max_segment_size(q, max_seg_s);
        blk_queue_logical_block_size(q, 512);
        blk_queue_segment_boundary(q, PAGE_SIZE-1);

diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index ea54ea393553831c6ba4a2066e9cb63859cd4e5b..ddb4f9abd480b8f0cb6ce013d6c514e5a211d120 100644 (file)
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -956,8 +956,7 @@ static int __init pf_init(void)
                return -ENOMEM;
        }
 
-       blk_queue_max_phys_segments(pf_queue, cluster);
-       blk_queue_max_hw_segments(pf_queue, cluster);
+       blk_queue_max_segments(pf_queue, cluster);
 
        for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
                struct gendisk *disk = pf->disk;

diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 6e1daa24da2fea7bbec0463a84bdb3a2037b2918..b72935b8f2036e3ea954b5560fe88fd3875f5d96 100644 (file)
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -950,14 +950,14 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
 static int pkt_set_segment_merging(struct pktcdvd_device *pd, struct request_queue *q)
 {
        if ((pd->settings.size << 9) / CD_FRAMESIZE
-           <= queue_max_phys_segments(q)) {
+           <= queue_max_segments(q)) {
                /*
                 * The cdrom device can handle one segment/frame
                 */
                clear_bit(PACKET_MERGE_SEGS, &pd->flags);
                return 0;
        } else if ((pd->settings.size << 9) / PAGE_SIZE
-                  <= queue_max_phys_segments(q)) {
+                  <= queue_max_segments(q)) {
                /*
                 * We can handle this case at the expense of some extra memory
                 * copies during write operations

diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index 9cd1a4a542b89bc46d7141fd3c8adb0a9e7076e8..bc95469d33c122018e96ccbc9576370e64c89afd 100644 (file)
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -482,8 +482,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
        blk_queue_ordered(queue, QUEUE_ORDERED_DRAIN_FLUSH,
                          ps3disk_prepare_flush);
 
-       blk_queue_max_phys_segments(queue, -1);
-       blk_queue_max_hw_segments(queue, -1);
+       blk_queue_max_segments(queue, -1);
        blk_queue_max_segment_size(queue, dev->bounce_size);
 
        gendisk = alloc_disk(PS3DISK_MINORS);

diff --git a/drivers/block/ps3vram.c b/drivers/block/ps3vram.c
index 6416b262934bf248d29b2130e0d6213b29bb2836..83ebb390b164fb30a59f4b8714b57b2b1c3ca3f6 100644 (file)
--- a/drivers/block/ps3vram.c
+++ b/drivers/block/ps3vram.c
@@ -751,8 +751,7 @@ static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
        priv->queue = queue;
        queue->queuedata = dev;
        blk_queue_make_request(queue, ps3vram_make_request);
-       blk_queue_max_phys_segments(queue, MAX_PHYS_SEGMENTS);
-       blk_queue_max_hw_segments(queue, MAX_HW_SEGMENTS);
+       blk_queue_max_segments(queue, BLK_MAX_HW_SEGMENTS);
        blk_queue_max_segment_size(queue, BLK_MAX_SEGMENT_SIZE);
        blk_queue_max_hw_sectors(queue, BLK_SAFE_MAX_SECTORS);
 

diff --git a/drivers/block/sunvdc.c b/drivers/block/sunvdc.c
index dd30cddd0f7f0d4c5072fb85fb5491cc9a85da54..48e8fee9f2d4f8aa6bacf4243694a430b53fdae9 100644 (file)
--- a/drivers/block/sunvdc.c
+++ b/drivers/block/sunvdc.c
@@ -691,8 +691,7 @@ static int probe_disk(struct vdc_port *port)
 
        port->disk = g;
 
-       blk_queue_max_hw_segments(q, port->ring_cookies);
-       blk_queue_max_phys_segments(q, port->ring_cookies);
+       blk_queue_max_segments(q, port->ring_cookies);
        blk_queue_max_hw_sectors(q, port->max_xfer_size);
        g->major = vdc_major;
        g->first_minor = port->vio.vdev->dev_no << PARTITION_SHIFT;

diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index 7bd7b2f83116824bbcad81257591af366f1b39aa..b70f0fca9a42e724e3911d62cd64729a2f20ce4b 100644 (file)
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -1518,8 +1518,7 @@ static int carm_init_disks(struct carm_host *host)
                        break;
                }
                disk->queue = q;
-               blk_queue_max_hw_segments(q, CARM_MAX_REQ_SG);
-               blk_queue_max_phys_segments(q, CARM_MAX_REQ_SG);
+               blk_queue_max_segments(q, CARM_MAX_REQ_SG);
                blk_queue_segment_boundary(q, CARM_SG_BOUNDARY);
 
                q->queuedata = port;

diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index 352ea24d66e87636ce0e485f218a59a233399eea..2e889838e819016c8c693cba1d0498595a027565 100644 (file)
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -2320,8 +2320,7 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum)
        disk->queue = q;
 
        blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH);
-       blk_queue_max_hw_segments(q, UB_MAX_REQ_SG);
-       blk_queue_max_phys_segments(q, UB_MAX_REQ_SG);
+       blk_queue_max_segments(q, UB_MAX_REQ_SG);
        blk_queue_segment_boundary(q, 0xffffffff);      /* Dubious. */
        blk_queue_max_hw_sectors(q, UB_MAX_SECTORS);
        blk_queue_logical_block_size(q, lun->capacity.bsize);

diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index d44ece7d7b7c0370d8468f21dd650ea6291dc818..c12b31362ac69845375ceaf8be44ad615520b786 100644 (file)
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -471,8 +471,7 @@ retry:
        }
 
        d->disk = g;
-       blk_queue_max_hw_segments(q, VIOMAXBLOCKDMA);
-       blk_queue_max_phys_segments(q, VIOMAXBLOCKDMA);
+       blk_queue_max_segments(q, VIOMAXBLOCKDMA);
        blk_queue_max_hw_sectors(q, VIODASD_MAXSECTORS);
        g->major = VIODASD_MAJOR;
        g->first_minor = dev_no << PARTITION_SHIFT;

diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index f9861aaa1fefccdde412ecb88d938baac2ad60f7..9c09694b2520cc5a2422416431576a46d0871eaf 100644 (file)
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -353,8 +353,7 @@ static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size)
        blk_queue_max_segment_size(rq, PAGE_SIZE);
 
        /* Ensure a merged request will fit in a single I/O ring slot. */
-       blk_queue_max_phys_segments(rq, BLKIF_MAX_SEGMENTS_PER_REQUEST);
-       blk_queue_max_hw_segments(rq, BLKIF_MAX_SEGMENTS_PER_REQUEST);
+       blk_queue_max_segments(rq, BLKIF_MAX_SEGMENTS_PER_REQUEST);
 
        /* Make sure buffer addresses are sector-aligned. */
        blk_queue_dma_alignment(rq, 511);

diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
index e789e6c9a42217681e9a0a698181e1f1dc971455..03c71f7698cb64ffd2aa1de3f31fc600648ce675 100644 (file)
--- a/drivers/cdrom/gdrom.c
+++ b/drivers/cdrom/gdrom.c
@@ -741,7 +741,7 @@ static int __devinit probe_gdrom_setupqueue(void)
 {
        blk_queue_logical_block_size(gd.gdrom_rq, GDROM_HARD_SECTOR);
        /* using DMA so memory will need to be contiguous */
-       blk_queue_max_hw_segments(gd.gdrom_rq, 1);
+       blk_queue_max_segments(gd.gdrom_rq, 1);
        /* set a large max size to get most from DMA */
        blk_queue_max_segment_size(gd.gdrom_rq, 0x40000);
        gd.disk->queue = gd.gdrom_rq;

diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index b1dfd23eb8328f3cda37ff1343f445c80f52c41f..cc435be0bc136840153e91bbb0ef4cbae0bf54d9 100644 (file)
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -616,8 +616,7 @@ static int viocd_probe(struct vio_dev *vdev, const struct vio_device_id *id)
        gendisk->first_minor = deviceno;
        strncpy(gendisk->disk_name, c->name,
                        sizeof(gendisk->disk_name));
-       blk_queue_max_hw_segments(q, 1);
-       blk_queue_max_phys_segments(q, 1);
+       blk_queue_max_segments(q, 1);
        blk_queue_max_hw_sectors(q, 4096 / 512);
        gendisk->queue = q;
        gendisk->fops = &viocd_fops;

diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 1ec8b31277bdd98104f77ec10d8ddbd2c4d14139..f8c1ae6ad74c6b4ef46681e3942ce5c71b068fa5 100644 (file)
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -790,8 +790,7 @@ static int ide_init_queue(ide_drive_t *drive)
                max_sg_entries >>= 1;
 #endif /* CONFIG_PCI */
 
-       blk_queue_max_hw_segments(q, max_sg_entries);
-       blk_queue_max_phys_segments(q, max_sg_entries);
+       blk_queue_max_segments(q, max_sg_entries);
 
        /* assign drive queue */
        drive->queue = q;

diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index ceb24afdc147aada31741b10213443375617257f..509c8f3dd9a565f35f1e53ed7d8a0987e8b05d74 100644 (file)
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3739,7 +3739,7 @@ static int bio_fits_rdev(struct bio *bi)
        if ((bi->bi_size>>9) > queue_max_sectors(q))
                return 0;
        blk_recount_segments(q, bi);
-       if (bi->bi_phys_segments > queue_max_phys_segments(q))
+       if (bi->bi_phys_segments > queue_max_segments(q))
                return 0;
 
        if (q->merge_bvec_fn)

diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index 44d4178c4c1577a7be0084ceb8765fcea1c7d6d0..972b87069d55aad0e6d27eba6b7fbbba55064598 100644 (file)
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -1227,8 +1227,7 @@ static int mspro_block_init_disk(struct memstick_dev *card)
 
        blk_queue_bounce_limit(msb->queue, limit);
        blk_queue_max_hw_sectors(msb->queue, MSPRO_BLOCK_MAX_PAGES);
-       blk_queue_max_phys_segments(msb->queue, MSPRO_BLOCK_MAX_SEGS);
-       blk_queue_max_hw_segments(msb->queue, MSPRO_BLOCK_MAX_SEGS);
+       blk_queue_max_segments(msb->queue, MSPRO_BLOCK_MAX_SEGS);
        blk_queue_max_segment_size(msb->queue,
                                   MSPRO_BLOCK_MAX_PAGES * msb->page_size);
 

diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index d033cfdb516f81052e2dcb0d69b83bcaa8e552fa..2658b1484a2c7ba0480d99ad413087fb70cf523b 100644 (file)
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -1065,9 +1065,8 @@ static int i2o_block_probe(struct device *dev)
        queue = gd->queue;
        queue->queuedata = i2o_blk_dev;
 
-       blk_queue_max_phys_segments(queue, I2O_MAX_PHYS_SEGMENTS);
        blk_queue_max_hw_sectors(queue, max_sectors);
-       blk_queue_max_hw_segments(queue, i2o_sg_tablesize(c, body_size));
+       blk_queue_max_segments(queue, i2o_sg_tablesize(c, body_size));
 
        osm_debug("max sectors = %d\n", queue->max_sectors);
        osm_debug("phys segments = %d\n", queue->max_phys_segments);

diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 09b633d5657b706aab8bc81e3cdc23c6e9015cac..381fe032caa129039c89da492a0b092f5540aed1 100644 (file)
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -155,8 +155,7 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
                if (mq->bounce_buf) {
                        blk_queue_bounce_limit(mq->queue, BLK_BOUNCE_ANY);
                        blk_queue_max_hw_sectors(mq->queue, bouncesz / 512);
-                       blk_queue_max_phys_segments(mq->queue, bouncesz / 512);
-                       blk_queue_max_hw_segments(mq->queue, bouncesz / 512);
+                       blk_queue_max_segments(mq->queue, bouncesz / 512);
                        blk_queue_max_segment_size(mq->queue, bouncesz);
 
                        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
                blk_queue_bounce_limit(mq->queue, limit);
                blk_queue_max_hw_sectors(mq->queue,
                        min(host->max_blk_count, host->max_req_size / 512));
-               blk_queue_max_phys_segments(mq->queue, host->max_phys_segs);
-               blk_queue_max_hw_segments(mq->queue, host->max_hw_segs);
+               blk_queue_max_segments(mq->queue, host->max_hw_segs);
                blk_queue_max_segment_size(mq->queue, host->max_seg_size);
 
                mq->sg = kmalloc(sizeof(struct scatterlist) *

diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 14b1e25b9dcf05efb8d978f3fd7a3ddac3700362..8831e9308d0579bee4f866e1d89e0b973200ab92 100644 (file)
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -2130,8 +2130,7 @@ static void dasd_setup_queue(struct dasd_block *block)
        blk_queue_logical_block_size(block->request_queue, block->bp_block);
        max = block->base->discipline->max_blocks << block->s2b_shift;
        blk_queue_max_hw_sectors(block->request_queue, max);
-       blk_queue_max_phys_segments(block->request_queue, -1L);
-       blk_queue_max_hw_segments(block->request_queue, -1L);
+       blk_queue_max_segments(block->request_queue, -1L);
        /* with page sized segments we can translate each segement into
         * one idaw/tidaw
         */

diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index 509ed056fdddc51daccdb1d35174344ccb701206..097da8ce6be6631eb515105773e523be43f02fb5 100644 (file)
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -223,8 +223,7 @@ tapeblock_setup_device(struct tape_device * device)
 
        blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
        blk_queue_max_hw_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
-       blk_queue_max_phys_segments(blkdat->request_queue, -1L);
-       blk_queue_max_hw_segments(blkdat->request_queue, -1L);
+       blk_queue_max_segments(blkdat->request_queue, -1L);
        blk_queue_max_segment_size(blkdat->request_queue, -1L);
        blk_queue_segment_boundary(blkdat->request_queue, -1L);
 

diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index 87b536a97cb4b7abddb1c46f7ac734926d61f1dd..732f6d35b4a8e4aebf9af1c7ef07bb593edf9a3f 100644 (file)
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -4195,7 +4195,7 @@ static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
                if (tgt->service_parms.class3_parms[0] & 0x80000000)
                        rport->supported_classes |= FC_COS_CLASS3;
                if (rport->rqst_q)
-                       blk_queue_max_hw_segments(rport->rqst_q, 1);
+                       blk_queue_max_segments(rport->rqst_q, 1);
        } else
                tgt_dbg(tgt, "rport add failed\n");
        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)
        }
 
        if (shost_to_fc_host(shost)->rqst_q)
-               blk_queue_max_hw_segments(shost_to_fc_host(shost)->rqst_q, 1);
+               blk_queue_max_segments(shost_to_fc_host(shost)->rqst_q, 1);
        dev_set_drvdata(dev, vhost);
        spin_lock(&ibmvfc_driver_lock);
        list_add_tail(&vhost->queue, &ibmvfc_head);

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index ac3cca74bdfb787660e3614bdf878ab9d6dc3d65..f8fbf47377aeca14532a75d0c51d418e4c34a1f4 100644 (file)
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1624,8 +1624,8 @@ struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
        /*
         * this limit is imposed by hardware restrictions
         */
-       blk_queue_max_hw_segments(q, shost->sg_tablesize);
-       blk_queue_max_phys_segments(q, SCSI_MAX_SG_CHAIN_SEGMENTS);
+       blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,
+                                       SCSI_MAX_SG_CHAIN_SEGMENTS));
 
        blk_queue_max_hw_sectors(q, shost->max_sectors);
        blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));

diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 040f751809ea97c4e09af568aa327e178e9f4218..c996d98636f340704b82c0fab8d445c1591823ff 100644 (file)
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -287,8 +287,7 @@ sg_open(struct inode *inode, struct file *filp)
        if (list_empty(&sdp->sfds)) {   /* no existing opens on this device */
                sdp->sgdebug = 0;
                q = sdp->device->request_queue;
-               sdp->sg_tablesize = min(queue_max_hw_segments(q),
-                                       queue_max_phys_segments(q));
+               sdp->sg_tablesize = queue_max_segments(q);
        }
        if ((sfp = sg_add_sfp(sdp, dev)))
                filp->private_data = sfp;
@@ -1376,8 +1375,7 @@ static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
        sdp->device = scsidp;
        INIT_LIST_HEAD(&sdp->sfds);
        init_waitqueue_head(&sdp->o_excl_wait);
-       sdp->sg_tablesize = min(queue_max_hw_segments(q),
-                               queue_max_phys_segments(q));
+       sdp->sg_tablesize = queue_max_segments(q);
        sdp->index = k;
        kref_init(&sdp->d_ref);
 

diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index d04ea9a6f6732b27526d748ba5b2524e6ebb7c23..f67d1a159aad9173982bacce034b88f7d7cb6732 100644 (file)
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -3983,8 +3983,7 @@ static int st_probe(struct device *dev)
                return -ENODEV;
        }
 
-       i = min(queue_max_hw_segments(SDp->request_queue),
-               queue_max_phys_segments(SDp->request_queue));
+       i = queue_max_segments(SDp->request_queue);
        if (st_max_sg_segs < i)
                i = st_max_sg_segs;
        buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);

diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 62b282844a53eb2e29ff96e418d95d778b1fc700..45d908114d11c27961ad04b713863805a9142dac 100644 (file)
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -363,10 +363,7 @@ static int blkvsc_probe(struct device *device)
        blkdev->gd->queue = blk_init_queue(blkvsc_request, &blkdev->lock);
 
        blk_queue_max_segment_size(blkdev->gd->queue, PAGE_SIZE);
-       blk_queue_max_phys_segments(blkdev->gd->queue,
-                                   MAX_MULTIPAGE_BUFFER_COUNT);
-       blk_queue_max_hw_segments(blkdev->gd->queue,
-                                 MAX_MULTIPAGE_BUFFER_COUNT);
+       blk_queue_max_segments(blkdev->gd->queue, MAX_MULTIPAGE_BUFFER_COUNT);
        blk_queue_segment_boundary(blkdev->gd->queue, PAGE_SIZE-1);
        blk_queue_bounce_limit(blkdev->gd->queue, BLK_BOUNCE_ANY);
        blk_queue_dma_alignment(blkdev->gd->queue, 511);

diff --git a/fs/bio.c b/fs/bio.c
index 88094afc29ea38c13906d861ca9bb7dd67c463a2..dc17afd672e354810d4b7b2d54e21d466bf8cca8 100644 (file)
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -507,10 +507,8 @@ int bio_get_nr_vecs(struct block_device *bdev)
        int nr_pages;
 
        nr_pages = ((queue_max_sectors(q) << 9) + PAGE_SIZE - 1) >> PAGE_SHIFT;
-       if (nr_pages > queue_max_phys_segments(q))
-               nr_pages = queue_max_phys_segments(q);
-       if (nr_pages > queue_max_hw_segments(q))
-               nr_pages = queue_max_hw_segments(q);
+       if (nr_pages > queue_max_segments(q))
+               nr_pages = queue_max_segments(q);
 
        return nr_pages;
 }
@@ -575,8 +573,7 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
         * make this too complex.
         */
 
-       while (bio->bi_phys_segments >= queue_max_phys_segments(q)
-              || bio->bi_phys_segments >= queue_max_hw_segments(q)) {
+       while (bio->bi_phys_segments >= queue_max_segments(q)) {
 
                if (retried_segments)
                        return 0;

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 57bc48446e924df5f2a7dd027be6187768805ffd..ebd22dbed861da16481a1f4995dd9460f71caca4 100644 (file)
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -316,8 +316,7 @@ struct queue_limits {
        unsigned int            discard_alignment;
 
        unsigned short          logical_block_size;
-       unsigned short          max_hw_segments;
-       unsigned short          max_phys_segments;
+       unsigned short          max_segments;
 
        unsigned char           misaligned;
        unsigned char           discard_misaligned;
@@ -929,8 +928,19 @@ static inline void blk_queue_max_sectors(struct request_queue *q, unsigned int m
        blk_queue_max_hw_sectors(q, max);
 }
 
-extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
-extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
+extern void blk_queue_max_segments(struct request_queue *, unsigned short);
+
+static inline void blk_queue_max_phys_segments(struct request_queue *q, unsigned short max)
+{
+       blk_queue_max_segments(q, max);
+}
+
+static inline void blk_queue_max_hw_segments(struct request_queue *q, unsigned short max)
+{
+       blk_queue_max_segments(q, max);
+}
+
+
 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
 extern void blk_queue_max_discard_sectors(struct request_queue *q,
                unsigned int max_discard_sectors);
@@ -1055,14 +1065,9 @@ static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
        return q->limits.max_hw_sectors;
 }
 
-static inline unsigned short queue_max_hw_segments(struct request_queue *q)
-{
-       return q->limits.max_hw_segments;
-}
-
-static inline unsigned short queue_max_phys_segments(struct request_queue *q)
+static inline unsigned short queue_max_segments(struct request_queue *q)
 {
-       return q->limits.max_phys_segments;
+       return q->limits.max_segments;
 }
 
 static inline unsigned int queue_max_segment_size(struct request_queue *q)

diff --git a/include/linux/i2o.h b/include/linux/i2o.h
index 4c4e57d1f19d74c245c7e70e09c5e9428f838089..87018dc5527dac26d9baf1eefd000b56f74509ff 100644 (file)
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -385,7 +385,7 @@
 /* defines for max_sectors and max_phys_segments */
 #define I2O_MAX_SECTORS                        1024
 #define I2O_MAX_SECTORS_LIMITED                128
-#define I2O_MAX_PHYS_SEGMENTS          MAX_PHYS_SEGMENTS
+#define I2O_MAX_PHYS_SEGMENTS          BLK_MAX_SEGMENTS
 
 /*
  *     Message structures