Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'for-linus' of git://git.kernel.dk/linux-block
Pull block fixes from Jens Axboe:
- the virtio_blk stack DMA corruption fix from Christoph, fixing and
issue with VMAP stacks.
- O_DIRECT blkbits calculation fix from Chandan.
- discard regression fix from Christoph.
- queue init error handling fixes for nbd and virtio_blk, from Omar and
Jeff.
- two small nvme fixes, from Christoph and Guilherme.
- rename of blk_queue_zone_size and bdev_zone_size to _sectors instead,
to more closely follow what we do in other places in the block layer.
This interface is new for this series, so let's get the naming right
before releasing a kernel with this feature. From Damien.
* 'for-linus' of git://git.kernel.dk/linux-block:
block: don't try to discard from __blkdev_issue_zeroout
sd: remove __data_len hack for WRITE SAME
nvme: use blk_rq_payload_bytes
scsi: use blk_rq_payload_bytes
block: add blk_rq_payload_bytes
block: Rename blk_queue_zone_size and bdev_zone_size
nvme: apply DELAY_BEFORE_CHK_RDY quirk at probe time too
nvme-rdma: fix nvme_rdma_queue_is_ready
virtio_blk: fix panic in initialization error path
nbd: blk_mq_init_queue returns an error code on failure, not NULL
virtio_blk: avoid DMA to stack for the sense buffer
do_direct_IO: Use inode->i_blkbits to compute block count to be cleaned
+66
-83
+6
-7
block/blk-lib.c
+6
-7
block/blk-lib.c
···
301
301
if ((sector | nr_sects) & bs_mask)
302
302
return -EINVAL;
303
303
304
-
if (discard) {
305
-
ret = __blkdev_issue_discard(bdev, sector, nr_sects, gfp_mask,
306
-
BLKDEV_DISCARD_ZERO, biop);
307
-
if (ret == 0 || (ret && ret != -EOPNOTSUPP))
308
-
goto out;
309
-
}
310
-
311
304
ret = __blkdev_issue_write_zeroes(bdev, sector, nr_sects, gfp_mask,
312
305
biop);
313
306
if (ret == 0 || (ret && ret != -EOPNOTSUPP))
···
362
369
int ret;
363
370
struct bio *bio = NULL;
364
371
struct blk_plug plug;
372
+
373
+
if (discard) {
374
+
if (!blkdev_issue_discard(bdev, sector, nr_sects, gfp_mask,
375
+
BLKDEV_DISCARD_ZERO))
376
+
return 0;
377
+
}
365
378
366
379
blk_start_plug(&plug);
367
380
ret = __blkdev_issue_zeroout(bdev, sector, nr_sects, gfp_mask,
+2
-2
block/blk-zoned.c
+2
-2
block/blk-zoned.c
···
16
16
static inline sector_t blk_zone_start(struct request_queue *q,
17
17
sector_t sector)
18
18
{
19
-
sector_t zone_mask = blk_queue_zone_size(q) - 1;
19
+
sector_t zone_mask = blk_queue_zone_sectors(q) - 1;
20
20
21
21
return sector & ~zone_mask;
22
22
}
···
222
222
return -EINVAL;
223
223
224
224
/* Check alignment (handle eventual smaller last zone) */
225
-
zone_sectors = blk_queue_zone_size(q);
225
+
zone_sectors = blk_queue_zone_sectors(q);
226
226
if (sector & (zone_sectors - 1))
227
227
return -EINVAL;
228
228
+7
-7
block/partition-generic.c
+7
-7
block/partition-generic.c
···
434
434
struct block_device *bdev,
435
435
sector_t from, sector_t size)
436
436
{
437
-
unsigned int zone_size = bdev_zone_size(bdev);
437
+
unsigned int zone_sectors = bdev_zone_sectors(bdev);
438
438
439
439
/*
440
440
* If this function is called, then the disk is a zoned block device
···
446
446
* regular block devices (no zone operation) and their zone size will
447
447
* be reported as 0. Allow this case.
448
448
*/
449
-
if (!zone_size)
449
+
if (!zone_sectors)
450
450
return true;
451
451
452
452
/*
···
455
455
* use it. Check the zone size too: it should be a power of 2 number
456
456
* of sectors.
457
457
*/
458
-
if (WARN_ON_ONCE(!is_power_of_2(zone_size))) {
458
+
if (WARN_ON_ONCE(!is_power_of_2(zone_sectors))) {
459
459
u32 rem;
460
460
461
-
div_u64_rem(from, zone_size, &rem);
461
+
div_u64_rem(from, zone_sectors, &rem);
462
462
if (rem)
463
463
return false;
464
464
if ((from + size) < get_capacity(disk)) {
465
-
div_u64_rem(size, zone_size, &rem);
465
+
div_u64_rem(size, zone_sectors, &rem);
466
466
if (rem)
467
467
return false;
468
468
}
469
469
470
470
} else {
471
471
472
-
if (from & (zone_size - 1))
472
+
if (from & (zone_sectors - 1))
473
473
return false;
474
474
if ((from + size) < get_capacity(disk) &&
475
-
(size & (zone_size - 1)))
475
+
(size & (zone_sectors - 1)))
476
476
return false;
477
477
478
478
}
+4
-2
drivers/block/nbd.c
+4
-2
drivers/block/nbd.c
···
1042
1042
return -ENOMEM;
1043
1043
1044
1044
for (i = 0; i < nbds_max; i++) {
1045
+
struct request_queue *q;
1045
1046
struct gendisk *disk = alloc_disk(1 << part_shift);
1046
1047
if (!disk)
1047
1048
goto out;
···
1068
1067
* every gendisk to have its very own request_queue struct.
1069
1068
* These structs are big so we dynamically allocate them.
1070
1069
*/
1071
-
disk->queue = blk_mq_init_queue(&nbd_dev[i].tag_set);
1072
-
if (!disk->queue) {
1070
+
q = blk_mq_init_queue(&nbd_dev[i].tag_set);
1071
+
if (IS_ERR(q)) {
1073
1072
blk_mq_free_tag_set(&nbd_dev[i].tag_set);
1074
1073
put_disk(disk);
1075
1074
goto out;
1076
1075
}
1076
+
disk->queue = q;
1077
1077
1078
1078
/*
1079
1079
* Tell the block layer that we are not a rotational device
+5
-2
drivers/block/virtio_blk.c
+5
-2
drivers/block/virtio_blk.c
···
56
56
struct virtio_blk_outhdr out_hdr;
57
57
struct virtio_scsi_inhdr in_hdr;
58
58
u8 status;
59
+
u8 sense[SCSI_SENSE_BUFFERSIZE];
59
60
struct scatterlist sg[];
60
61
};
61
62
···
103
102
}
104
103
105
104
if (type == cpu_to_virtio32(vq->vdev, VIRTIO_BLK_T_SCSI_CMD)) {
106
-
sg_init_one(&sense, vbr->req->sense, SCSI_SENSE_BUFFERSIZE);
105
+
memcpy(vbr->sense, vbr->req->sense, SCSI_SENSE_BUFFERSIZE);
106
+
sg_init_one(&sense, vbr->sense, SCSI_SENSE_BUFFERSIZE);
107
107
sgs[num_out + num_in++] = &sense;
108
108
sg_init_one(&inhdr, &vbr->in_hdr, sizeof(vbr->in_hdr));
109
109
sgs[num_out + num_in++] = &inhdr;
···
630
628
if (err)
631
629
goto out_put_disk;
632
630
633
-
q = vblk->disk->queue = blk_mq_init_queue(&vblk->tag_set);
631
+
q = blk_mq_init_queue(&vblk->tag_set);
634
632
if (IS_ERR(q)) {
635
633
err = -ENOMEM;
636
634
goto out_free_tags;
637
635
}
636
+
vblk->disk->queue = q;
638
637
639
638
q->queuedata = vblk;
640
639
+1
-6
drivers/nvme/host/core.c
+1
-6
drivers/nvme/host/core.c
···
1106
1106
if (ret)
1107
1107
return ret;
1108
1108
1109
-
/* Checking for ctrl->tagset is a trick to avoid sleeping on module
1110
-
* load, since we only need the quirk on reset_controller. Notice
1111
-
* that the HGST device needs this delay only in firmware activation
1112
-
* procedure; unfortunately we have no (easy) way to verify this.
1113
-
*/
1114
-
if ((ctrl->quirks & NVME_QUIRK_DELAY_BEFORE_CHK_RDY) && ctrl->tagset)
1109
+
if (ctrl->quirks & NVME_QUIRK_DELAY_BEFORE_CHK_RDY)
1115
1110
msleep(NVME_QUIRK_DELAY_AMOUNT);
1116
1111
1117
1112
return nvme_wait_ready(ctrl, cap, false);
+2
-3
drivers/nvme/host/fc.c
+2
-3
drivers/nvme/host/fc.c
···
1654
1654
struct nvme_fc_fcp_op *op)
1655
1655
{
1656
1656
struct nvmefc_fcp_req *freq = &op->fcp_req;
1657
-
u32 map_len = nvme_map_len(rq);
1658
1657
enum dma_data_direction dir;
1659
1658
int ret;
1660
1659
1661
1660
freq->sg_cnt = 0;
1662
1661
1663
-
if (!map_len)
1662
+
if (!blk_rq_payload_bytes(rq))
1664
1663
return 0;
1665
1664
1666
1665
freq->sg_table.sgl = freq->first_sgl;
···
1853
1854
if (ret)
1854
1855
return ret;
1855
1856
1856
-
data_len = nvme_map_len(rq);
1857
+
data_len = blk_rq_payload_bytes(rq);
1857
1858
if (data_len)
1858
1859
io_dir = ((rq_data_dir(rq) == WRITE) ?
1859
1860
NVMEFC_FCP_WRITE : NVMEFC_FCP_READ);
-8
drivers/nvme/host/nvme.h
-8
drivers/nvme/host/nvme.h
···
225
225
return (sector >> (ns->lba_shift - 9));
226
226
}
227
227
228
-
static inline unsigned nvme_map_len(struct request *rq)
229
-
{
230
-
if (req_op(rq) == REQ_OP_DISCARD)
231
-
return sizeof(struct nvme_dsm_range);
232
-
else
233
-
return blk_rq_bytes(rq);
234
-
}
235
-
236
228
static inline void nvme_cleanup_cmd(struct request *req)
237
229
{
238
230
if (req->rq_flags & RQF_SPECIAL_PAYLOAD) {
+8
-11
drivers/nvme/host/pci.c
+8
-11
drivers/nvme/host/pci.c
···
306
306
return (__le64 **)(iod->sg + blk_rq_nr_phys_segments(req));
307
307
}
308
308
309
-
static int nvme_init_iod(struct request *rq, unsigned size,
310
-
struct nvme_dev *dev)
309
+
static int nvme_init_iod(struct request *rq, struct nvme_dev *dev)
311
310
{
312
311
struct nvme_iod *iod = blk_mq_rq_to_pdu(rq);
313
312
int nseg = blk_rq_nr_phys_segments(rq);
313
+
unsigned int size = blk_rq_payload_bytes(rq);
314
314
315
315
if (nseg > NVME_INT_PAGES || size > NVME_INT_BYTES(dev)) {
316
316
iod->sg = kmalloc(nvme_iod_alloc_size(dev, size, nseg), GFP_ATOMIC);
···
420
420
}
421
421
#endif
422
422
423
-
static bool nvme_setup_prps(struct nvme_dev *dev, struct request *req,
424
-
int total_len)
423
+
static bool nvme_setup_prps(struct nvme_dev *dev, struct request *req)
425
424
{
426
425
struct nvme_iod *iod = blk_mq_rq_to_pdu(req);
427
426
struct dma_pool *pool;
428
-
int length = total_len;
427
+
int length = blk_rq_payload_bytes(req);
429
428
struct scatterlist *sg = iod->sg;
430
429
int dma_len = sg_dma_len(sg);
431
430
u64 dma_addr = sg_dma_address(sg);
···
500
501
}
501
502
502
503
static int nvme_map_data(struct nvme_dev *dev, struct request *req,
503
-
unsigned size, struct nvme_command *cmnd)
504
+
struct nvme_command *cmnd)
504
505
{
505
506
struct nvme_iod *iod = blk_mq_rq_to_pdu(req);
506
507
struct request_queue *q = req->q;
···
518
519
DMA_ATTR_NO_WARN))
519
520
goto out;
520
521
521
-
if (!nvme_setup_prps(dev, req, size))
522
+
if (!nvme_setup_prps(dev, req))
522
523
goto out_unmap;
523
524
524
525
ret = BLK_MQ_RQ_QUEUE_ERROR;
···
579
580
struct nvme_dev *dev = nvmeq->dev;
580
581
struct request *req = bd->rq;
581
582
struct nvme_command cmnd;
582
-
unsigned map_len;
583
583
int ret = BLK_MQ_RQ_QUEUE_OK;
584
584
585
585
/*
···
598
600
if (ret != BLK_MQ_RQ_QUEUE_OK)
599
601
return ret;
600
602
601
-
map_len = nvme_map_len(req);
602
-
ret = nvme_init_iod(req, map_len, dev);
603
+
ret = nvme_init_iod(req, dev);
603
604
if (ret != BLK_MQ_RQ_QUEUE_OK)
604
605
goto out_free_cmd;
605
606
606
607
if (blk_rq_nr_phys_segments(req))
607
-
ret = nvme_map_data(dev, req, map_len, &cmnd);
608
+
ret = nvme_map_data(dev, req, &cmnd);
608
609
609
610
if (ret != BLK_MQ_RQ_QUEUE_OK)
610
611
goto out_cleanup_iod;
+6
-9
drivers/nvme/host/rdma.c
+6
-9
drivers/nvme/host/rdma.c
···
981
981
}
982
982
983
983
static int nvme_rdma_map_data(struct nvme_rdma_queue *queue,
984
-
struct request *rq, unsigned int map_len,
985
-
struct nvme_command *c)
984
+
struct request *rq, struct nvme_command *c)
986
985
{
987
986
struct nvme_rdma_request *req = blk_mq_rq_to_pdu(rq);
988
987
struct nvme_rdma_device *dev = queue->device;
···
1013
1014
}
1014
1015
1015
1016
if (count == 1) {
1016
-
if (rq_data_dir(rq) == WRITE &&
1017
-
map_len <= nvme_rdma_inline_data_size(queue) &&
1018
-
nvme_rdma_queue_idx(queue))
1017
+
if (rq_data_dir(rq) == WRITE && nvme_rdma_queue_idx(queue) &&
1018
+
blk_rq_payload_bytes(rq) <=
1019
+
nvme_rdma_inline_data_size(queue))
1019
1020
return nvme_rdma_map_sg_inline(queue, req, c);
1020
1021
1021
1022
if (dev->pd->flags & IB_PD_UNSAFE_GLOBAL_RKEY)
···
1421
1422
struct request *rq)
1422
1423
{
1423
1424
if (unlikely(!test_bit(NVME_RDMA_Q_LIVE, &queue->flags))) {
1424
-
struct nvme_command *cmd = (struct nvme_command *)rq->cmd;
1425
+
struct nvme_command *cmd = nvme_req(rq)->cmd;
1425
1426
1426
1427
if (rq->cmd_type != REQ_TYPE_DRV_PRIV ||
1427
1428
cmd->common.opcode != nvme_fabrics_command ||
···
1443
1444
struct nvme_command *c = sqe->data;
1444
1445
bool flush = false;
1445
1446
struct ib_device *dev;
1446
-
unsigned int map_len;
1447
1447
int ret;
1448
1448
1449
1449
WARN_ON_ONCE(rq->tag < 0);
···
1460
1462
1461
1463
blk_mq_start_request(rq);
1462
1464
1463
-
map_len = nvme_map_len(rq);
1464
-
ret = nvme_rdma_map_data(queue, rq, map_len, c);
1465
+
ret = nvme_rdma_map_data(queue, rq, c);
1465
1466
if (ret < 0) {
1466
1467
dev_err(queue->ctrl->ctrl.device,
1467
1468
"Failed to map data (%d)\n", ret);
+1
-1
drivers/scsi/scsi_lib.c
+1
-1
drivers/scsi/scsi_lib.c
+1
-16
drivers/scsi/sd.c
+1
-16
drivers/scsi/sd.c
···
836
836
struct bio *bio = rq->bio;
837
837
sector_t sector = blk_rq_pos(rq);
838
838
unsigned int nr_sectors = blk_rq_sectors(rq);
839
-
unsigned int nr_bytes = blk_rq_bytes(rq);
840
839
int ret;
841
840
842
841
if (sdkp->device->no_write_same)
···
868
869
869
870
cmd->transfersize = sdp->sector_size;
870
871
cmd->allowed = SD_MAX_RETRIES;
871
-
872
-
/*
873
-
* For WRITE_SAME the data transferred in the DATA IN buffer is
874
-
* different from the amount of data actually written to the target.
875
-
*
876
-
* We set up __data_len to the amount of data transferred from the
877
-
* DATA IN buffer so that blk_rq_map_sg set up the proper S/G list
878
-
* to transfer a single sector of data first, but then reset it to
879
-
* the amount of data to be written right after so that the I/O path
880
-
* knows how much to actually write.
881
-
*/
882
-
rq->__data_len = sdp->sector_size;
883
-
ret = scsi_init_io(cmd);
884
-
rq->__data_len = nr_bytes;
885
-
return ret;
872
+
return scsi_init_io(cmd);
886
873
}
887
874
888
875
static int sd_setup_flush_cmnd(struct scsi_cmnd *cmd)
+2
-1
fs/direct-io.c
+2
-1
fs/direct-io.c
···
906
906
struct buffer_head *map_bh)
907
907
{
908
908
const unsigned blkbits = sdio->blkbits;
909
+
const unsigned i_blkbits = blkbits + sdio->blkfactor;
909
910
int ret = 0;
910
911
911
912
while (sdio->block_in_file < sdio->final_block_in_request) {
···
950
949
clean_bdev_aliases(
951
950
map_bh->b_bdev,
952
951
map_bh->b_blocknr,
953
-
map_bh->b_size >> blkbits);
952
+
map_bh->b_size >> i_blkbits);
954
953
}
955
954
956
955
if (!sdio->blkfactor)
+2
-2
fs/f2fs/segment.c
+2
-2
fs/f2fs/segment.c
···
713
713
}
714
714
sector = SECTOR_FROM_BLOCK(blkstart);
715
715
716
-
if (sector & (bdev_zone_size(bdev) - 1) ||
717
-
nr_sects != bdev_zone_size(bdev)) {
716
+
if (sector & (bdev_zone_sectors(bdev) - 1) ||
717
+
nr_sects != bdev_zone_sectors(bdev)) {
718
718
f2fs_msg(sbi->sb, KERN_INFO,
719
719
"(%d) %s: Unaligned discard attempted (block %x + %x)",
720
720
devi, sbi->s_ndevs ? FDEV(devi).path: "",
+3
-3
fs/f2fs/super.c
+3
-3
fs/f2fs/super.c
···
1553
1553
return 0;
1554
1554
1555
1555
if (sbi->blocks_per_blkz && sbi->blocks_per_blkz !=
1556
-
SECTOR_TO_BLOCK(bdev_zone_size(bdev)))
1556
+
SECTOR_TO_BLOCK(bdev_zone_sectors(bdev)))
1557
1557
return -EINVAL;
1558
-
sbi->blocks_per_blkz = SECTOR_TO_BLOCK(bdev_zone_size(bdev));
1558
+
sbi->blocks_per_blkz = SECTOR_TO_BLOCK(bdev_zone_sectors(bdev));
1559
1559
if (sbi->log_blocks_per_blkz && sbi->log_blocks_per_blkz !=
1560
1560
__ilog2_u32(sbi->blocks_per_blkz))
1561
1561
return -EINVAL;
1562
1562
sbi->log_blocks_per_blkz = __ilog2_u32(sbi->blocks_per_blkz);
1563
1563
FDEV(devi).nr_blkz = SECTOR_TO_BLOCK(nr_sectors) >>
1564
1564
sbi->log_blocks_per_blkz;
1565
-
if (nr_sectors & (bdev_zone_size(bdev) - 1))
1565
+
if (nr_sectors & (bdev_zone_sectors(bdev) - 1))
1566
1566
FDEV(devi).nr_blkz++;
1567
1567
1568
1568
FDEV(devi).blkz_type = kmalloc(FDEV(devi).nr_blkz, GFP_KERNEL);
+16
-3
include/linux/blkdev.h
+16
-3
include/linux/blkdev.h
···
739
739
}
740
740
}
741
741
742
-
static inline unsigned int blk_queue_zone_size(struct request_queue *q)
742
+
static inline unsigned int blk_queue_zone_sectors(struct request_queue *q)
743
743
{
744
744
return blk_queue_is_zoned(q) ? q->limits.chunk_sectors : 0;
745
745
}
···
998
998
static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
999
999
{
1000
1000
return blk_rq_cur_bytes(rq) >> 9;
1001
+
}
1002
+
1003
+
/*
1004
+
* Some commands like WRITE SAME have a payload or data transfer size which
1005
+
* is different from the size of the request. Any driver that supports such
1006
+
* commands using the RQF_SPECIAL_PAYLOAD flag needs to use this helper to
1007
+
* calculate the data transfer size.
1008
+
*/
1009
+
static inline unsigned int blk_rq_payload_bytes(struct request *rq)
1010
+
{
1011
+
if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
1012
+
return rq->special_vec.bv_len;
1013
+
return blk_rq_bytes(rq);
1001
1014
}
1002
1015
1003
1016
static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
···
1549
1536
return false;
1550
1537
}
1551
1538
1552
-
static inline unsigned int bdev_zone_size(struct block_device *bdev)
1539
+
static inline unsigned int bdev_zone_sectors(struct block_device *bdev)
1553
1540
{
1554
1541
struct request_queue *q = bdev_get_queue(bdev);
1555
1542
1556
1543
if (q)
1557
-
return blk_queue_zone_size(q);
1544
+
return blk_queue_zone_sectors(q);
1558
1545
1559
1546
return 0;
1560
1547
}