1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Virtio SCSI HBA driver
5 * Copyright IBM Corp. 2010
6 * Copyright Red Hat, Inc. 2011
9 * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
10 * Paolo Bonzini <pbonzini@redhat.com>
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/mempool.h>
18 #include <linux/interrupt.h>
19 #include <linux/virtio.h>
20 #include <linux/virtio_ids.h>
21 #include <linux/virtio_config.h>
22 #include <linux/virtio_scsi.h>
23 #include <linux/cpu.h>
24 #include <linux/blkdev.h>
25 #include <scsi/scsi_host.h>
26 #include <scsi/scsi_device.h>
27 #include <scsi/scsi_cmnd.h>
28 #include <scsi/scsi_tcq.h>
29 #include <scsi/scsi_devinfo.h>
30 #include <linux/seqlock.h>
31 #include <linux/blk-mq-virtio.h>
35 #define VIRTIO_SCSI_MEMPOOL_SZ 64
36 #define VIRTIO_SCSI_EVENT_LEN 8
37 #define VIRTIO_SCSI_VQ_BASE 2
39 /* Command queue element */
40 struct virtio_scsi_cmd
{
42 struct completion
*comp
;
44 struct virtio_scsi_cmd_req cmd
;
45 struct virtio_scsi_cmd_req_pi cmd_pi
;
46 struct virtio_scsi_ctrl_tmf_req tmf
;
47 struct virtio_scsi_ctrl_an_req an
;
50 struct virtio_scsi_cmd_resp cmd
;
51 struct virtio_scsi_ctrl_tmf_resp tmf
;
52 struct virtio_scsi_ctrl_an_resp an
;
53 struct virtio_scsi_event evt
;
55 } ____cacheline_aligned_in_smp
;
57 struct virtio_scsi_event_node
{
58 struct virtio_scsi
*vscsi
;
59 struct virtio_scsi_event event
;
60 struct work_struct work
;
63 struct virtio_scsi_vq
{
70 /* Driver instance state */
72 struct virtio_device
*vdev
;
74 /* Get some buffers ready for event vq */
75 struct virtio_scsi_event_node event_list
[VIRTIO_SCSI_EVENT_LEN
];
79 struct hlist_node node
;
81 /* Protected by event_vq lock */
84 struct virtio_scsi_vq ctrl_vq
;
85 struct virtio_scsi_vq event_vq
;
86 struct virtio_scsi_vq req_vqs
[];
89 static struct kmem_cache
*virtscsi_cmd_cache
;
90 static mempool_t
*virtscsi_cmd_pool
;
92 static inline struct Scsi_Host
*virtio_scsi_host(struct virtio_device
*vdev
)
97 static void virtscsi_compute_resid(struct scsi_cmnd
*sc
, u32 resid
)
100 scsi_set_resid(sc
, min(resid
, scsi_bufflen(sc
)));
104 * virtscsi_complete_cmd - finish a scsi_cmd and invoke scsi_done
106 * Called with vq_lock held.
108 static void virtscsi_complete_cmd(struct virtio_scsi
*vscsi
, void *buf
)
110 struct virtio_scsi_cmd
*cmd
= buf
;
111 struct scsi_cmnd
*sc
= cmd
->sc
;
112 struct virtio_scsi_cmd_resp
*resp
= &cmd
->resp
.cmd
;
114 dev_dbg(&sc
->device
->sdev_gendev
,
115 "cmd %p response %u status %#02x sense_len %u\n",
116 sc
, resp
->response
, resp
->status
, resp
->sense_len
);
118 sc
->result
= resp
->status
;
119 virtscsi_compute_resid(sc
, virtio32_to_cpu(vscsi
->vdev
, resp
->resid
));
120 switch (resp
->response
) {
121 case VIRTIO_SCSI_S_OK
:
122 set_host_byte(sc
, DID_OK
);
124 case VIRTIO_SCSI_S_OVERRUN
:
125 set_host_byte(sc
, DID_ERROR
);
127 case VIRTIO_SCSI_S_ABORTED
:
128 set_host_byte(sc
, DID_ABORT
);
130 case VIRTIO_SCSI_S_BAD_TARGET
:
131 set_host_byte(sc
, DID_BAD_TARGET
);
133 case VIRTIO_SCSI_S_RESET
:
134 set_host_byte(sc
, DID_RESET
);
136 case VIRTIO_SCSI_S_BUSY
:
137 set_host_byte(sc
, DID_BUS_BUSY
);
139 case VIRTIO_SCSI_S_TRANSPORT_FAILURE
:
140 set_host_byte(sc
, DID_TRANSPORT_DISRUPTED
);
142 case VIRTIO_SCSI_S_TARGET_FAILURE
:
143 set_host_byte(sc
, DID_TARGET_FAILURE
);
145 case VIRTIO_SCSI_S_NEXUS_FAILURE
:
146 set_host_byte(sc
, DID_NEXUS_FAILURE
);
149 scmd_printk(KERN_WARNING
, sc
, "Unknown response %d",
152 case VIRTIO_SCSI_S_FAILURE
:
153 set_host_byte(sc
, DID_ERROR
);
157 WARN_ON(virtio32_to_cpu(vscsi
->vdev
, resp
->sense_len
) >
158 VIRTIO_SCSI_SENSE_SIZE
);
159 if (resp
->sense_len
) {
160 memcpy(sc
->sense_buffer
, resp
->sense
,
162 virtio32_to_cpu(vscsi
->vdev
, resp
->sense_len
),
163 VIRTIO_SCSI_SENSE_SIZE
));
169 static void virtscsi_vq_done(struct virtio_scsi
*vscsi
,
170 struct virtio_scsi_vq
*virtscsi_vq
,
171 void (*fn
)(struct virtio_scsi
*vscsi
, void *buf
))
176 struct virtqueue
*vq
= virtscsi_vq
->vq
;
178 spin_lock_irqsave(&virtscsi_vq
->vq_lock
, flags
);
180 virtqueue_disable_cb(vq
);
181 while ((buf
= virtqueue_get_buf(vq
, &len
)) != NULL
)
184 if (unlikely(virtqueue_is_broken(vq
)))
186 } while (!virtqueue_enable_cb(vq
));
187 spin_unlock_irqrestore(&virtscsi_vq
->vq_lock
, flags
);
190 static void virtscsi_req_done(struct virtqueue
*vq
)
192 struct Scsi_Host
*sh
= virtio_scsi_host(vq
->vdev
);
193 struct virtio_scsi
*vscsi
= shost_priv(sh
);
194 int index
= vq
->index
- VIRTIO_SCSI_VQ_BASE
;
195 struct virtio_scsi_vq
*req_vq
= &vscsi
->req_vqs
[index
];
197 virtscsi_vq_done(vscsi
, req_vq
, virtscsi_complete_cmd
);
200 static void virtscsi_poll_requests(struct virtio_scsi
*vscsi
)
204 num_vqs
= vscsi
->num_queues
;
205 for (i
= 0; i
< num_vqs
; i
++)
206 virtscsi_vq_done(vscsi
, &vscsi
->req_vqs
[i
],
207 virtscsi_complete_cmd
);
210 static void virtscsi_complete_free(struct virtio_scsi
*vscsi
, void *buf
)
212 struct virtio_scsi_cmd
*cmd
= buf
;
218 static void virtscsi_ctrl_done(struct virtqueue
*vq
)
220 struct Scsi_Host
*sh
= virtio_scsi_host(vq
->vdev
);
221 struct virtio_scsi
*vscsi
= shost_priv(sh
);
223 virtscsi_vq_done(vscsi
, &vscsi
->ctrl_vq
, virtscsi_complete_free
);
226 static void virtscsi_handle_event(struct work_struct
*work
);
228 static int virtscsi_kick_event(struct virtio_scsi
*vscsi
,
229 struct virtio_scsi_event_node
*event_node
)
232 struct scatterlist sg
;
235 INIT_WORK(&event_node
->work
, virtscsi_handle_event
);
236 sg_init_one(&sg
, &event_node
->event
, sizeof(struct virtio_scsi_event
));
238 spin_lock_irqsave(&vscsi
->event_vq
.vq_lock
, flags
);
240 err
= virtqueue_add_inbuf(vscsi
->event_vq
.vq
, &sg
, 1, event_node
,
243 virtqueue_kick(vscsi
->event_vq
.vq
);
245 spin_unlock_irqrestore(&vscsi
->event_vq
.vq_lock
, flags
);
250 static int virtscsi_kick_event_all(struct virtio_scsi
*vscsi
)
254 for (i
= 0; i
< VIRTIO_SCSI_EVENT_LEN
; i
++) {
255 vscsi
->event_list
[i
].vscsi
= vscsi
;
256 virtscsi_kick_event(vscsi
, &vscsi
->event_list
[i
]);
262 static void virtscsi_cancel_event_work(struct virtio_scsi
*vscsi
)
266 /* Stop scheduling work before calling cancel_work_sync. */
267 spin_lock_irq(&vscsi
->event_vq
.vq_lock
);
268 vscsi
->stop_events
= true;
269 spin_unlock_irq(&vscsi
->event_vq
.vq_lock
);
271 for (i
= 0; i
< VIRTIO_SCSI_EVENT_LEN
; i
++)
272 cancel_work_sync(&vscsi
->event_list
[i
].work
);
275 static void virtscsi_handle_transport_reset(struct virtio_scsi
*vscsi
,
276 struct virtio_scsi_event
*event
)
278 struct scsi_device
*sdev
;
279 struct Scsi_Host
*shost
= virtio_scsi_host(vscsi
->vdev
);
280 unsigned int target
= event
->lun
[1];
281 unsigned int lun
= (event
->lun
[2] << 8) | event
->lun
[3];
283 switch (virtio32_to_cpu(vscsi
->vdev
, event
->reason
)) {
284 case VIRTIO_SCSI_EVT_RESET_RESCAN
:
286 scsi_scan_target(&shost
->shost_gendev
, 0, target
,
287 SCAN_WILD_CARD
, SCSI_SCAN_INITIAL
);
289 scsi_add_device(shost
, 0, target
, lun
);
292 case VIRTIO_SCSI_EVT_RESET_REMOVED
:
293 sdev
= scsi_device_lookup(shost
, 0, target
, lun
);
295 scsi_remove_device(sdev
);
296 scsi_device_put(sdev
);
298 pr_err("SCSI device %d 0 %d %d not found\n",
299 shost
->host_no
, target
, lun
);
303 pr_info("Unsupported virtio scsi event reason %x\n", event
->reason
);
307 static void virtscsi_handle_param_change(struct virtio_scsi
*vscsi
,
308 struct virtio_scsi_event
*event
)
310 struct scsi_device
*sdev
;
311 struct Scsi_Host
*shost
= virtio_scsi_host(vscsi
->vdev
);
312 unsigned int target
= event
->lun
[1];
313 unsigned int lun
= (event
->lun
[2] << 8) | event
->lun
[3];
314 u8 asc
= virtio32_to_cpu(vscsi
->vdev
, event
->reason
) & 255;
315 u8 ascq
= virtio32_to_cpu(vscsi
->vdev
, event
->reason
) >> 8;
317 sdev
= scsi_device_lookup(shost
, 0, target
, lun
);
319 pr_err("SCSI device %d 0 %d %d not found\n",
320 shost
->host_no
, target
, lun
);
324 /* Handle "Parameters changed", "Mode parameters changed", and
325 "Capacity data has changed". */
326 if (asc
== 0x2a && (ascq
== 0x00 || ascq
== 0x01 || ascq
== 0x09))
327 scsi_rescan_device(&sdev
->sdev_gendev
);
329 scsi_device_put(sdev
);
332 static void virtscsi_rescan_hotunplug(struct virtio_scsi
*vscsi
)
334 struct scsi_device
*sdev
;
335 struct Scsi_Host
*shost
= virtio_scsi_host(vscsi
->vdev
);
336 unsigned char scsi_cmd
[MAX_COMMAND_SIZE
];
337 int result
, inquiry_len
, inq_result_len
= 256;
338 char *inq_result
= kmalloc(inq_result_len
, GFP_KERNEL
);
340 shost_for_each_device(sdev
, shost
) {
341 inquiry_len
= sdev
->inquiry_len
? sdev
->inquiry_len
: 36;
343 memset(scsi_cmd
, 0, sizeof(scsi_cmd
));
344 scsi_cmd
[0] = INQUIRY
;
345 scsi_cmd
[4] = (unsigned char) inquiry_len
;
347 memset(inq_result
, 0, inq_result_len
);
349 result
= scsi_execute_req(sdev
, scsi_cmd
, DMA_FROM_DEVICE
,
350 inq_result
, inquiry_len
, NULL
,
351 SD_TIMEOUT
, SD_MAX_RETRIES
, NULL
);
353 if (result
== 0 && inq_result
[0] >> 5) {
354 /* PQ indicates the LUN is not attached */
355 scsi_remove_device(sdev
);
356 } else if (result
> 0 && host_byte(result
) == DID_BAD_TARGET
) {
358 * If all LUNs of a virtio-scsi device are unplugged
359 * it will respond with BAD TARGET on any INQUIRY
361 * Remove the device in this case as well.
363 scsi_remove_device(sdev
);
370 static void virtscsi_handle_event(struct work_struct
*work
)
372 struct virtio_scsi_event_node
*event_node
=
373 container_of(work
, struct virtio_scsi_event_node
, work
);
374 struct virtio_scsi
*vscsi
= event_node
->vscsi
;
375 struct virtio_scsi_event
*event
= &event_node
->event
;
378 cpu_to_virtio32(vscsi
->vdev
, VIRTIO_SCSI_T_EVENTS_MISSED
)) {
379 event
->event
&= ~cpu_to_virtio32(vscsi
->vdev
,
380 VIRTIO_SCSI_T_EVENTS_MISSED
);
381 virtscsi_rescan_hotunplug(vscsi
);
382 scsi_scan_host(virtio_scsi_host(vscsi
->vdev
));
385 switch (virtio32_to_cpu(vscsi
->vdev
, event
->event
)) {
386 case VIRTIO_SCSI_T_NO_EVENT
:
388 case VIRTIO_SCSI_T_TRANSPORT_RESET
:
389 virtscsi_handle_transport_reset(vscsi
, event
);
391 case VIRTIO_SCSI_T_PARAM_CHANGE
:
392 virtscsi_handle_param_change(vscsi
, event
);
395 pr_err("Unsupported virtio scsi event %x\n", event
->event
);
397 virtscsi_kick_event(vscsi
, event_node
);
400 static void virtscsi_complete_event(struct virtio_scsi
*vscsi
, void *buf
)
402 struct virtio_scsi_event_node
*event_node
= buf
;
404 if (!vscsi
->stop_events
)
405 queue_work(system_freezable_wq
, &event_node
->work
);
408 static void virtscsi_event_done(struct virtqueue
*vq
)
410 struct Scsi_Host
*sh
= virtio_scsi_host(vq
->vdev
);
411 struct virtio_scsi
*vscsi
= shost_priv(sh
);
413 virtscsi_vq_done(vscsi
, &vscsi
->event_vq
, virtscsi_complete_event
);
416 static int __virtscsi_add_cmd(struct virtqueue
*vq
,
417 struct virtio_scsi_cmd
*cmd
,
418 size_t req_size
, size_t resp_size
)
420 struct scsi_cmnd
*sc
= cmd
->sc
;
421 struct scatterlist
*sgs
[6], req
, resp
;
422 struct sg_table
*out
, *in
;
423 unsigned out_num
= 0, in_num
= 0;
427 if (sc
&& sc
->sc_data_direction
!= DMA_NONE
) {
428 if (sc
->sc_data_direction
!= DMA_FROM_DEVICE
)
429 out
= &sc
->sdb
.table
;
430 if (sc
->sc_data_direction
!= DMA_TO_DEVICE
)
434 /* Request header. */
435 sg_init_one(&req
, &cmd
->req
, req_size
);
436 sgs
[out_num
++] = &req
;
438 /* Data-out buffer. */
440 /* Place WRITE protection SGLs before Data OUT payload */
441 if (scsi_prot_sg_count(sc
))
442 sgs
[out_num
++] = scsi_prot_sglist(sc
);
443 sgs
[out_num
++] = out
->sgl
;
446 /* Response header. */
447 sg_init_one(&resp
, &cmd
->resp
, resp_size
);
448 sgs
[out_num
+ in_num
++] = &resp
;
452 /* Place READ protection SGLs before Data IN payload */
453 if (scsi_prot_sg_count(sc
))
454 sgs
[out_num
+ in_num
++] = scsi_prot_sglist(sc
);
455 sgs
[out_num
+ in_num
++] = in
->sgl
;
458 return virtqueue_add_sgs(vq
, sgs
, out_num
, in_num
, cmd
, GFP_ATOMIC
);
461 static void virtscsi_kick_vq(struct virtio_scsi_vq
*vq
)
466 spin_lock_irqsave(&vq
->vq_lock
, flags
);
467 needs_kick
= virtqueue_kick_prepare(vq
->vq
);
468 spin_unlock_irqrestore(&vq
->vq_lock
, flags
);
471 virtqueue_notify(vq
->vq
);
475 * virtscsi_add_cmd - add a virtio_scsi_cmd to a virtqueue, optionally kick it
476 * @vq : the struct virtqueue we're talking about
477 * @cmd : command structure
478 * @req_size : size of the request buffer
479 * @resp_size : size of the response buffer
480 * @kick : whether to kick the virtqueue immediately
482 static int virtscsi_add_cmd(struct virtio_scsi_vq
*vq
,
483 struct virtio_scsi_cmd
*cmd
,
484 size_t req_size
, size_t resp_size
,
489 bool needs_kick
= false;
491 spin_lock_irqsave(&vq
->vq_lock
, flags
);
492 err
= __virtscsi_add_cmd(vq
->vq
, cmd
, req_size
, resp_size
);
494 needs_kick
= virtqueue_kick_prepare(vq
->vq
);
496 spin_unlock_irqrestore(&vq
->vq_lock
, flags
);
499 virtqueue_notify(vq
->vq
);
503 static void virtio_scsi_init_hdr(struct virtio_device
*vdev
,
504 struct virtio_scsi_cmd_req
*cmd
,
505 struct scsi_cmnd
*sc
)
508 cmd
->lun
[1] = sc
->device
->id
;
509 cmd
->lun
[2] = (sc
->device
->lun
>> 8) | 0x40;
510 cmd
->lun
[3] = sc
->device
->lun
& 0xff;
511 cmd
->tag
= cpu_to_virtio64(vdev
, (unsigned long)sc
);
512 cmd
->task_attr
= VIRTIO_SCSI_S_SIMPLE
;
517 #ifdef CONFIG_BLK_DEV_INTEGRITY
518 static void virtio_scsi_init_hdr_pi(struct virtio_device
*vdev
,
519 struct virtio_scsi_cmd_req_pi
*cmd_pi
,
520 struct scsi_cmnd
*sc
)
522 struct request
*rq
= scsi_cmd_to_rq(sc
);
523 struct blk_integrity
*bi
;
525 virtio_scsi_init_hdr(vdev
, (struct virtio_scsi_cmd_req
*)cmd_pi
, sc
);
527 if (!rq
|| !scsi_prot_sg_count(sc
))
530 bi
= blk_get_integrity(rq
->rq_disk
);
532 if (sc
->sc_data_direction
== DMA_TO_DEVICE
)
533 cmd_pi
->pi_bytesout
= cpu_to_virtio32(vdev
,
534 bio_integrity_bytes(bi
,
535 blk_rq_sectors(rq
)));
536 else if (sc
->sc_data_direction
== DMA_FROM_DEVICE
)
537 cmd_pi
->pi_bytesin
= cpu_to_virtio32(vdev
,
538 bio_integrity_bytes(bi
,
539 blk_rq_sectors(rq
)));
543 static struct virtio_scsi_vq
*virtscsi_pick_vq_mq(struct virtio_scsi
*vscsi
,
544 struct scsi_cmnd
*sc
)
546 u32 tag
= blk_mq_unique_tag(scsi_cmd_to_rq(sc
));
547 u16 hwq
= blk_mq_unique_tag_to_hwq(tag
);
549 return &vscsi
->req_vqs
[hwq
];
552 static int virtscsi_queuecommand(struct Scsi_Host
*shost
,
553 struct scsi_cmnd
*sc
)
555 struct virtio_scsi
*vscsi
= shost_priv(shost
);
556 struct virtio_scsi_vq
*req_vq
= virtscsi_pick_vq_mq(vscsi
, sc
);
557 struct virtio_scsi_cmd
*cmd
= scsi_cmd_priv(sc
);
563 BUG_ON(scsi_sg_count(sc
) > shost
->sg_tablesize
);
565 /* TODO: check feature bit and fail if unsupported? */
566 BUG_ON(sc
->sc_data_direction
== DMA_BIDIRECTIONAL
);
568 dev_dbg(&sc
->device
->sdev_gendev
,
569 "cmd %p CDB: %#02x\n", sc
, sc
->cmnd
[0]);
573 BUG_ON(sc
->cmd_len
> VIRTIO_SCSI_CDB_SIZE
);
575 #ifdef CONFIG_BLK_DEV_INTEGRITY
576 if (virtio_has_feature(vscsi
->vdev
, VIRTIO_SCSI_F_T10_PI
)) {
577 virtio_scsi_init_hdr_pi(vscsi
->vdev
, &cmd
->req
.cmd_pi
, sc
);
578 memcpy(cmd
->req
.cmd_pi
.cdb
, sc
->cmnd
, sc
->cmd_len
);
579 req_size
= sizeof(cmd
->req
.cmd_pi
);
583 virtio_scsi_init_hdr(vscsi
->vdev
, &cmd
->req
.cmd
, sc
);
584 memcpy(cmd
->req
.cmd
.cdb
, sc
->cmnd
, sc
->cmd_len
);
585 req_size
= sizeof(cmd
->req
.cmd
);
588 kick
= (sc
->flags
& SCMD_LAST
) != 0;
589 ret
= virtscsi_add_cmd(req_vq
, cmd
, req_size
, sizeof(cmd
->resp
.cmd
), kick
);
591 cmd
->resp
.cmd
.response
= VIRTIO_SCSI_S_BAD_TARGET
;
592 spin_lock_irqsave(&req_vq
->vq_lock
, flags
);
593 virtscsi_complete_cmd(vscsi
, cmd
);
594 spin_unlock_irqrestore(&req_vq
->vq_lock
, flags
);
595 } else if (ret
!= 0) {
596 return SCSI_MLQUEUE_HOST_BUSY
;
601 static int virtscsi_tmf(struct virtio_scsi
*vscsi
, struct virtio_scsi_cmd
*cmd
)
603 DECLARE_COMPLETION_ONSTACK(comp
);
607 if (virtscsi_add_cmd(&vscsi
->ctrl_vq
, cmd
,
608 sizeof cmd
->req
.tmf
, sizeof cmd
->resp
.tmf
, true) < 0)
611 wait_for_completion(&comp
);
612 if (cmd
->resp
.tmf
.response
== VIRTIO_SCSI_S_OK
||
613 cmd
->resp
.tmf
.response
== VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
)
617 * The spec guarantees that all requests related to the TMF have
618 * been completed, but the callback might not have run yet if
619 * we're using independent interrupts (e.g. MSI). Poll the
622 * In the abort case, sc->scsi_done will do nothing, because
623 * the block layer must have detected a timeout and as a result
624 * REQ_ATOM_COMPLETE has been set.
626 virtscsi_poll_requests(vscsi
);
629 mempool_free(cmd
, virtscsi_cmd_pool
);
633 static int virtscsi_device_reset(struct scsi_cmnd
*sc
)
635 struct virtio_scsi
*vscsi
= shost_priv(sc
->device
->host
);
636 struct virtio_scsi_cmd
*cmd
;
638 sdev_printk(KERN_INFO
, sc
->device
, "device reset\n");
639 cmd
= mempool_alloc(virtscsi_cmd_pool
, GFP_NOIO
);
643 memset(cmd
, 0, sizeof(*cmd
));
644 cmd
->req
.tmf
= (struct virtio_scsi_ctrl_tmf_req
){
645 .type
= VIRTIO_SCSI_T_TMF
,
646 .subtype
= cpu_to_virtio32(vscsi
->vdev
,
647 VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET
),
649 .lun
[1] = sc
->device
->id
,
650 .lun
[2] = (sc
->device
->lun
>> 8) | 0x40,
651 .lun
[3] = sc
->device
->lun
& 0xff,
653 return virtscsi_tmf(vscsi
, cmd
);
656 static int virtscsi_device_alloc(struct scsi_device
*sdevice
)
659 * Passed through SCSI targets (e.g. with qemu's 'scsi-block')
660 * may have transfer limits which come from the host SCSI
661 * controller or something on the host side other than the
664 * To make this work properly, the hypervisor can adjust the
665 * target's VPD information to advertise these limits. But
666 * for that to work, the guest has to look at the VPD pages,
667 * which we won't do by default if it is an SPC-2 device, even
668 * if it does actually support it.
670 * So, set the blist to always try to read the VPD pages.
672 sdevice
->sdev_bflags
= BLIST_TRY_VPD_PAGES
;
679 * virtscsi_change_queue_depth() - Change a virtscsi target's queue depth
680 * @sdev: Virtscsi target whose queue depth to change
681 * @qdepth: New queue depth
683 static int virtscsi_change_queue_depth(struct scsi_device
*sdev
, int qdepth
)
685 struct Scsi_Host
*shost
= sdev
->host
;
686 int max_depth
= shost
->cmd_per_lun
;
688 return scsi_change_queue_depth(sdev
, min(max_depth
, qdepth
));
691 static int virtscsi_abort(struct scsi_cmnd
*sc
)
693 struct virtio_scsi
*vscsi
= shost_priv(sc
->device
->host
);
694 struct virtio_scsi_cmd
*cmd
;
696 scmd_printk(KERN_INFO
, sc
, "abort\n");
697 cmd
= mempool_alloc(virtscsi_cmd_pool
, GFP_NOIO
);
701 memset(cmd
, 0, sizeof(*cmd
));
702 cmd
->req
.tmf
= (struct virtio_scsi_ctrl_tmf_req
){
703 .type
= VIRTIO_SCSI_T_TMF
,
704 .subtype
= VIRTIO_SCSI_T_TMF_ABORT_TASK
,
706 .lun
[1] = sc
->device
->id
,
707 .lun
[2] = (sc
->device
->lun
>> 8) | 0x40,
708 .lun
[3] = sc
->device
->lun
& 0xff,
709 .tag
= cpu_to_virtio64(vscsi
->vdev
, (unsigned long)sc
),
711 return virtscsi_tmf(vscsi
, cmd
);
714 static int virtscsi_map_queues(struct Scsi_Host
*shost
)
716 struct virtio_scsi
*vscsi
= shost_priv(shost
);
717 struct blk_mq_queue_map
*qmap
= &shost
->tag_set
.map
[HCTX_TYPE_DEFAULT
];
719 return blk_mq_virtio_map_queues(qmap
, vscsi
->vdev
, 2);
722 static void virtscsi_commit_rqs(struct Scsi_Host
*shost
, u16 hwq
)
724 struct virtio_scsi
*vscsi
= shost_priv(shost
);
726 virtscsi_kick_vq(&vscsi
->req_vqs
[hwq
]);
730 * The host guarantees to respond to each command, although I/O
731 * latencies might be higher than on bare metal. Reset the timer
732 * unconditionally to give the host a chance to perform EH.
734 static enum blk_eh_timer_return
virtscsi_eh_timed_out(struct scsi_cmnd
*scmnd
)
736 return BLK_EH_RESET_TIMER
;
739 static struct scsi_host_template virtscsi_host_template
= {
740 .module
= THIS_MODULE
,
741 .name
= "Virtio SCSI HBA",
742 .proc_name
= "virtio_scsi",
744 .cmd_size
= sizeof(struct virtio_scsi_cmd
),
745 .queuecommand
= virtscsi_queuecommand
,
746 .commit_rqs
= virtscsi_commit_rqs
,
747 .change_queue_depth
= virtscsi_change_queue_depth
,
748 .eh_abort_handler
= virtscsi_abort
,
749 .eh_device_reset_handler
= virtscsi_device_reset
,
750 .eh_timed_out
= virtscsi_eh_timed_out
,
751 .slave_alloc
= virtscsi_device_alloc
,
753 .dma_boundary
= UINT_MAX
,
754 .map_queues
= virtscsi_map_queues
,
755 .track_queue_depth
= 1,
758 #define virtscsi_config_get(vdev, fld) \
760 __virtio_native_type(struct virtio_scsi_config, fld) __val; \
761 virtio_cread(vdev, struct virtio_scsi_config, fld, &__val); \
765 #define virtscsi_config_set(vdev, fld, val) \
767 __virtio_native_type(struct virtio_scsi_config, fld) __val = (val); \
768 virtio_cwrite(vdev, struct virtio_scsi_config, fld, &__val); \
771 static void virtscsi_init_vq(struct virtio_scsi_vq
*virtscsi_vq
,
772 struct virtqueue
*vq
)
774 spin_lock_init(&virtscsi_vq
->vq_lock
);
775 virtscsi_vq
->vq
= vq
;
778 static void virtscsi_remove_vqs(struct virtio_device
*vdev
)
780 /* Stop all the virtqueues. */
781 vdev
->config
->reset(vdev
);
782 vdev
->config
->del_vqs(vdev
);
785 static int virtscsi_init(struct virtio_device
*vdev
,
786 struct virtio_scsi
*vscsi
)
791 vq_callback_t
**callbacks
;
793 struct virtqueue
**vqs
;
794 struct irq_affinity desc
= { .pre_vectors
= 2 };
796 num_vqs
= vscsi
->num_queues
+ VIRTIO_SCSI_VQ_BASE
;
797 vqs
= kmalloc_array(num_vqs
, sizeof(struct virtqueue
*), GFP_KERNEL
);
798 callbacks
= kmalloc_array(num_vqs
, sizeof(vq_callback_t
*),
800 names
= kmalloc_array(num_vqs
, sizeof(char *), GFP_KERNEL
);
802 if (!callbacks
|| !vqs
|| !names
) {
807 callbacks
[0] = virtscsi_ctrl_done
;
808 callbacks
[1] = virtscsi_event_done
;
809 names
[0] = "control";
811 for (i
= VIRTIO_SCSI_VQ_BASE
; i
< num_vqs
; i
++) {
812 callbacks
[i
] = virtscsi_req_done
;
813 names
[i
] = "request";
816 /* Discover virtqueues and write information to configuration. */
817 err
= virtio_find_vqs(vdev
, num_vqs
, vqs
, callbacks
, names
, &desc
);
821 virtscsi_init_vq(&vscsi
->ctrl_vq
, vqs
[0]);
822 virtscsi_init_vq(&vscsi
->event_vq
, vqs
[1]);
823 for (i
= VIRTIO_SCSI_VQ_BASE
; i
< num_vqs
; i
++)
824 virtscsi_init_vq(&vscsi
->req_vqs
[i
- VIRTIO_SCSI_VQ_BASE
],
827 virtscsi_config_set(vdev
, cdb_size
, VIRTIO_SCSI_CDB_SIZE
);
828 virtscsi_config_set(vdev
, sense_size
, VIRTIO_SCSI_SENSE_SIZE
);
837 virtscsi_remove_vqs(vdev
);
841 static int virtscsi_probe(struct virtio_device
*vdev
)
843 struct Scsi_Host
*shost
;
844 struct virtio_scsi
*vscsi
;
846 u32 sg_elems
, num_targets
;
850 if (!vdev
->config
->get
) {
851 dev_err(&vdev
->dev
, "%s failure: config access disabled\n",
856 /* We need to know how many queues before we allocate. */
857 num_queues
= virtscsi_config_get(vdev
, num_queues
) ? : 1;
858 num_queues
= min_t(unsigned int, nr_cpu_ids
, num_queues
);
860 num_targets
= virtscsi_config_get(vdev
, max_target
) + 1;
862 shost
= scsi_host_alloc(&virtscsi_host_template
,
863 struct_size(vscsi
, req_vqs
, num_queues
));
867 sg_elems
= virtscsi_config_get(vdev
, seg_max
) ?: 1;
868 shost
->sg_tablesize
= sg_elems
;
869 vscsi
= shost_priv(shost
);
871 vscsi
->num_queues
= num_queues
;
874 err
= virtscsi_init(vdev
, vscsi
);
876 goto virtscsi_init_failed
;
878 shost
->can_queue
= virtqueue_get_vring_size(vscsi
->req_vqs
[0].vq
);
880 cmd_per_lun
= virtscsi_config_get(vdev
, cmd_per_lun
) ?: 1;
881 shost
->cmd_per_lun
= min_t(u32
, cmd_per_lun
, shost
->can_queue
);
882 shost
->max_sectors
= virtscsi_config_get(vdev
, max_sectors
) ?: 0xFFFF;
884 /* LUNs > 256 are reported with format 1, so they go in the range
887 shost
->max_lun
= virtscsi_config_get(vdev
, max_lun
) + 1 + 0x4000;
888 shost
->max_id
= num_targets
;
889 shost
->max_channel
= 0;
890 shost
->max_cmd_len
= VIRTIO_SCSI_CDB_SIZE
;
891 shost
->nr_hw_queues
= num_queues
;
893 #ifdef CONFIG_BLK_DEV_INTEGRITY
894 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_T10_PI
)) {
897 host_prot
= SHOST_DIF_TYPE1_PROTECTION
| SHOST_DIF_TYPE2_PROTECTION
|
898 SHOST_DIF_TYPE3_PROTECTION
| SHOST_DIX_TYPE1_PROTECTION
|
899 SHOST_DIX_TYPE2_PROTECTION
| SHOST_DIX_TYPE3_PROTECTION
;
901 scsi_host_set_prot(shost
, host_prot
);
902 scsi_host_set_guard(shost
, SHOST_DIX_GUARD_CRC
);
906 err
= scsi_add_host(shost
, &vdev
->dev
);
908 goto scsi_add_host_failed
;
910 virtio_device_ready(vdev
);
912 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
))
913 virtscsi_kick_event_all(vscsi
);
915 scsi_scan_host(shost
);
918 scsi_add_host_failed
:
919 vdev
->config
->del_vqs(vdev
);
920 virtscsi_init_failed
:
921 scsi_host_put(shost
);
925 static void virtscsi_remove(struct virtio_device
*vdev
)
927 struct Scsi_Host
*shost
= virtio_scsi_host(vdev
);
928 struct virtio_scsi
*vscsi
= shost_priv(shost
);
930 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
))
931 virtscsi_cancel_event_work(vscsi
);
933 scsi_remove_host(shost
);
934 virtscsi_remove_vqs(vdev
);
935 scsi_host_put(shost
);
938 #ifdef CONFIG_PM_SLEEP
939 static int virtscsi_freeze(struct virtio_device
*vdev
)
941 virtscsi_remove_vqs(vdev
);
945 static int virtscsi_restore(struct virtio_device
*vdev
)
947 struct Scsi_Host
*sh
= virtio_scsi_host(vdev
);
948 struct virtio_scsi
*vscsi
= shost_priv(sh
);
951 err
= virtscsi_init(vdev
, vscsi
);
955 virtio_device_ready(vdev
);
957 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
))
958 virtscsi_kick_event_all(vscsi
);
964 static struct virtio_device_id id_table
[] = {
965 { VIRTIO_ID_SCSI
, VIRTIO_DEV_ANY_ID
},
969 static unsigned int features
[] = {
970 VIRTIO_SCSI_F_HOTPLUG
,
971 VIRTIO_SCSI_F_CHANGE
,
972 #ifdef CONFIG_BLK_DEV_INTEGRITY
973 VIRTIO_SCSI_F_T10_PI
,
977 static struct virtio_driver virtio_scsi_driver
= {
978 .feature_table
= features
,
979 .feature_table_size
= ARRAY_SIZE(features
),
980 .driver
.name
= KBUILD_MODNAME
,
981 .driver
.owner
= THIS_MODULE
,
982 .id_table
= id_table
,
983 .probe
= virtscsi_probe
,
984 #ifdef CONFIG_PM_SLEEP
985 .freeze
= virtscsi_freeze
,
986 .restore
= virtscsi_restore
,
988 .remove
= virtscsi_remove
,
991 static int __init
init(void)
995 virtscsi_cmd_cache
= KMEM_CACHE(virtio_scsi_cmd
, 0);
996 if (!virtscsi_cmd_cache
) {
997 pr_err("kmem_cache_create() for virtscsi_cmd_cache failed\n");
1003 mempool_create_slab_pool(VIRTIO_SCSI_MEMPOOL_SZ
,
1004 virtscsi_cmd_cache
);
1005 if (!virtscsi_cmd_pool
) {
1006 pr_err("mempool_create() for virtscsi_cmd_pool failed\n");
1009 ret
= register_virtio_driver(&virtio_scsi_driver
);
1016 mempool_destroy(virtscsi_cmd_pool
);
1017 virtscsi_cmd_pool
= NULL
;
1018 kmem_cache_destroy(virtscsi_cmd_cache
);
1019 virtscsi_cmd_cache
= NULL
;
1023 static void __exit
fini(void)
1025 unregister_virtio_driver(&virtio_scsi_driver
);
1026 mempool_destroy(virtscsi_cmd_pool
);
1027 kmem_cache_destroy(virtscsi_cmd_cache
);
1032 MODULE_DEVICE_TABLE(virtio
, id_table
);
1033 MODULE_DESCRIPTION("Virtio SCSI HBA driver");
1034 MODULE_LICENSE("GPL");