mirror of
https://github.com/torvalds/linux
synced 2024-09-21 03:28:37 +00:00
Merge branch 'for-2.6.34-next' into for-2.6.34
This commit is contained in:
Jens Axboe
commit
6fc2de06ef
|
|
@ -747,7 +747,7 @@ static int ubd_open_dev(struct ubd *ubd_dev)
|
|||
ubd_dev->fd = fd;
|
||||
|
||||
if(ubd_dev->cow.file != NULL){
|
||||
blk_queue_max_sectors(ubd_dev->queue, 8 * sizeof(long));
|
||||
blk_queue_max_hw_sectors(ubd_dev->queue, 8 * sizeof(long));
|
||||
|
||||
err = -ENOMEM;
|
||||
ubd_dev->cow.bitmap = vmalloc(ubd_dev->cow.bitmap_len);
|
||||
|
|
@ -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";
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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... */
|
||||
|
|
|
|||
|
|
@ -91,10 +91,9 @@ 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 = MAX_SEGMENT_SIZE;
|
||||
lim->max_segment_size = BLK_MAX_SEGMENT_SIZE;
|
||||
lim->max_sectors = BLK_DEF_MAX_SECTORS;
|
||||
lim->max_hw_sectors = INT_MAX;
|
||||
lim->max_discard_sectors = 0;
|
||||
|
|
@ -154,7 +153,7 @@ void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
|
|||
q->unplug_timer.data = (unsigned long)q;
|
||||
|
||||
blk_set_default_limits(&q->limits);
|
||||
blk_queue_max_sectors(q, SAFE_MAX_SECTORS);
|
||||
blk_queue_max_hw_sectors(q, BLK_SAFE_MAX_SECTORS);
|
||||
|
||||
/*
|
||||
* If the caller didn't supply a lock, fall back to our embedded
|
||||
|
|
@ -210,37 +209,32 @@ void blk_queue_bounce_limit(struct request_queue *q, u64 dma_mask)
|
|||
EXPORT_SYMBOL(blk_queue_bounce_limit);
|
||||
|
||||
/**
|
||||
* blk_queue_max_sectors - set max sectors for a request for this queue
|
||||
* blk_queue_max_hw_sectors - set max sectors for a request for this queue
|
||||
* @q: the request queue for the device
|
||||
* @max_sectors: max sectors in the usual 512b unit
|
||||
* @max_hw_sectors: max hardware sectors in the usual 512b unit
|
||||
*
|
||||
* Description:
|
||||
* Enables a low level driver to set an upper limit on the size of
|
||||
* received requests.
|
||||
* Enables a low level driver to set a hard upper limit,
|
||||
* max_hw_sectors, on the size of requests. max_hw_sectors is set by
|
||||
* the device driver based upon the combined capabilities of I/O
|
||||
* controller and storage device.
|
||||
*
|
||||
* max_sectors is a soft limit imposed by the block layer for
|
||||
* filesystem type requests. This value can be overridden on a
|
||||
* per-device basis in /sys/block/<device>/queue/max_sectors_kb.
|
||||
* The soft limit can not exceed max_hw_sectors.
|
||||
**/
|
||||
void blk_queue_max_sectors(struct request_queue *q, unsigned int max_sectors)
|
||||
void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_hw_sectors)
|
||||
{
|
||||
if ((max_sectors << 9) < PAGE_CACHE_SIZE) {
|
||||
max_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
|
||||
if ((max_hw_sectors << 9) < PAGE_CACHE_SIZE) {
|
||||
max_hw_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
|
||||
printk(KERN_INFO "%s: set to minimum %d\n",
|
||||
__func__, max_sectors);
|
||||
__func__, max_hw_sectors);
|
||||
}
|
||||
|
||||
if (BLK_DEF_MAX_SECTORS > max_sectors)
|
||||
q->limits.max_hw_sectors = q->limits.max_sectors = max_sectors;
|
||||
else {
|
||||
q->limits.max_sectors = BLK_DEF_MAX_SECTORS;
|
||||
q->limits.max_hw_sectors = max_sectors;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(blk_queue_max_sectors);
|
||||
|
||||
void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_sectors)
|
||||
{
|
||||
if (BLK_DEF_MAX_SECTORS > max_sectors)
|
||||
q->limits.max_hw_sectors = BLK_DEF_MAX_SECTORS;
|
||||
else
|
||||
q->limits.max_hw_sectors = max_sectors;
|
||||
q->limits.max_hw_sectors = max_hw_sectors;
|
||||
q->limits.max_sectors = min_t(unsigned int, max_hw_sectors,
|
||||
BLK_DEF_MAX_SECTORS);
|
||||
}
|
||||
EXPORT_SYMBOL(blk_queue_max_hw_sectors);
|
||||
|
||||
|
|
@ -257,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;
|
||||
|
|
@ -275,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
|
||||
|
|
@ -536,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);
|
||||
|
|
@ -744,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;
|
||||
|
|
|
|||
|
|
@ -1097,7 +1097,7 @@ static int ata_scsi_dev_config(struct scsi_device *sdev,
|
|||
dev->flags |= ATA_DFLAG_NO_UNLOAD;
|
||||
|
||||
/* configure max sectors */
|
||||
blk_queue_max_sectors(sdev->request_queue, dev->max_sectors);
|
||||
blk_queue_max_hw_sectors(sdev->request_queue, dev->max_sectors);
|
||||
|
||||
if (dev->class == ATA_DEV_ATAPI) {
|
||||
struct request_queue *q = sdev->request_queue;
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -2534,8 +2534,8 @@ 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_sectors(RequestQueue, Controller->MaxBlocksPerCommand);
|
||||
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);
|
||||
disk->major = MajorNumber;
|
||||
|
|
|
|||
|
|
@ -434,7 +434,7 @@ static struct brd_device *brd_alloc(int i)
|
|||
goto out_free_dev;
|
||||
blk_queue_make_request(brd->brd_queue, brd_make_request);
|
||||
blk_queue_ordered(brd->brd_queue, QUEUE_ORDERED_TAG, NULL);
|
||||
blk_queue_max_sectors(brd->brd_queue, 1024);
|
||||
blk_queue_max_hw_sectors(brd->brd_queue, 1024);
|
||||
blk_queue_bounce_limit(brd->brd_queue, BLK_BOUNCE_ANY);
|
||||
|
||||
disk = brd->brd_disk = alloc_disk(1 << part_shift);
|
||||
|
|
|
|||
|
|
@ -1797,12 +1797,9 @@ 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);
|
||||
blk_queue_max_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_sectors(disk->queue, h->cciss_max_sectors);
|
||||
blk_queue_max_hw_sectors(disk->queue, h->cciss_max_sectors);
|
||||
|
||||
blk_queue_softirq_done(disk->queue, cciss_softirq_done);
|
||||
|
||||
|
|
|
|||
|
|
@ -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];
|
||||
|
|
|
|||
|
|
@ -709,9 +709,8 @@ 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_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_hw_sectors(q, max_seg_s >> 9);
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -4234,7 +4234,7 @@ static int __init floppy_init(void)
|
|||
err = -ENOMEM;
|
||||
goto out_unreg_driver;
|
||||
}
|
||||
blk_queue_max_sectors(floppy_queue, 64);
|
||||
blk_queue_max_hw_sectors(floppy_queue, 64);
|
||||
|
||||
blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
|
||||
floppy_find, NULL, NULL);
|
||||
|
|
|
|||
|
|
@ -719,7 +719,7 @@ static int __init hd_init(void)
|
|||
return -ENOMEM;
|
||||
}
|
||||
|
||||
blk_queue_max_sectors(hd_queue, 255);
|
||||
blk_queue_max_hw_sectors(hd_queue, 255);
|
||||
init_timer(&device_timer);
|
||||
device_timer.function = hd_times_out;
|
||||
blk_queue_logical_block_size(hd_queue, 512);
|
||||
|
|
|
|||
|
|
@ -980,7 +980,7 @@ static int mg_probe(struct platform_device *plat_dev)
|
|||
__func__, __LINE__);
|
||||
goto probe_err_6;
|
||||
}
|
||||
blk_queue_max_sectors(host->breq, MG_MAX_SECTS);
|
||||
blk_queue_max_hw_sectors(host->breq, MG_MAX_SECTS);
|
||||
blk_queue_logical_block_size(host->breq, MG_SECTOR_SIZE);
|
||||
|
||||
init_timer(&host->timer);
|
||||
|
|
|
|||
|
|
@ -906,7 +906,7 @@ static int __init pd_init(void)
|
|||
if (!pd_queue)
|
||||
goto out1;
|
||||
|
||||
blk_queue_max_sectors(pd_queue, cluster);
|
||||
blk_queue_max_hw_sectors(pd_queue, cluster);
|
||||
|
||||
if (register_blkdev(major, name))
|
||||
goto out2;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -2312,7 +2312,7 @@ static int pkt_open_dev(struct pktcdvd_device *pd, fmode_t write)
|
|||
* even if the size is a multiple of the packet size.
|
||||
*/
|
||||
spin_lock_irq(q->queue_lock);
|
||||
blk_queue_max_sectors(q, pd->settings.size);
|
||||
blk_queue_max_hw_sectors(q, pd->settings.size);
|
||||
spin_unlock_irq(q->queue_lock);
|
||||
set_bit(PACKET_WRITABLE, &pd->flags);
|
||||
} else {
|
||||
|
|
@ -2613,7 +2613,7 @@ static void pkt_init_queue(struct pktcdvd_device *pd)
|
|||
|
||||
blk_queue_make_request(q, pkt_make_request);
|
||||
blk_queue_logical_block_size(q, CD_FRAMESIZE);
|
||||
blk_queue_max_sectors(q, PACKET_MAX_SECTORS);
|
||||
blk_queue_max_hw_sectors(q, PACKET_MAX_SECTORS);
|
||||
blk_queue_merge_bvec(q, pkt_merge_bvec);
|
||||
q->queuedata = pd;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -474,7 +474,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
|
|||
|
||||
blk_queue_bounce_limit(queue, BLK_BOUNCE_HIGH);
|
||||
|
||||
blk_queue_max_sectors(queue, dev->bounce_size >> 9);
|
||||
blk_queue_max_hw_sectors(queue, dev->bounce_size >> 9);
|
||||
blk_queue_segment_boundary(queue, -1UL);
|
||||
blk_queue_dma_alignment(queue, dev->blk_size-1);
|
||||
blk_queue_logical_block_size(queue, dev->blk_size);
|
||||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -751,10 +751,9 @@ 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_segment_size(queue, MAX_SEGMENT_SIZE);
|
||||
blk_queue_max_sectors(queue, SAFE_MAX_SECTORS);
|
||||
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);
|
||||
|
||||
gendisk = alloc_disk(1);
|
||||
if (!gendisk) {
|
||||
|
|
|
|||
|
|
@ -691,9 +691,8 @@ 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_sectors(q, port->max_xfer_size);
|
||||
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;
|
||||
strcpy(g->disk_name, port->disk_name);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -2320,10 +2320,9 @@ 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_sectors(q, UB_MAX_SECTORS);
|
||||
blk_queue_max_hw_sectors(q, UB_MAX_SECTORS);
|
||||
blk_queue_logical_block_size(q, lun->capacity.bsize);
|
||||
|
||||
lun->disk = disk;
|
||||
|
|
|
|||
|
|
@ -471,9 +471,8 @@ static int probe_disk(struct viodasd_device *d)
|
|||
}
|
||||
|
||||
d->disk = g;
|
||||
blk_queue_max_hw_segments(q, VIOMAXBLOCKDMA);
|
||||
blk_queue_max_phys_segments(q, VIOMAXBLOCKDMA);
|
||||
blk_queue_max_sectors(q, VIODASD_MAXSECTORS);
|
||||
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;
|
||||
if (dev_no >= 26)
|
||||
|
|
|
|||
|
|
@ -242,7 +242,7 @@ static int __init xd_init(void)
|
|||
}
|
||||
|
||||
/* xd_maxsectors depends on controller - so set after detection */
|
||||
blk_queue_max_sectors(xd_queue, xd_maxsectors);
|
||||
blk_queue_max_hw_sectors(xd_queue, xd_maxsectors);
|
||||
|
||||
for (i = 0; i < xd_drives; i++)
|
||||
add_disk(xd_gendisk[i]);
|
||||
|
|
|
|||
|
|
@ -346,15 +346,14 @@ static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size)
|
|||
|
||||
/* Hard sector size and max sectors impersonate the equiv. hardware. */
|
||||
blk_queue_logical_block_size(rq, sector_size);
|
||||
blk_queue_max_sectors(rq, 512);
|
||||
blk_queue_max_hw_sectors(rq, 512);
|
||||
|
||||
/* Each segment in a request is up to an aligned page in size. */
|
||||
blk_queue_segment_boundary(rq, PAGE_SIZE - 1);
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -616,9 +616,8 @@ 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_sectors(q, 4096 / 512);
|
||||
blk_queue_max_segments(q, 1);
|
||||
blk_queue_max_hw_sectors(q, 4096 / 512);
|
||||
gendisk->queue = q;
|
||||
gendisk->fops = &viocd_fops;
|
||||
gendisk->flags = GENHD_FL_CD|GENHD_FL_REMOVABLE;
|
||||
|
|
|
|||
|
|
@ -1571,7 +1571,7 @@ static int sbp2_scsi_slave_configure(struct scsi_device *sdev)
|
|||
sdev->start_stop_pwr_cond = 1;
|
||||
|
||||
if (lu->tgt->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
|
||||
blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
|
||||
blk_queue_max_hw_sectors(sdev->request_queue, 128 * 1024 / 512);
|
||||
|
||||
blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);
|
||||
|
||||
|
|
|
|||
|
|
@ -679,7 +679,7 @@ static void ide_disk_setup(ide_drive_t *drive)
|
|||
if (max_s > hwif->rqsize)
|
||||
max_s = hwif->rqsize;
|
||||
|
||||
blk_queue_max_sectors(q, max_s);
|
||||
blk_queue_max_hw_sectors(q, max_s);
|
||||
}
|
||||
|
||||
printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
|
||||
|
|
|
|||
|
|
@ -486,7 +486,7 @@ static void ide_floppy_setup(ide_drive_t *drive)
|
|||
drive->atapi_flags |= IDE_AFLAG_ZIP_DRIVE;
|
||||
/* This value will be visible in the /proc/ide/hdx/settings */
|
||||
drive->pc_delay = IDEFLOPPY_PC_DELAY;
|
||||
blk_queue_max_sectors(drive->queue, 64);
|
||||
blk_queue_max_hw_sectors(drive->queue, 64);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -494,7 +494,7 @@ static void ide_floppy_setup(ide_drive_t *drive)
|
|||
* nasty clicking noises without it, so please don't remove this.
|
||||
*/
|
||||
if (strncmp((char *)&id[ATA_ID_PROD], "IOMEGA Clik!", 11) == 0) {
|
||||
blk_queue_max_sectors(drive->queue, 64);
|
||||
blk_queue_max_hw_sectors(drive->queue, 64);
|
||||
drive->atapi_flags |= IDE_AFLAG_CLIK_DRIVE;
|
||||
/* IOMEGA Clik! drives do not support lock/unlock commands */
|
||||
drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
|
||||
|
|
|
|||
|
|
@ -774,7 +774,7 @@ static int ide_init_queue(ide_drive_t *drive)
|
|||
|
||||
if (hwif->rqsize < max_sectors)
|
||||
max_sectors = hwif->rqsize;
|
||||
blk_queue_max_sectors(q, max_sectors);
|
||||
blk_queue_max_hw_sectors(q, max_sectors);
|
||||
|
||||
#ifdef CONFIG_PCI
|
||||
/* When we have an IOMMU, we may have a problem where pci_map_sg()
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -2020,7 +2020,7 @@ static int sbp2scsi_slave_configure(struct scsi_device *sdev)
|
|||
if (lu->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
|
||||
sdev->start_stop_pwr_cond = 1;
|
||||
if (lu->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
|
||||
blk_queue_max_sectors(sdev->request_queue, 128 * 1024 / 512);
|
||||
blk_queue_max_hw_sectors(sdev->request_queue, 128 * 1024 / 512);
|
||||
|
||||
blk_queue_max_segment_size(sdev->request_queue, SBP2_MAX_SEG_SIZE);
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -177,7 +177,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
|
|||
*/
|
||||
if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
|
||||
queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
|
||||
blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
|
||||
conf->array_sectors += rdev->sectors;
|
||||
cnt++;
|
||||
|
|
|
|||
|
|
@ -308,7 +308,7 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
|
|||
*/
|
||||
if (q->merge_bvec_fn &&
|
||||
queue_max_sectors(q) > (PAGE_SIZE>>9))
|
||||
blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
|
||||
conf->working_disks++;
|
||||
mddev->degraded--;
|
||||
|
|
@ -478,7 +478,7 @@ static int multipath_run (mddev_t *mddev)
|
|||
* a merge_bvec_fn to be involved in multipath */
|
||||
if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
|
||||
queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
|
||||
blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
|
||||
if (!test_bit(Faulty, &rdev->flags))
|
||||
conf->working_disks++;
|
||||
|
|
|
|||
|
|
@ -182,7 +182,7 @@ static int create_strip_zones(mddev_t *mddev)
|
|||
|
||||
if (rdev1->bdev->bd_disk->queue->merge_bvec_fn &&
|
||||
queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
|
||||
blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
|
||||
if (!smallest || (rdev1->sectors < smallest->sectors))
|
||||
smallest = rdev1;
|
||||
|
|
@ -325,7 +325,7 @@ static int raid0_run(mddev_t *mddev)
|
|||
}
|
||||
if (md_check_no_bitmap(mddev))
|
||||
return -EINVAL;
|
||||
blk_queue_max_sectors(mddev->queue, mddev->chunk_sectors);
|
||||
blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
|
||||
mddev->queue->queue_lock = &mddev->queue->__queue_lock;
|
||||
|
||||
ret = create_strip_zones(mddev);
|
||||
|
|
|
|||
|
|
@ -1158,7 +1158,7 @@ static int raid1_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
|
|||
*/
|
||||
if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
|
||||
queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
|
||||
blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
|
||||
p->head_position = 0;
|
||||
rdev->raid_disk = mirror;
|
||||
|
|
@ -2103,7 +2103,7 @@ static int run(mddev_t *mddev)
|
|||
*/
|
||||
if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
|
||||
queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
|
||||
blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
}
|
||||
|
||||
mddev->degraded = 0;
|
||||
|
|
|
|||
|
|
@ -1161,7 +1161,7 @@ static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
|
|||
*/
|
||||
if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
|
||||
queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
|
||||
blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
|
||||
p->head_position = 0;
|
||||
rdev->raid_disk = mirror;
|
||||
|
|
@ -2260,7 +2260,7 @@ static int run(mddev_t *mddev)
|
|||
*/
|
||||
if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
|
||||
queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
|
||||
blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
|
||||
|
||||
disk->head_position = 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -1226,9 +1226,8 @@ static int mspro_block_init_disk(struct memstick_dev *card)
|
|||
blk_queue_prep_rq(msb->queue, mspro_block_prepare_req);
|
||||
|
||||
blk_queue_bounce_limit(msb->queue, limit);
|
||||
blk_queue_max_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_hw_sectors(msb->queue, MSPRO_BLOCK_MAX_PAGES);
|
||||
blk_queue_max_segments(msb->queue, MSPRO_BLOCK_MAX_SEGS);
|
||||
blk_queue_max_segment_size(msb->queue,
|
||||
MSPRO_BLOCK_MAX_PAGES * msb->page_size);
|
||||
|
||||
|
|
|
|||
|
|
@ -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_sectors(queue, max_sectors);
|
||||
blk_queue_max_hw_segments(queue, i2o_sg_tablesize(c, body_size));
|
||||
blk_queue_max_hw_sectors(queue, max_sectors);
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -154,9 +154,8 @@ 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_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_hw_sectors(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),
|
||||
|
|
@ -180,10 +179,9 @@ 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, limit);
|
||||
blk_queue_max_sectors(mq->queue,
|
||||
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) *
|
||||
|
|
|
|||
|
|
@ -2129,9 +2129,8 @@ 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_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_hw_sectors(block->request_queue, max);
|
||||
blk_queue_max_segments(block->request_queue, -1L);
|
||||
/* with page sized segments we can translate each segement into
|
||||
* one idaw/tidaw
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -222,9 +222,8 @@ tapeblock_setup_device(struct tape_device * device)
|
|||
goto cleanup_queue;
|
||||
|
||||
blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
|
||||
blk_queue_max_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_hw_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
|
||||
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);
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -3674,7 +3674,7 @@ static int ipr_slave_configure(struct scsi_device *sdev)
|
|||
if (ipr_is_vset_device(res)) {
|
||||
blk_queue_rq_timeout(sdev->request_queue,
|
||||
IPR_VSET_RW_TIMEOUT);
|
||||
blk_queue_max_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
|
||||
blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
|
||||
}
|
||||
if (ipr_is_vset_device(res) || ipr_is_scsi_disk(res))
|
||||
sdev->allow_restart = 1;
|
||||
|
|
|
|||
|
|
@ -235,7 +235,7 @@ static int pmcraid_slave_configure(struct scsi_device *scsi_dev)
|
|||
scsi_dev->allow_restart = 1;
|
||||
blk_queue_rq_timeout(scsi_dev->request_queue,
|
||||
PMCRAID_VSET_IO_TIMEOUT);
|
||||
blk_queue_max_sectors(scsi_dev->request_queue,
|
||||
blk_queue_max_hw_sectors(scsi_dev->request_queue,
|
||||
PMCRAID_VSET_MAX_SECTORS);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1624,10 +1624,10 @@ 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_sectors(q, shost->max_sectors);
|
||||
blk_queue_max_hw_sectors(q, shost->max_sectors);
|
||||
blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));
|
||||
blk_queue_segment_boundary(q, shost->dma_boundary);
|
||||
dma_set_seg_boundary(dev, shost->dma_boundary);
|
||||
|
|
|
|||
|
|
@ -879,7 +879,7 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
|
|||
* broken RA4x00 Compaq Disk Array
|
||||
*/
|
||||
if (*bflags & BLIST_MAX_512)
|
||||
blk_queue_max_sectors(sdev->request_queue, 512);
|
||||
blk_queue_max_hw_sectors(sdev->request_queue, 512);
|
||||
|
||||
/*
|
||||
* Some devices may not want to have a start command automatically
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -134,14 +134,14 @@ static int slave_configure(struct scsi_device *sdev)
|
|||
if (us->fflags & US_FL_MAX_SECTORS_MIN)
|
||||
max_sectors = PAGE_CACHE_SIZE >> 9;
|
||||
if (queue_max_sectors(sdev->request_queue) > max_sectors)
|
||||
blk_queue_max_sectors(sdev->request_queue,
|
||||
blk_queue_max_hw_sectors(sdev->request_queue,
|
||||
max_sectors);
|
||||
} else if (sdev->type == TYPE_TAPE) {
|
||||
/* Tapes need much higher max_sector limits, so just
|
||||
* raise it to the maximum possible (4 GB / 512) and
|
||||
* let the queue segment size sort out the real limit.
|
||||
*/
|
||||
blk_queue_max_sectors(sdev->request_queue, 0x7FFFFF);
|
||||
blk_queue_max_hw_sectors(sdev->request_queue, 0x7FFFFF);
|
||||
}
|
||||
|
||||
/* Some USB host controllers can't do DMA; they have to use PIO.
|
||||
|
|
@ -495,7 +495,7 @@ static ssize_t store_max_sectors(struct device *dev, struct device_attribute *at
|
|||
unsigned short ms;
|
||||
|
||||
if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) {
|
||||
blk_queue_max_sectors(sdev->request_queue, ms);
|
||||
blk_queue_max_hw_sectors(sdev->request_queue, ms);
|
||||
return strlen(buf);
|
||||
}
|
||||
return -EINVAL;
|
||||
|
|
|
|||
9
fs/bio.c
9
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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
@ -921,10 +920,27 @@ extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
|
|||
extern void blk_cleanup_queue(struct request_queue *);
|
||||
extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
|
||||
extern void blk_queue_bounce_limit(struct request_queue *, u64);
|
||||
extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
|
||||
extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
|
||||
extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
|
||||
extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
|
||||
|
||||
/* Temporary compatibility wrapper */
|
||||
static inline void blk_queue_max_sectors(struct request_queue *q, unsigned int max)
|
||||
{
|
||||
blk_queue_max_hw_sectors(q, max);
|
||||
}
|
||||
|
||||
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);
|
||||
|
|
@ -1017,11 +1033,15 @@ extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
|
|||
#define MAX_PHYS_SEGMENTS 128
|
||||
#define MAX_HW_SEGMENTS 128
|
||||
#define SAFE_MAX_SECTORS 255
|
||||
#define BLK_DEF_MAX_SECTORS 1024
|
||||
|
||||
#define MAX_SEGMENT_SIZE 65536
|
||||
|
||||
#define BLK_SEG_BOUNDARY_MASK 0xFFFFFFFFUL
|
||||
enum blk_default_limits {
|
||||
BLK_MAX_SEGMENTS = 128,
|
||||
BLK_SAFE_MAX_SECTORS = 255,
|
||||
BLK_DEF_MAX_SECTORS = 1024,
|
||||
BLK_MAX_SEGMENT_SIZE = 65536,
|
||||
BLK_SEG_BOUNDARY_MASK = 0xFFFFFFFFUL,
|
||||
};
|
||||
|
||||
#define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
|
||||
|
||||
|
|
@ -1045,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)
|
||||
static inline unsigned short queue_max_segments(struct request_queue *q)
|
||||
{
|
||||
return q->limits.max_hw_segments;
|
||||
}
|
||||
|
||||
static inline unsigned short queue_max_phys_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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in a new issue