Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi
Pull SCSI fixes from James Bottomley:
"This is quite a bumper crop of fixes: three from Arnd correcting
various build issues in some configurations, a lock recursion in
qla2xxx. Two potentially exploitable issues in hpsa and mvsas, a
potential null deref in st, a revert of a bdi registration fix that
turned out to cause even more problems, a set of fixes to allow people
who only defined MPT2SAS to still work after the mpt2/mpt3sas merger
and a couple of fixes for issues turned up by the hyper-v storvsc
driver"
* tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi:
mpt3sas: fix Kconfig dependency problem for mpt2sas back compatibility
Revert "scsi: Fix a bdi reregistration race"
mpt3sas: Add dummy Kconfig option for backwards compatibility
Fix a memory leak in scsi_host_dev_release()
block/sd: Fix device-imposed transfer length limits
scsi_debug: fix prevent_allow+verify regressions
MAINTAINERS: Add myself as co-maintainer of the SCSI subsystem.
sd: Make discard granularity match logical block size when LBPRZ=1
scsi: hpsa: select CONFIG_SCSI_SAS_ATTR
scsi: advansys needs ISA dma api for ISA support
scsi_sysfs: protect against double execution of __scsi_remove_device()
st: fix potential null pointer dereference.
scsi: report 'INQUIRY result too short' once per host
advansys: fix big-endian builds
qla2xxx: Fix rwlock recursion
hpsa: logical vs bitwise AND typo
mvsas: don't allow negative timeouts
mpt3sas: Fix use sas_is_tlr_enabled API before enabling MPI2_SCSIIO_CONTROL_TLR_ON flag
+129
-70
+3
-1
MAINTAINERS
+3
-1
MAINTAINERS
···
9427
9427
9428
9428
SCSI SUBSYSTEM
9429
9429
M: "James E.J. Bottomley" <JBottomley@odin.com>
9430
-
L: linux-scsi@vger.kernel.org
9431
9430
T: git git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi.git
9431
+
M: "Martin K. Petersen" <martin.petersen@oracle.com>
9432
+
T: git git://git.kernel.org/pub/scm/linux/kernel/git/mkp/scsi.git
9433
+
L: linux-scsi@vger.kernel.org
9432
9434
S: Maintained
9433
9435
F: drivers/scsi/
9434
9436
F: include/scsi/
+16
-20
block/blk-settings.c
+16
-20
block/blk-settings.c
···
91
91
lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
92
92
lim->virt_boundary_mask = 0;
93
93
lim->max_segment_size = BLK_MAX_SEGMENT_SIZE;
94
-
lim->max_sectors = lim->max_hw_sectors = BLK_SAFE_MAX_SECTORS;
94
+
lim->max_sectors = lim->max_dev_sectors = lim->max_hw_sectors =
95
+
BLK_SAFE_MAX_SECTORS;
95
96
lim->chunk_sectors = 0;
96
97
lim->max_write_same_sectors = 0;
97
98
lim->max_discard_sectors = 0;
···
128
127
lim->max_hw_sectors = UINT_MAX;
129
128
lim->max_segment_size = UINT_MAX;
130
129
lim->max_sectors = UINT_MAX;
130
+
lim->max_dev_sectors = UINT_MAX;
131
131
lim->max_write_same_sectors = UINT_MAX;
132
132
}
133
133
EXPORT_SYMBOL(blk_set_stacking_limits);
···
216
214
EXPORT_SYMBOL(blk_queue_bounce_limit);
217
215
218
216
/**
219
-
* blk_limits_max_hw_sectors - set hard and soft limit of max sectors for request
220
-
* @limits: the queue limits
217
+
* blk_queue_max_hw_sectors - set max sectors for a request for this queue
218
+
* @q: the request queue for the device
221
219
* @max_hw_sectors: max hardware sectors in the usual 512b unit
222
220
*
223
221
* Description:
···
226
224
* the device driver based upon the capabilities of the I/O
227
225
* controller.
228
226
*
227
+
* max_dev_sectors is a hard limit imposed by the storage device for
228
+
* READ/WRITE requests. It is set by the disk driver.
229
+
*
229
230
* max_sectors is a soft limit imposed by the block layer for
230
231
* filesystem type requests. This value can be overridden on a
231
232
* per-device basis in /sys/block/<device>/queue/max_sectors_kb.
232
233
* The soft limit can not exceed max_hw_sectors.
233
234
**/
234
-
void blk_limits_max_hw_sectors(struct queue_limits *limits, unsigned int max_hw_sectors)
235
+
void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_hw_sectors)
235
236
{
237
+
struct queue_limits *limits = &q->limits;
238
+
unsigned int max_sectors;
239
+
236
240
if ((max_hw_sectors << 9) < PAGE_CACHE_SIZE) {
237
241
max_hw_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
238
242
printk(KERN_INFO "%s: set to minimum %d\n",
···
246
238
}
247
239
248
240
limits->max_hw_sectors = max_hw_sectors;
249
-
limits->max_sectors = min_t(unsigned int, max_hw_sectors,
250
-
BLK_DEF_MAX_SECTORS);
251
-
}
252
-
EXPORT_SYMBOL(blk_limits_max_hw_sectors);
253
-
254
-
/**
255
-
* blk_queue_max_hw_sectors - set max sectors for a request for this queue
256
-
* @q: the request queue for the device
257
-
* @max_hw_sectors: max hardware sectors in the usual 512b unit
258
-
*
259
-
* Description:
260
-
* See description for blk_limits_max_hw_sectors().
261
-
**/
262
-
void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_hw_sectors)
263
-
{
264
-
blk_limits_max_hw_sectors(&q->limits, max_hw_sectors);
241
+
max_sectors = min_not_zero(max_hw_sectors, limits->max_dev_sectors);
242
+
max_sectors = min_t(unsigned int, max_sectors, BLK_DEF_MAX_SECTORS);
243
+
limits->max_sectors = max_sectors;
265
244
}
266
245
EXPORT_SYMBOL(blk_queue_max_hw_sectors);
267
246
···
522
527
523
528
t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
524
529
t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
530
+
t->max_dev_sectors = min_not_zero(t->max_dev_sectors, b->max_dev_sectors);
525
531
t->max_write_same_sectors = min(t->max_write_same_sectors,
526
532
b->max_write_same_sectors);
527
533
t->bounce_pfn = min_not_zero(t->bounce_pfn, b->bounce_pfn);
+3
block/blk-sysfs.c
+3
block/blk-sysfs.c
+2
drivers/scsi/Kconfig
+2
drivers/scsi/Kconfig
···
364
364
tristate "HP Smart Array SCSI driver"
365
365
depends on PCI && SCSI
366
366
select CHECK_SIGNATURE
367
+
select SCSI_SAS_ATTRS
367
368
help
368
369
This driver supports HP Smart Array Controllers (circa 2009).
369
370
It is a SCSI alternative to the cciss driver, which is a block
···
500
499
tristate "AdvanSys SCSI support"
501
500
depends on SCSI
502
501
depends on ISA || EISA || PCI
502
+
depends on ISA_DMA_API || !ISA
503
503
help
504
504
This is a driver for all SCSI host adapters manufactured by
505
505
AdvanSys. It is documented in the kernel source in
+1
-1
drivers/scsi/advansys.c
+1
-1
drivers/scsi/advansys.c
+11
drivers/scsi/hosts.c
+11
drivers/scsi/hosts.c
···
333
333
kfree(queuedata);
334
334
}
335
335
336
+
if (shost->shost_state == SHOST_CREATED) {
337
+
/*
338
+
* Free the shost_dev device name here if scsi_host_alloc()
339
+
* and scsi_host_put() have been called but neither
340
+
* scsi_host_add() nor scsi_host_remove() has been called.
341
+
* This avoids that the memory allocated for the shost_dev
342
+
* name is leaked.
343
+
*/
344
+
kfree(dev_name(&shost->shost_dev));
345
+
}
346
+
336
347
scsi_destroy_command_freelist(shost);
337
348
if (shost_use_blk_mq(shost)) {
338
349
if (shost->tag_set.tags)
+1
-1
drivers/scsi/hpsa.c
+1
-1
drivers/scsi/hpsa.c
+9
drivers/scsi/mpt3sas/Kconfig
+9
drivers/scsi/mpt3sas/Kconfig
···
71
71
MAX_PHYS_SEGMENTS in most kernels. However in SuSE kernels this
72
72
can be 256. However, it may decreased down to 16. Decreasing this
73
73
parameter will reduce memory requirements on a per controller instance.
74
+
75
+
config SCSI_MPT2SAS
76
+
tristate "Legacy MPT2SAS config option"
77
+
default n
78
+
select SCSI_MPT3SAS
79
+
depends on PCI && SCSI
80
+
---help---
81
+
Dummy config option for backwards compatiblity: configure the MPT3SAS
82
+
driver instead.
+1
-2
drivers/scsi/mpt3sas/mpt3sas_scsih.c
+1
-2
drivers/scsi/mpt3sas/mpt3sas_scsih.c
···
3905
3905
* We do not expose raid functionality to upper layer for warpdrive.
3906
3906
*/
3907
3907
if (!ioc->is_warpdrive && !scsih_is_raid(&scmd->device->sdev_gendev)
3908
-
&& (sas_device_priv_data->flags & MPT_DEVICE_TLR_ON) &&
3909
-
scmd->cmd_len != 32)
3908
+
&& sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32)
3910
3909
mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
3911
3910
3912
3911
smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
+2
-2
drivers/scsi/mvsas/mv_init.c
+2
-2
drivers/scsi/mvsas/mv_init.c
···
758
758
struct device_attribute *attr,
759
759
const char *buffer, size_t size)
760
760
{
761
-
int val = 0;
761
+
unsigned int val = 0;
762
762
struct mvs_info *mvi = NULL;
763
763
struct Scsi_Host *shost = class_to_shost(cdev);
764
764
struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
···
766
766
if (buffer == NULL)
767
767
return size;
768
768
769
-
if (sscanf(buffer, "%d", &val) != 1)
769
+
if (sscanf(buffer, "%u", &val) != 1)
770
770
return -EINVAL;
771
771
772
772
if (val >= 0x10000) {
+2
-1
drivers/scsi/qla2xxx/qla_nx.c
+2
-1
drivers/scsi/qla2xxx/qla_nx.c
···
433
433
if (off_in < QLA82XX_PCI_CRBSPACE)
434
434
return -1;
435
435
436
-
*off_out = (void __iomem *)(off_in - QLA82XX_PCI_CRBSPACE);
436
+
off_in -= QLA82XX_PCI_CRBSPACE;
437
437
438
438
/* Try direct map */
439
439
m = &crb_128M_2M_map[CRB_BLK(off_in)].sub_block[CRB_SUBBLK(off_in)];
···
443
443
return 0;
444
444
}
445
445
/* Not in direct map, use crb window */
446
+
*off_out = (void __iomem *)off_in;
446
447
return 1;
447
448
}
448
449
+5
-4
drivers/scsi/scsi_debug.c
+5
-4
drivers/scsi/scsi_debug.c
···
465
465
0} },
466
466
{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* MAINT OUT */
467
467
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
468
-
{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* VERIFY */
469
-
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
468
+
{0, 0x2f, 0, F_D_OUT_MAYBE | FF_DIRECT_IO, NULL, NULL, /* VERIFY(10) */
469
+
{10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7,
470
+
0, 0, 0, 0, 0, 0} },
470
471
{1, 0x7f, 0x9, F_SA_HIGH | F_D_IN | FF_DIRECT_IO, resp_read_dt0,
471
472
vl_iarr, {32, 0xc7, 0, 0, 0, 0, 0x1f, 0x18, 0x0, 0x9, 0xfe, 0,
472
473
0xff, 0xff, 0xff, 0xff} },/* VARIABLE LENGTH, READ(32) */
···
478
477
{10, 0x13, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
479
478
0} },
480
479
/* 20 */
481
-
{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* ALLOW REMOVAL */
482
-
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
480
+
{0, 0x1e, 0, 0, NULL, NULL, /* ALLOW REMOVAL */
481
+
{6, 0, 0, 0, 0x3, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
483
482
{0, 0x1, 0, 0, resp_start_stop, NULL, /* REWIND ?? */
484
483
{6, 0x1, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
485
484
{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* ATA_PT */
+6
-3
drivers/scsi/scsi_scan.c
+6
-3
drivers/scsi/scsi_scan.c
···
701
701
* strings.
702
702
*/
703
703
if (sdev->inquiry_len < 36) {
704
-
sdev_printk(KERN_INFO, sdev,
705
-
"scsi scan: INQUIRY result too short (%d),"
706
-
" using 36\n", sdev->inquiry_len);
704
+
if (!sdev->host->short_inquiry) {
705
+
shost_printk(KERN_INFO, sdev->host,
706
+
"scsi scan: INQUIRY result too short (%d),"
707
+
" using 36\n", sdev->inquiry_len);
708
+
sdev->host->short_inquiry = 1;
709
+
}
707
710
sdev->inquiry_len = 36;
708
711
}
709
712
+11
-11
drivers/scsi/scsi_sysfs.c
+11
-11
drivers/scsi/scsi_sysfs.c
···
1102
1102
{
1103
1103
struct device *dev = &sdev->sdev_gendev;
1104
1104
1105
+
/*
1106
+
* This cleanup path is not reentrant and while it is impossible
1107
+
* to get a new reference with scsi_device_get() someone can still
1108
+
* hold a previously acquired one.
1109
+
*/
1110
+
if (sdev->sdev_state == SDEV_DEL)
1111
+
return;
1112
+
1105
1113
if (sdev->is_visible) {
1106
1114
if (scsi_device_set_state(sdev, SDEV_CANCEL) != 0)
1107
1115
return;
···
1118
1110
device_unregister(&sdev->sdev_dev);
1119
1111
transport_remove_device(dev);
1120
1112
scsi_dh_remove_device(sdev);
1121
-
}
1113
+
device_del(dev);
1114
+
} else
1115
+
put_device(&sdev->sdev_dev);
1122
1116
1123
1117
/*
1124
1118
* Stop accepting new requests and wait until all queuecommand() and
···
1130
1120
scsi_device_set_state(sdev, SDEV_DEL);
1131
1121
blk_cleanup_queue(sdev->request_queue);
1132
1122
cancel_work_sync(&sdev->requeue_work);
1133
-
1134
-
/*
1135
-
* Remove the device after blk_cleanup_queue() has been called such
1136
-
* a possible bdi_register() call with the same name occurs after
1137
-
* blk_cleanup_queue() has called bdi_destroy().
1138
-
*/
1139
-
if (sdev->is_visible)
1140
-
device_del(dev);
1141
-
else
1142
-
put_device(&sdev->sdev_dev);
1143
1123
1144
1124
if (sdev->host->hostt->slave_destroy)
1145
1125
sdev->host->hostt->slave_destroy(sdev);
+48
-21
drivers/scsi/sd.c
+48
-21
drivers/scsi/sd.c
···
638
638
unsigned int max_blocks = 0;
639
639
640
640
q->limits.discard_zeroes_data = 0;
641
-
q->limits.discard_alignment = sdkp->unmap_alignment *
642
-
logical_block_size;
643
-
q->limits.discard_granularity =
644
-
max(sdkp->physical_block_size,
645
-
sdkp->unmap_granularity * logical_block_size);
641
+
642
+
/*
643
+
* When LBPRZ is reported, discard alignment and granularity
644
+
* must be fixed to the logical block size. Otherwise the block
645
+
* layer will drop misaligned portions of the request which can
646
+
* lead to data corruption. If LBPRZ is not set, we honor the
647
+
* device preference.
648
+
*/
649
+
if (sdkp->lbprz) {
650
+
q->limits.discard_alignment = 0;
651
+
q->limits.discard_granularity = 1;
652
+
} else {
653
+
q->limits.discard_alignment = sdkp->unmap_alignment *
654
+
logical_block_size;
655
+
q->limits.discard_granularity =
656
+
max(sdkp->physical_block_size,
657
+
sdkp->unmap_granularity * logical_block_size);
658
+
}
646
659
647
660
sdkp->provisioning_mode = mode;
648
661
···
2334
2321
}
2335
2322
}
2336
2323
2337
-
if (sdkp->capacity > 0xffffffff) {
2324
+
if (sdkp->capacity > 0xffffffff)
2338
2325
sdp->use_16_for_rw = 1;
2339
-
sdkp->max_xfer_blocks = SD_MAX_XFER_BLOCKS;
2340
-
} else
2341
-
sdkp->max_xfer_blocks = SD_DEF_XFER_BLOCKS;
2342
2326
2343
2327
/* Rescale capacity to 512-byte units */
2344
2328
if (sector_size == 4096)
···
2652
2642
{
2653
2643
unsigned int sector_sz = sdkp->device->sector_size;
2654
2644
const int vpd_len = 64;
2655
-
u32 max_xfer_length;
2656
2645
unsigned char *buffer = kmalloc(vpd_len, GFP_KERNEL);
2657
2646
2658
2647
if (!buffer ||
···
2659
2650
scsi_get_vpd_page(sdkp->device, 0xb0, buffer, vpd_len))
2660
2651
goto out;
2661
2652
2662
-
max_xfer_length = get_unaligned_be32(&buffer[8]);
2663
-
if (max_xfer_length)
2664
-
sdkp->max_xfer_blocks = max_xfer_length;
2665
-
2666
2653
blk_queue_io_min(sdkp->disk->queue,
2667
2654
get_unaligned_be16(&buffer[6]) * sector_sz);
2668
-
blk_queue_io_opt(sdkp->disk->queue,
2669
-
get_unaligned_be32(&buffer[12]) * sector_sz);
2655
+
2656
+
sdkp->max_xfer_blocks = get_unaligned_be32(&buffer[8]);
2657
+
sdkp->opt_xfer_blocks = get_unaligned_be32(&buffer[12]);
2670
2658
2671
2659
if (buffer[3] == 0x3c) {
2672
2660
unsigned int lba_count, desc_count;
···
2812
2806
return 0;
2813
2807
}
2814
2808
2809
+
static inline u32 logical_to_sectors(struct scsi_device *sdev, u32 blocks)
2810
+
{
2811
+
return blocks << (ilog2(sdev->sector_size) - 9);
2812
+
}
2813
+
2815
2814
/**
2816
2815
* sd_revalidate_disk - called the first time a new disk is seen,
2817
2816
* performs disk spin up, read_capacity, etc.
···
2826
2815
{
2827
2816
struct scsi_disk *sdkp = scsi_disk(disk);
2828
2817
struct scsi_device *sdp = sdkp->device;
2818
+
struct request_queue *q = sdkp->disk->queue;
2829
2819
unsigned char *buffer;
2830
-
unsigned int max_xfer;
2820
+
unsigned int dev_max, rw_max;
2831
2821
2832
2822
SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
2833
2823
"sd_revalidate_disk\n"));
···
2876
2864
*/
2877
2865
sd_set_flush_flag(sdkp);
2878
2866
2879
-
max_xfer = sdkp->max_xfer_blocks;
2880
-
max_xfer <<= ilog2(sdp->sector_size) - 9;
2867
+
/* Initial block count limit based on CDB TRANSFER LENGTH field size. */
2868
+
dev_max = sdp->use_16_for_rw ? SD_MAX_XFER_BLOCKS : SD_DEF_XFER_BLOCKS;
2881
2869
2882
-
sdkp->disk->queue->limits.max_sectors =
2883
-
min_not_zero(queue_max_hw_sectors(sdkp->disk->queue), max_xfer);
2870
+
/* Some devices report a maximum block count for READ/WRITE requests. */
2871
+
dev_max = min_not_zero(dev_max, sdkp->max_xfer_blocks);
2872
+
q->limits.max_dev_sectors = logical_to_sectors(sdp, dev_max);
2873
+
2874
+
/*
2875
+
* Use the device's preferred I/O size for reads and writes
2876
+
* unless the reported value is unreasonably large (or garbage).
2877
+
*/
2878
+
if (sdkp->opt_xfer_blocks && sdkp->opt_xfer_blocks <= dev_max &&
2879
+
sdkp->opt_xfer_blocks <= SD_DEF_XFER_BLOCKS)
2880
+
rw_max = q->limits.io_opt =
2881
+
logical_to_sectors(sdp, sdkp->opt_xfer_blocks);
2882
+
else
2883
+
rw_max = BLK_DEF_MAX_SECTORS;
2884
+
2885
+
/* Combine with controller limits */
2886
+
q->limits.max_sectors = min(rw_max, queue_max_hw_sectors(q));
2884
2887
2885
2888
set_capacity(disk, sdkp->capacity);
2886
2889
sd_config_write_same(sdkp);
+1
drivers/scsi/sd.h
+1
drivers/scsi/sd.h
+3
-2
drivers/scsi/st.c
+3
-2
drivers/scsi/st.c
···
4083
4083
}
4084
4084
cdev->owner = THIS_MODULE;
4085
4085
cdev->ops = &st_fops;
4086
+
STm->cdevs[rew] = cdev;
4086
4087
4087
4088
error = cdev_add(cdev, cdev_devno, 1);
4088
4089
if (error) {
···
4092
4091
pr_err("st%d: Device not attached.\n", dev_num);
4093
4092
goto out_free;
4094
4093
}
4095
-
STm->cdevs[rew] = cdev;
4096
4094
4097
4095
i = mode << (4 - ST_NBR_MODE_BITS);
4098
4096
snprintf(name, 10, "%s%s%s", rew ? "n" : "",
···
4110
4110
return 0;
4111
4111
out_free:
4112
4112
cdev_del(STm->cdevs[rew]);
4113
-
STm->cdevs[rew] = NULL;
4114
4113
out:
4114
+
STm->cdevs[rew] = NULL;
4115
+
STm->devs[rew] = NULL;
4115
4116
return error;
4116
4117
}
4117
4118
+1
-1
include/linux/blkdev.h
+1
-1
include/linux/blkdev.h
···
254
254
unsigned long virt_boundary_mask;
255
255
256
256
unsigned int max_hw_sectors;
257
+
unsigned int max_dev_sectors;
257
258
unsigned int chunk_sectors;
258
259
unsigned int max_sectors;
259
260
unsigned int max_segment_size;
···
960
959
extern void blk_cleanup_queue(struct request_queue *);
961
960
extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
962
961
extern void blk_queue_bounce_limit(struct request_queue *, u64);
963
-
extern void blk_limits_max_hw_sectors(struct queue_limits *, unsigned int);
964
962
extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
965
963
extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);
966
964
extern void blk_queue_max_segments(struct request_queue *, unsigned short);