/src/qemu/hw/scsi/virtio-scsi.c
Line | Count | Source |
1 | | /* |
2 | | * Virtio SCSI HBA |
3 | | * |
4 | | * Copyright IBM, Corp. 2010 |
5 | | * Copyright Red Hat, Inc. 2011 |
6 | | * |
7 | | * Authors: |
8 | | * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> |
9 | | * Paolo Bonzini <pbonzini@redhat.com> |
10 | | * |
11 | | * This work is licensed under the terms of the GNU GPL, version 2 or later. |
12 | | * See the COPYING file in the top-level directory. |
13 | | * |
14 | | */ |
15 | | |
16 | | #include "qemu/osdep.h" |
17 | | #include "qapi/error.h" |
18 | | #include "standard-headers/linux/virtio_ids.h" |
19 | | #include "hw/virtio/virtio-scsi.h" |
20 | | #include "migration/qemu-file-types.h" |
21 | | #include "qemu/defer-call.h" |
22 | | #include "qemu/error-report.h" |
23 | | #include "qemu/iov.h" |
24 | | #include "qemu/module.h" |
25 | | #include "system/block-backend.h" |
26 | | #include "system/dma.h" |
27 | | #include "hw/core/qdev-properties.h" |
28 | | #include "hw/scsi/scsi.h" |
29 | | #include "scsi/constants.h" |
30 | | #include "hw/virtio/iothread-vq-mapping.h" |
31 | | #include "hw/virtio/virtio-bus.h" |
32 | | #include "hw/virtio/virtio-access.h" |
33 | | #include "trace.h" |
34 | | |
35 | | typedef struct VirtIOSCSIReq { |
36 | | /* |
37 | | * Note: |
38 | | * - fields up to resp_iov are initialized by virtio_scsi_init_req; |
39 | | * - fields starting at vring are zeroed by virtio_scsi_init_req. |
40 | | */ |
41 | | VirtQueueElement elem; |
42 | | |
43 | | VirtIOSCSI *dev; |
44 | | VirtQueue *vq; |
45 | | QEMUSGList qsgl; |
46 | | QEMUIOVector resp_iov; |
47 | | |
48 | | /* Used for two-stage request submission and TMFs deferred to BH */ |
49 | | QTAILQ_ENTRY(VirtIOSCSIReq) next; |
50 | | |
51 | | /* Used for cancellation of request during TMFs. Atomic. */ |
52 | | int remaining; |
53 | | |
54 | | SCSIRequest *sreq; |
55 | | size_t resp_size; |
56 | | enum SCSIXferMode mode; |
57 | | union { |
58 | | VirtIOSCSICmdResp cmd; |
59 | | VirtIOSCSICtrlTMFResp tmf; |
60 | | VirtIOSCSICtrlANResp an; |
61 | | VirtIOSCSIEvent event; |
62 | | } resp; |
63 | | union { |
64 | | VirtIOSCSICmdReq cmd; |
65 | | VirtIOSCSICtrlTMFReq tmf; |
66 | | VirtIOSCSICtrlANReq an; |
67 | | } req; |
68 | | } VirtIOSCSIReq; |
69 | | |
70 | | static inline int virtio_scsi_get_lun(uint8_t *lun) |
71 | 221k | { |
72 | 221k | return ((lun[2] << 8) | lun[3]) & 0x3FFF; |
73 | 221k | } |
74 | | |
75 | | static inline SCSIDevice *virtio_scsi_device_get(VirtIOSCSI *s, uint8_t *lun) |
76 | 64.3k | { |
77 | 64.3k | if (lun[0] != 1) { |
78 | 18.7k | return NULL; |
79 | 18.7k | } |
80 | 45.5k | if (lun[2] != 0 && !(lun[2] >= 0x40 && lun[2] < 0x80)) { |
81 | 247 | return NULL; |
82 | 247 | } |
83 | 45.2k | return scsi_device_get(&s->bus, 0, lun[1], virtio_scsi_get_lun(lun)); |
84 | 45.5k | } |
85 | | |
86 | | static void virtio_scsi_init_req(VirtIOSCSI *s, VirtQueue *vq, VirtIOSCSIReq *req) |
87 | 84.2k | { |
88 | 84.2k | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
89 | 84.2k | const size_t zero_skip = |
90 | 84.2k | offsetof(VirtIOSCSIReq, resp_iov) + sizeof(req->resp_iov); |
91 | | |
92 | 84.2k | req->vq = vq; |
93 | 84.2k | req->dev = s; |
94 | 84.2k | qemu_sglist_init(&req->qsgl, DEVICE(s), 8, vdev->dma_as); |
95 | 84.2k | qemu_iovec_init(&req->resp_iov, 1); |
96 | 84.2k | memset((uint8_t *)req + zero_skip, 0, sizeof(*req) - zero_skip); |
97 | 84.2k | } |
98 | | |
99 | | static void virtio_scsi_free_req(VirtIOSCSIReq *req) |
100 | 84.2k | { |
101 | 84.2k | qemu_iovec_destroy(&req->resp_iov); |
102 | 84.2k | qemu_sglist_destroy(&req->qsgl); |
103 | 84.2k | g_free(req); |
104 | 84.2k | } |
105 | | |
106 | | static void virtio_scsi_complete_req(VirtIOSCSIReq *req, QemuMutex *vq_lock) |
107 | 82.6k | { |
108 | 82.6k | VirtIOSCSI *s = req->dev; |
109 | 82.6k | VirtQueue *vq = req->vq; |
110 | 82.6k | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
111 | | |
112 | 82.6k | qemu_iovec_from_buf(&req->resp_iov, 0, &req->resp, req->resp_size); |
113 | | |
114 | 82.6k | if (vq_lock) { |
115 | 19.5k | qemu_mutex_lock(vq_lock); |
116 | 19.5k | } |
117 | | |
118 | 82.6k | virtqueue_push(vq, &req->elem, req->qsgl.size + req->resp_iov.size); |
119 | 82.6k | virtio_notify(vdev, vq); |
120 | | |
121 | 82.6k | if (vq_lock) { |
122 | 19.5k | qemu_mutex_unlock(vq_lock); |
123 | 19.5k | } |
124 | | |
125 | 82.6k | if (req->sreq) { |
126 | 44.2k | req->sreq->hba_private = NULL; |
127 | 44.2k | scsi_req_unref(req->sreq); |
128 | 44.2k | } |
129 | 82.6k | virtio_scsi_free_req(req); |
130 | 82.6k | } |
131 | | |
132 | | static void virtio_scsi_bad_req(VirtIOSCSIReq *req, QemuMutex *vq_lock) |
133 | 1.64k | { |
134 | 1.64k | virtio_error(VIRTIO_DEVICE(req->dev), "wrong size for virtio-scsi headers"); |
135 | | |
136 | 1.64k | if (vq_lock) { |
137 | 905 | qemu_mutex_lock(vq_lock); |
138 | 905 | } |
139 | | |
140 | 1.64k | virtqueue_detach_element(req->vq, &req->elem, 0); |
141 | | |
142 | 1.64k | if (vq_lock) { |
143 | 905 | qemu_mutex_unlock(vq_lock); |
144 | 905 | } |
145 | | |
146 | 1.64k | virtio_scsi_free_req(req); |
147 | 1.64k | } |
148 | | |
149 | | static size_t qemu_sgl_concat(VirtIOSCSIReq *req, struct iovec *iov, |
150 | | hwaddr *addr, int num, size_t skip) |
151 | 131k | { |
152 | 131k | QEMUSGList *qsgl = &req->qsgl; |
153 | 131k | size_t copied = 0; |
154 | | |
155 | 299k | while (num) { |
156 | 168k | if (skip >= iov->iov_len) { |
157 | 131k | skip -= iov->iov_len; |
158 | 131k | } else { |
159 | 37.0k | qemu_sglist_add(qsgl, *addr + skip, iov->iov_len - skip); |
160 | 37.0k | copied += iov->iov_len - skip; |
161 | 37.0k | skip = 0; |
162 | 37.0k | } |
163 | 168k | iov++; |
164 | 168k | addr++; |
165 | 168k | num--; |
166 | 168k | } |
167 | | |
168 | 131k | assert(skip == 0); |
169 | 131k | return copied; |
170 | 131k | } |
171 | | |
172 | | static int virtio_scsi_parse_req(VirtIOSCSIReq *req, |
173 | | unsigned req_size, unsigned resp_size) |
174 | 67.2k | { |
175 | 67.2k | VirtIODevice *vdev = (VirtIODevice *) req->dev; |
176 | 67.2k | size_t in_size, out_size; |
177 | | |
178 | 67.2k | if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0, |
179 | 67.2k | &req->req, req_size) < req_size) { |
180 | 334 | return -EINVAL; |
181 | 334 | } |
182 | | |
183 | 66.9k | if (qemu_iovec_concat_iov(&req->resp_iov, |
184 | 66.9k | req->elem.in_sg, req->elem.in_num, 0, |
185 | 66.9k | resp_size) < resp_size) { |
186 | 1.28k | return -EINVAL; |
187 | 1.28k | } |
188 | | |
189 | 65.6k | req->resp_size = resp_size; |
190 | | |
191 | | /* Old BIOSes left some padding by mistake after the req_size/resp_size. |
192 | | * As a workaround, always consider the first buffer as the virtio-scsi |
193 | | * request/response, making the payload start at the second element |
194 | | * of the iovec. |
195 | | * |
196 | | * The actual length of the response header, stored in req->resp_size, |
197 | | * does not change. |
198 | | * |
199 | | * TODO: always disable this workaround for virtio 1.0 devices. |
200 | | */ |
201 | 65.6k | if (!virtio_vdev_has_feature(vdev, VIRTIO_F_ANY_LAYOUT)) { |
202 | 65.5k | if (req->elem.out_num) { |
203 | 65.5k | req_size = req->elem.out_sg[0].iov_len; |
204 | 65.5k | } |
205 | 65.5k | if (req->elem.in_num) { |
206 | 65.5k | resp_size = req->elem.in_sg[0].iov_len; |
207 | 65.5k | } |
208 | 65.5k | } |
209 | | |
210 | 65.6k | out_size = qemu_sgl_concat(req, req->elem.out_sg, |
211 | 65.6k | &req->elem.out_addr[0], req->elem.out_num, |
212 | 65.6k | req_size); |
213 | 65.6k | in_size = qemu_sgl_concat(req, req->elem.in_sg, |
214 | 65.6k | &req->elem.in_addr[0], req->elem.in_num, |
215 | 65.6k | resp_size); |
216 | | |
217 | 65.6k | if (out_size && in_size) { |
218 | 90 | return -ENOTSUP; |
219 | 90 | } |
220 | | |
221 | 65.5k | if (out_size) { |
222 | 36.1k | req->mode = SCSI_XFER_TO_DEV; |
223 | 36.1k | } else if (in_size) { |
224 | 249 | req->mode = SCSI_XFER_FROM_DEV; |
225 | 249 | } |
226 | | |
227 | 65.5k | return 0; |
228 | 65.6k | } |
229 | | |
230 | | static VirtIOSCSIReq *virtio_scsi_pop_req(VirtIOSCSI *s, VirtQueue *vq, size_t extra_req_size, |
231 | | QemuMutex *vq_lock) |
232 | 115k | { |
233 | 115k | VirtIOSCSIReq *req; |
234 | | |
235 | 115k | if (vq_lock) { |
236 | 24.8k | qemu_mutex_lock(vq_lock); |
237 | 24.8k | } |
238 | | |
239 | 115k | req = virtqueue_pop(vq, sizeof(VirtIOSCSIReq) + extra_req_size); |
240 | | |
241 | 115k | if (vq_lock) { |
242 | 24.8k | qemu_mutex_unlock(vq_lock); |
243 | 24.8k | } |
244 | | |
245 | 115k | if (!req) { |
246 | 31.0k | return NULL; |
247 | 31.0k | } |
248 | 84.2k | virtio_scsi_init_req(s, vq, req); |
249 | 84.2k | return req; |
250 | 115k | } |
251 | | |
252 | | static void virtio_scsi_save_request(QEMUFile *f, SCSIRequest *sreq) |
253 | 0 | { |
254 | 0 | VirtIOSCSIReq *req = sreq->hba_private; |
255 | 0 | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(req->dev); |
256 | 0 | VirtIODevice *vdev = VIRTIO_DEVICE(req->dev); |
257 | 0 | uint32_t n = virtio_get_queue_index(req->vq) - VIRTIO_SCSI_VQ_NUM_FIXED; |
258 | |
|
259 | 0 | assert(n < vs->conf.num_queues); |
260 | 0 | qemu_put_be32s(f, &n); |
261 | 0 | qemu_put_virtqueue_element(vdev, f, &req->elem); |
262 | 0 | } |
263 | | |
264 | | static void *virtio_scsi_load_request(QEMUFile *f, SCSIRequest *sreq) |
265 | 0 | { |
266 | 0 | SCSIBus *bus = sreq->bus; |
267 | 0 | VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus); |
268 | 0 | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s); |
269 | 0 | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
270 | 0 | VirtIOSCSIReq *req; |
271 | 0 | uint32_t n; |
272 | |
|
273 | 0 | qemu_get_be32s(f, &n); |
274 | 0 | assert(n < vs->conf.num_queues); |
275 | 0 | req = qemu_get_virtqueue_element(vdev, f, |
276 | 0 | sizeof(VirtIOSCSIReq) + vs->cdb_size); |
277 | 0 | if (!req) { |
278 | 0 | error_report("Failed to restore virtio-scsi request"); |
279 | 0 | return NULL; |
280 | 0 | } |
281 | 0 | virtio_scsi_init_req(s, vs->cmd_vqs[n], req); |
282 | |
|
283 | 0 | if (virtio_scsi_parse_req(req, sizeof(VirtIOSCSICmdReq) + vs->cdb_size, |
284 | 0 | sizeof(VirtIOSCSICmdResp) + vs->sense_size) < 0) { |
285 | 0 | error_report("invalid SCSI request migration data"); |
286 | 0 | exit(1); |
287 | 0 | } |
288 | | |
289 | 0 | scsi_req_ref(sreq); |
290 | 0 | req->sreq = sreq; |
291 | 0 | if (req->sreq->cmd.mode != SCSI_XFER_NONE) { |
292 | 0 | assert(req->sreq->cmd.mode == req->mode); |
293 | 0 | } |
294 | 0 | return req; |
295 | 0 | } |
296 | | |
297 | | typedef struct { |
298 | | Notifier notifier; |
299 | | VirtIOSCSIReq *tmf_req; |
300 | | } VirtIOSCSICancelNotifier; |
301 | | |
302 | | static void virtio_scsi_tmf_dec_remaining(VirtIOSCSIReq *tmf) |
303 | 858 | { |
304 | 858 | if (qatomic_fetch_dec(&tmf->remaining) == 1) { |
305 | 429 | trace_virtio_scsi_tmf_resp(virtio_scsi_get_lun(tmf->req.tmf.lun), |
306 | 429 | tmf->req.tmf.tag, tmf->resp.tmf.response); |
307 | | |
308 | 429 | virtio_scsi_complete_req(tmf, &tmf->dev->ctrl_lock); |
309 | 429 | } |
310 | 858 | } |
311 | | |
312 | | static void virtio_scsi_cancel_notify(Notifier *notifier, void *data) |
313 | 0 | { |
314 | 0 | VirtIOSCSICancelNotifier *n = container_of(notifier, |
315 | 0 | VirtIOSCSICancelNotifier, |
316 | 0 | notifier); |
317 | |
|
318 | 0 | virtio_scsi_tmf_dec_remaining(n->tmf_req); |
319 | 0 | g_free(n); |
320 | 0 | } |
321 | | |
322 | | static void virtio_scsi_tmf_cancel_req(VirtIOSCSIReq *tmf, SCSIRequest *r) |
323 | 0 | { |
324 | 0 | VirtIOSCSICancelNotifier *notifier; |
325 | |
|
326 | 0 | assert(r->ctx == qemu_get_current_aio_context()); |
327 | | |
328 | | /* Decremented in virtio_scsi_cancel_notify() */ |
329 | 0 | qatomic_inc(&tmf->remaining); |
330 | |
|
331 | 0 | notifier = g_new(VirtIOSCSICancelNotifier, 1); |
332 | 0 | notifier->notifier.notify = virtio_scsi_cancel_notify; |
333 | 0 | notifier->tmf_req = tmf; |
334 | 0 | scsi_req_cancel_async(r, ¬ifier->notifier); |
335 | 0 | } |
336 | | |
337 | | /* Execute a TMF on the requests in the current AioContext */ |
338 | | static void virtio_scsi_do_tmf_aio_context(void *opaque) |
339 | 429 | { |
340 | 429 | AioContext *ctx = qemu_get_current_aio_context(); |
341 | 429 | VirtIOSCSIReq *tmf = opaque; |
342 | 429 | VirtIOSCSI *s = tmf->dev; |
343 | 429 | SCSIDevice *d = virtio_scsi_device_get(s, tmf->req.tmf.lun); |
344 | 429 | SCSIRequest *r; |
345 | 429 | bool match_tag; |
346 | 429 | g_autoptr(GList) reqs = NULL; |
347 | | |
348 | 429 | if (!d) { |
349 | 0 | tmf->resp.tmf.response = VIRTIO_SCSI_S_BAD_TARGET; |
350 | 0 | virtio_scsi_tmf_dec_remaining(tmf); |
351 | 0 | return; |
352 | 0 | } |
353 | | |
354 | | /* |
355 | | * This function could handle other subtypes that need to be processed in |
356 | | * the request's AioContext in the future, but for now only request |
357 | | * cancelation subtypes are performed here. |
358 | | */ |
359 | 429 | switch (tmf->req.tmf.subtype) { |
360 | 0 | case VIRTIO_SCSI_T_TMF_ABORT_TASK: |
361 | 0 | match_tag = true; |
362 | 0 | break; |
363 | 0 | case VIRTIO_SCSI_T_TMF_ABORT_TASK_SET: |
364 | 429 | case VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET: |
365 | 429 | match_tag = false; |
366 | 429 | break; |
367 | 0 | default: |
368 | 0 | g_assert_not_reached(); |
369 | 429 | } |
370 | | |
371 | 429 | WITH_QEMU_LOCK_GUARD(&d->requests_lock) { |
372 | 429 | QTAILQ_FOREACH(r, &d->requests, next) { |
373 | 0 | VirtIOSCSIReq *cmd_req = r->hba_private; |
374 | 0 | assert(cmd_req); /* request has hba_private while enqueued */ |
375 | |
|
376 | 0 | if (r->ctx != ctx) { |
377 | 0 | continue; |
378 | 0 | } |
379 | 0 | if (match_tag && cmd_req->req.cmd.tag != tmf->req.tmf.tag) { |
380 | 0 | continue; |
381 | 0 | } |
382 | | /* |
383 | | * Cannot cancel directly, because scsi_req_dequeue() would deadlock |
384 | | * when attempting to acquire the request_lock a second time. Taking |
385 | | * a reference here is paired with an unref after cancelling below. |
386 | | */ |
387 | 0 | scsi_req_ref(r); |
388 | 0 | reqs = g_list_prepend(reqs, r); |
389 | 0 | } |
390 | 429 | } |
391 | | |
392 | 429 | for (GList *elem = g_list_first(reqs); elem; elem = g_list_next(elem)) { |
393 | 0 | virtio_scsi_tmf_cancel_req(tmf, elem->data); |
394 | 0 | scsi_req_unref(elem->data); |
395 | 0 | } |
396 | | |
397 | | /* Incremented by virtio_scsi_do_tmf() */ |
398 | 429 | virtio_scsi_tmf_dec_remaining(tmf); |
399 | | |
400 | 429 | object_unref(d); |
401 | 429 | } |
402 | | |
403 | | static void dummy_bh(void *opaque) |
404 | 477k | { |
405 | | /* Do nothing */ |
406 | 477k | } |
407 | | |
408 | | /* |
409 | | * Wait for pending virtio_scsi_defer_tmf_to_aio_context() BHs. |
410 | | */ |
411 | | static void virtio_scsi_flush_defer_tmf_to_aio_context(VirtIOSCSI *s) |
412 | 59.7k | { |
413 | 59.7k | GLOBAL_STATE_CODE(); |
414 | | |
415 | 59.7k | assert(!s->dataplane_started); |
416 | | |
417 | 537k | for (uint32_t i = 0; i < s->parent_obj.conf.num_queues; i++) { |
418 | 477k | AioContext *ctx = s->vq_aio_context[VIRTIO_SCSI_VQ_NUM_FIXED + i]; |
419 | | |
420 | | /* Our BH only runs after previously scheduled BHs */ |
421 | 477k | aio_wait_bh_oneshot(ctx, dummy_bh, NULL); |
422 | 477k | } |
423 | 59.7k | } |
424 | | |
425 | | /* |
426 | | * Run the TMF in a specific AioContext, handling only requests in that |
427 | | * AioContext. This is necessary because requests can run in different |
428 | | * AioContext and it is only possible to cancel them from the AioContext where |
429 | | * they are running. |
430 | | */ |
431 | | static void virtio_scsi_defer_tmf_to_aio_context(VirtIOSCSIReq *tmf, |
432 | | AioContext *ctx) |
433 | 429 | { |
434 | | /* Decremented in virtio_scsi_do_tmf_aio_context() */ |
435 | 429 | qatomic_inc(&tmf->remaining); |
436 | | |
437 | | /* See virtio_scsi_flush_defer_tmf_to_aio_context() cleanup during reset */ |
438 | 429 | aio_bh_schedule_oneshot(ctx, virtio_scsi_do_tmf_aio_context, tmf); |
439 | 429 | } |
440 | | |
441 | | /* |
442 | | * Returns the AioContext for a given TMF's tag field or NULL. Note that the |
443 | | * request identified by the tag may have completed by the time you can execute |
444 | | * a BH in the AioContext, so don't assume the request still exists in your BH. |
445 | | */ |
446 | | static AioContext *find_aio_context_for_tmf_tag(SCSIDevice *d, |
447 | | VirtIOSCSIReq *tmf) |
448 | 0 | { |
449 | 0 | WITH_QEMU_LOCK_GUARD(&d->requests_lock) { |
450 | 0 | SCSIRequest *r; |
451 | 0 | SCSIRequest *next; |
452 | |
|
453 | 0 | QTAILQ_FOREACH_SAFE(r, &d->requests, next, next) { |
454 | 0 | VirtIOSCSIReq *cmd_req = r->hba_private; |
455 | | |
456 | | /* hba_private is non-NULL while the request is enqueued */ |
457 | 0 | assert(cmd_req); |
458 | |
|
459 | 0 | if (cmd_req->req.cmd.tag == tmf->req.tmf.tag) { |
460 | 0 | return r->ctx; |
461 | 0 | } |
462 | 0 | } |
463 | 0 | } |
464 | 0 | return NULL; |
465 | 0 | } |
466 | | |
467 | | /* Return 0 if the request is ready to be completed and return to guest; |
468 | | * -EINPROGRESS if the request is submitted and will be completed later, in the |
469 | | * case of async cancellation. */ |
470 | | static int virtio_scsi_do_tmf(VirtIOSCSI *s, VirtIOSCSIReq *req) |
471 | 893 | { |
472 | 893 | SCSIDevice *d = virtio_scsi_device_get(s, req->req.tmf.lun); |
473 | 893 | SCSIRequest *r, *next; |
474 | 893 | AioContext *ctx; |
475 | 893 | int ret = 0; |
476 | | |
477 | | /* Here VIRTIO_SCSI_S_OK means "FUNCTION COMPLETE". */ |
478 | 893 | req->resp.tmf.response = VIRTIO_SCSI_S_OK; |
479 | | |
480 | | /* |
481 | | * req->req.tmf has the QEMU_PACKED attribute. Don't use virtio_tswap32s() |
482 | | * to avoid compiler errors. |
483 | | */ |
484 | 893 | req->req.tmf.subtype = |
485 | 893 | virtio_tswap32(VIRTIO_DEVICE(s), req->req.tmf.subtype); |
486 | | |
487 | 893 | trace_virtio_scsi_tmf_req(virtio_scsi_get_lun(req->req.tmf.lun), |
488 | 893 | req->req.tmf.tag, req->req.tmf.subtype); |
489 | | |
490 | 893 | switch (req->req.tmf.subtype) { |
491 | 137 | case VIRTIO_SCSI_T_TMF_ABORT_TASK: { |
492 | 137 | if (!d) { |
493 | 137 | goto fail; |
494 | 137 | } |
495 | 0 | if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) { |
496 | 0 | goto incorrect_lun; |
497 | 0 | } |
498 | | |
499 | 0 | ctx = find_aio_context_for_tmf_tag(d, req); |
500 | 0 | if (ctx) { |
501 | 0 | virtio_scsi_defer_tmf_to_aio_context(req, ctx); |
502 | 0 | ret = -EINPROGRESS; |
503 | 0 | } |
504 | 0 | break; |
505 | 0 | } |
506 | | |
507 | 0 | case VIRTIO_SCSI_T_TMF_QUERY_TASK: |
508 | 0 | if (!d) { |
509 | 0 | goto fail; |
510 | 0 | } |
511 | 0 | if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) { |
512 | 0 | goto incorrect_lun; |
513 | 0 | } |
514 | | |
515 | 0 | WITH_QEMU_LOCK_GUARD(&d->requests_lock) { |
516 | 0 | QTAILQ_FOREACH(r, &d->requests, next) { |
517 | 0 | VirtIOSCSIReq *cmd_req = r->hba_private; |
518 | 0 | assert(cmd_req); /* request has hba_private while enqueued */ |
519 | |
|
520 | 0 | if (cmd_req->req.cmd.tag == req->req.tmf.tag) { |
521 | | /* |
522 | | * "If the specified command is present in the task set, |
523 | | * then return a service response set to FUNCTION |
524 | | * SUCCEEDED". |
525 | | */ |
526 | 0 | req->resp.tmf.response = VIRTIO_SCSI_S_FUNCTION_SUCCEEDED; |
527 | 0 | } |
528 | 0 | } |
529 | 0 | } |
530 | 0 | break; |
531 | | |
532 | 9 | case VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET: |
533 | 9 | if (!d) { |
534 | 0 | goto fail; |
535 | 0 | } |
536 | 9 | if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) { |
537 | 2 | goto incorrect_lun; |
538 | 2 | } |
539 | 7 | qatomic_inc(&s->resetting); |
540 | 7 | device_cold_reset(&d->qdev); |
541 | 7 | qatomic_dec(&s->resetting); |
542 | 7 | break; |
543 | | |
544 | 171 | case VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET: { |
545 | 171 | BusChild *kid; |
546 | 171 | int target = req->req.tmf.lun[1]; |
547 | 171 | qatomic_inc(&s->resetting); |
548 | | |
549 | 171 | rcu_read_lock(); |
550 | 171 | QTAILQ_FOREACH_RCU(kid, &s->bus.qbus.children, sibling) { |
551 | 171 | SCSIDevice *d1 = SCSI_DEVICE(kid->child); |
552 | 171 | if (d1->channel == 0 && d1->id == target) { |
553 | 171 | device_cold_reset(&d1->qdev); |
554 | 171 | } |
555 | 171 | } |
556 | 171 | rcu_read_unlock(); |
557 | | |
558 | 171 | qatomic_dec(&s->resetting); |
559 | 171 | break; |
560 | 171 | } |
561 | | |
562 | 9 | case VIRTIO_SCSI_T_TMF_ABORT_TASK_SET: |
563 | 438 | case VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET: { |
564 | 438 | g_autoptr(GHashTable) aio_contexts = g_hash_table_new(NULL, NULL); |
565 | | |
566 | 438 | if (!d) { |
567 | 9 | goto fail; |
568 | 9 | } |
569 | 429 | if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) { |
570 | 0 | goto incorrect_lun; |
571 | 0 | } |
572 | | |
573 | 429 | qatomic_inc(&req->remaining); |
574 | | |
575 | 3.86k | for (uint32_t i = 0; i < s->parent_obj.conf.num_queues; i++) { |
576 | 3.43k | ctx = s->vq_aio_context[VIRTIO_SCSI_VQ_NUM_FIXED + i]; |
577 | | |
578 | 3.43k | if (!g_hash_table_add(aio_contexts, ctx)) { |
579 | 3.00k | continue; /* skip previously added AioContext */ |
580 | 3.00k | } |
581 | | |
582 | 429 | virtio_scsi_defer_tmf_to_aio_context(req, ctx); |
583 | 429 | } |
584 | | |
585 | 429 | virtio_scsi_tmf_dec_remaining(req); |
586 | 429 | ret = -EINPROGRESS; |
587 | 429 | break; |
588 | 429 | } |
589 | | |
590 | 134 | case VIRTIO_SCSI_T_TMF_QUERY_TASK_SET: |
591 | 134 | if (!d) { |
592 | 0 | goto fail; |
593 | 0 | } |
594 | 134 | if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) { |
595 | 134 | goto incorrect_lun; |
596 | 134 | } |
597 | | |
598 | 0 | WITH_QEMU_LOCK_GUARD(&d->requests_lock) { |
599 | 0 | QTAILQ_FOREACH_SAFE(r, &d->requests, next, next) { |
600 | | /* Request has hba_private while enqueued */ |
601 | 0 | assert(r->hba_private); |
602 | | |
603 | | /* |
604 | | * "If there is any command present in the task set, then |
605 | | * return a service response set to FUNCTION SUCCEEDED". |
606 | | */ |
607 | 0 | req->resp.tmf.response = VIRTIO_SCSI_S_FUNCTION_SUCCEEDED; |
608 | 0 | break; |
609 | 0 | } |
610 | 0 | } |
611 | 0 | break; |
612 | | |
613 | 0 | case VIRTIO_SCSI_T_TMF_CLEAR_ACA: |
614 | 4 | default: |
615 | 4 | req->resp.tmf.response = VIRTIO_SCSI_S_FUNCTION_REJECTED; |
616 | 4 | break; |
617 | 893 | } |
618 | | |
619 | 611 | object_unref(OBJECT(d)); |
620 | 611 | return ret; |
621 | | |
622 | 136 | incorrect_lun: |
623 | 136 | req->resp.tmf.response = VIRTIO_SCSI_S_INCORRECT_LUN; |
624 | 136 | object_unref(OBJECT(d)); |
625 | 136 | return ret; |
626 | | |
627 | 146 | fail: |
628 | 146 | req->resp.tmf.response = VIRTIO_SCSI_S_BAD_TARGET; |
629 | 146 | object_unref(OBJECT(d)); |
630 | 146 | return ret; |
631 | 893 | } |
632 | | |
633 | | static void virtio_scsi_handle_ctrl_req(VirtIOSCSI *s, VirtIOSCSIReq *req) |
634 | 20.4k | { |
635 | 20.4k | VirtIODevice *vdev = (VirtIODevice *)s; |
636 | 20.4k | uint32_t type; |
637 | 20.4k | int r = 0; |
638 | | |
639 | 20.4k | if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0, |
640 | 20.4k | &type, sizeof(type)) < sizeof(type)) { |
641 | 24 | virtio_scsi_bad_req(req, &s->ctrl_lock); |
642 | 24 | return; |
643 | 24 | } |
644 | | |
645 | 20.4k | virtio_tswap32s(vdev, &type); |
646 | 20.4k | if (type == VIRTIO_SCSI_T_TMF) { |
647 | 1.77k | if (virtio_scsi_parse_req(req, sizeof(VirtIOSCSICtrlTMFReq), |
648 | 1.77k | sizeof(VirtIOSCSICtrlTMFResp)) < 0) { |
649 | 881 | virtio_scsi_bad_req(req, &s->ctrl_lock); |
650 | 881 | return; |
651 | 893 | } else { |
652 | 893 | r = virtio_scsi_do_tmf(s, req); |
653 | 893 | } |
654 | | |
655 | 18.6k | } else if (type == VIRTIO_SCSI_T_AN_QUERY || |
656 | 16.9k | type == VIRTIO_SCSI_T_AN_SUBSCRIBE) { |
657 | 1.67k | if (virtio_scsi_parse_req(req, sizeof(VirtIOSCSICtrlANReq), |
658 | 1.67k | sizeof(VirtIOSCSICtrlANResp)) < 0) { |
659 | 0 | virtio_scsi_bad_req(req, &s->ctrl_lock); |
660 | 0 | return; |
661 | 1.67k | } else { |
662 | 1.67k | req->req.an.event_requested = |
663 | 1.67k | virtio_tswap32(VIRTIO_DEVICE(s), req->req.an.event_requested); |
664 | 1.67k | trace_virtio_scsi_an_req(virtio_scsi_get_lun(req->req.an.lun), |
665 | 1.67k | req->req.an.event_requested); |
666 | 1.67k | req->resp.an.event_actual = 0; |
667 | 1.67k | req->resp.an.response = VIRTIO_SCSI_S_OK; |
668 | 1.67k | } |
669 | 1.67k | } |
670 | 19.5k | if (r == 0) { |
671 | 19.1k | if (type == VIRTIO_SCSI_T_TMF) |
672 | 464 | trace_virtio_scsi_tmf_resp(virtio_scsi_get_lun(req->req.tmf.lun), |
673 | 464 | req->req.tmf.tag, |
674 | 464 | req->resp.tmf.response); |
675 | 18.6k | else if (type == VIRTIO_SCSI_T_AN_QUERY || |
676 | 16.9k | type == VIRTIO_SCSI_T_AN_SUBSCRIBE) |
677 | 1.67k | trace_virtio_scsi_an_resp(virtio_scsi_get_lun(req->req.an.lun), |
678 | 1.67k | req->resp.an.response); |
679 | 19.1k | virtio_scsi_complete_req(req, &s->ctrl_lock); |
680 | 19.1k | } else { |
681 | 429 | assert(r == -EINPROGRESS); |
682 | 429 | } |
683 | 19.5k | } |
684 | | |
685 | | static void virtio_scsi_handle_ctrl_vq(VirtIOSCSI *s, VirtQueue *vq) |
686 | 4.34k | { |
687 | 4.34k | VirtIOSCSIReq *req; |
688 | | |
689 | 24.8k | while ((req = virtio_scsi_pop_req(s, vq, 0, &s->ctrl_lock))) { |
690 | 20.4k | virtio_scsi_handle_ctrl_req(s, req); |
691 | 20.4k | } |
692 | 4.34k | } |
693 | | |
694 | | /* |
695 | | * If dataplane is configured but not yet started, do so now and return true on |
696 | | * success. |
697 | | * |
698 | | * Dataplane is started by the core virtio code but virtqueue handler functions |
699 | | * can also be invoked when a guest kicks before DRIVER_OK, so this helper |
700 | | * function helps us deal with manually starting ioeventfd in that case. |
701 | | */ |
702 | | static bool virtio_scsi_defer_to_dataplane(VirtIOSCSI *s) |
703 | 32.2k | { |
704 | 32.2k | if (s->dataplane_started) { |
705 | 29.6k | return false; |
706 | 29.6k | } |
707 | 2.57k | if (s->vq_aio_context[0] == qemu_get_aio_context()) { |
708 | 2.57k | return false; /* not using IOThreads */ |
709 | 2.57k | } |
710 | | |
711 | 0 | virtio_device_start_ioeventfd(&s->parent_obj.parent_obj); |
712 | 0 | return !s->dataplane_fenced; |
713 | 2.57k | } |
714 | | |
715 | | static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq) |
716 | 4.34k | { |
717 | 4.34k | VirtIOSCSI *s = (VirtIOSCSI *)vdev; |
718 | | |
719 | 4.34k | if (virtio_scsi_defer_to_dataplane(s)) { |
720 | 0 | return; |
721 | 0 | } |
722 | | |
723 | 4.34k | virtio_scsi_handle_ctrl_vq(s, vq); |
724 | 4.34k | } |
725 | | |
726 | | static void virtio_scsi_complete_cmd_req(VirtIOSCSIReq *req) |
727 | 63.0k | { |
728 | 63.0k | trace_virtio_scsi_cmd_resp(virtio_scsi_get_lun(req->req.cmd.lun), |
729 | 63.0k | req->req.cmd.tag, |
730 | 63.0k | req->resp.cmd.response, |
731 | 63.0k | req->resp.cmd.status); |
732 | | /* Sense data is not in req->resp and is copied separately |
733 | | * in virtio_scsi_command_complete. |
734 | | */ |
735 | 63.0k | req->resp_size = sizeof(VirtIOSCSICmdResp); |
736 | 63.0k | virtio_scsi_complete_req(req, NULL); |
737 | 63.0k | } |
738 | | |
739 | | static void virtio_scsi_command_failed(SCSIRequest *r) |
740 | 0 | { |
741 | 0 | VirtIOSCSIReq *req = r->hba_private; |
742 | |
|
743 | 0 | if (r->io_canceled) { |
744 | 0 | return; |
745 | 0 | } |
746 | | |
747 | 0 | req->resp.cmd.status = GOOD; |
748 | 0 | switch (r->host_status) { |
749 | 0 | case SCSI_HOST_NO_LUN: |
750 | 0 | req->resp.cmd.response = VIRTIO_SCSI_S_INCORRECT_LUN; |
751 | 0 | break; |
752 | 0 | case SCSI_HOST_BUSY: |
753 | 0 | req->resp.cmd.response = VIRTIO_SCSI_S_BUSY; |
754 | 0 | break; |
755 | 0 | case SCSI_HOST_TIME_OUT: |
756 | 0 | case SCSI_HOST_ABORTED: |
757 | 0 | req->resp.cmd.response = VIRTIO_SCSI_S_ABORTED; |
758 | 0 | break; |
759 | 0 | case SCSI_HOST_BAD_RESPONSE: |
760 | 0 | req->resp.cmd.response = VIRTIO_SCSI_S_BAD_TARGET; |
761 | 0 | break; |
762 | 0 | case SCSI_HOST_RESET: |
763 | 0 | req->resp.cmd.response = VIRTIO_SCSI_S_RESET; |
764 | 0 | break; |
765 | 0 | case SCSI_HOST_TRANSPORT_DISRUPTED: |
766 | 0 | req->resp.cmd.response = VIRTIO_SCSI_S_TRANSPORT_FAILURE; |
767 | 0 | break; |
768 | 0 | case SCSI_HOST_TARGET_FAILURE: |
769 | 0 | req->resp.cmd.response = VIRTIO_SCSI_S_TARGET_FAILURE; |
770 | 0 | break; |
771 | 0 | case SCSI_HOST_RESERVATION_ERROR: |
772 | 0 | req->resp.cmd.response = VIRTIO_SCSI_S_NEXUS_FAILURE; |
773 | 0 | break; |
774 | 0 | case SCSI_HOST_ALLOCATION_FAILURE: |
775 | 0 | case SCSI_HOST_MEDIUM_ERROR: |
776 | 0 | case SCSI_HOST_ERROR: |
777 | 0 | default: |
778 | 0 | req->resp.cmd.response = VIRTIO_SCSI_S_FAILURE; |
779 | 0 | break; |
780 | 0 | } |
781 | 0 | virtio_scsi_complete_cmd_req(req); |
782 | 0 | } |
783 | | |
784 | | static void virtio_scsi_command_complete(SCSIRequest *r, size_t resid) |
785 | 37.9k | { |
786 | 37.9k | VirtIOSCSIReq *req = r->hba_private; |
787 | 37.9k | uint8_t sense[SCSI_SENSE_BUF_SIZE]; |
788 | 37.9k | uint32_t sense_len; |
789 | 37.9k | VirtIODevice *vdev = VIRTIO_DEVICE(req->dev); |
790 | | |
791 | 37.9k | if (r->io_canceled) { |
792 | 0 | return; |
793 | 0 | } |
794 | | |
795 | 37.9k | req->resp.cmd.response = VIRTIO_SCSI_S_OK; |
796 | 37.9k | req->resp.cmd.status = r->status; |
797 | 37.9k | if (req->resp.cmd.status == GOOD) { |
798 | 14.2k | req->resp.cmd.resid = virtio_tswap32(vdev, resid); |
799 | 23.7k | } else { |
800 | 23.7k | req->resp.cmd.resid = 0; |
801 | 23.7k | sense_len = scsi_req_get_sense(r, sense, sizeof(sense)); |
802 | 23.7k | sense_len = MIN(sense_len, req->resp_iov.size - sizeof(req->resp.cmd)); |
803 | 23.7k | qemu_iovec_from_buf(&req->resp_iov, sizeof(req->resp.cmd), |
804 | 23.7k | sense, sense_len); |
805 | 23.7k | req->resp.cmd.sense_len = virtio_tswap32(vdev, sense_len); |
806 | 23.7k | } |
807 | 37.9k | virtio_scsi_complete_cmd_req(req); |
808 | 37.9k | } |
809 | | |
810 | | static int virtio_scsi_parse_cdb(SCSIDevice *dev, SCSICommand *cmd, |
811 | | uint8_t *buf, size_t buf_len, |
812 | | void *hba_private) |
813 | 0 | { |
814 | 0 | VirtIOSCSIReq *req = hba_private; |
815 | |
|
816 | 0 | if (cmd->len == 0) { |
817 | 0 | cmd->len = MIN(VIRTIO_SCSI_CDB_DEFAULT_SIZE, SCSI_CMD_BUF_SIZE); |
818 | 0 | memcpy(cmd->buf, buf, cmd->len); |
819 | 0 | } |
820 | | |
821 | | /* Extract the direction and mode directly from the request, for |
822 | | * host device passthrough. |
823 | | */ |
824 | 0 | cmd->xfer = req->qsgl.size; |
825 | 0 | cmd->mode = req->mode; |
826 | 0 | return 0; |
827 | 0 | } |
828 | | |
829 | | static QEMUSGList *virtio_scsi_get_sg_list(SCSIRequest *r) |
830 | 39.3k | { |
831 | 39.3k | VirtIOSCSIReq *req = r->hba_private; |
832 | | |
833 | 39.3k | return &req->qsgl; |
834 | 39.3k | } |
835 | | |
836 | | static void virtio_scsi_request_cancelled(SCSIRequest *r) |
837 | 1.37k | { |
838 | 1.37k | VirtIOSCSIReq *req = r->hba_private; |
839 | | |
840 | 1.37k | if (!req) { |
841 | 0 | return; |
842 | 0 | } |
843 | 1.37k | if (qatomic_read(&req->dev->resetting)) { |
844 | 1.37k | req->resp.cmd.response = VIRTIO_SCSI_S_RESET; |
845 | 1.37k | } else { |
846 | 0 | req->resp.cmd.response = VIRTIO_SCSI_S_ABORTED; |
847 | 0 | } |
848 | 1.37k | virtio_scsi_complete_cmd_req(req); |
849 | 1.37k | } |
850 | | |
851 | | static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq *req) |
852 | 90 | { |
853 | 90 | req->resp.cmd.response = VIRTIO_SCSI_S_FAILURE; |
854 | 90 | virtio_scsi_complete_cmd_req(req); |
855 | 90 | } |
856 | | |
857 | | static int virtio_scsi_handle_cmd_req_prepare(VirtIOSCSI *s, VirtIOSCSIReq *req, |
858 | | size_t cdb_size) |
859 | 63.8k | { |
860 | 63.8k | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s); |
861 | 63.8k | SCSIDevice *d; |
862 | 63.8k | int rc; |
863 | | |
864 | 63.8k | rc = virtio_scsi_parse_req(req, sizeof(VirtIOSCSICmdReq) + cdb_size, |
865 | 63.8k | sizeof(VirtIOSCSICmdResp) + vs->sense_size); |
866 | 63.8k | if (rc < 0) { |
867 | 832 | if (rc == -ENOTSUP) { |
868 | 90 | virtio_scsi_fail_cmd_req(req); |
869 | 90 | return -ENOTSUP; |
870 | 742 | } else { |
871 | 742 | virtio_scsi_bad_req(req, NULL); |
872 | 742 | return -EINVAL; |
873 | 742 | } |
874 | 832 | } |
875 | 62.9k | trace_virtio_scsi_cmd_req(virtio_scsi_get_lun(req->req.cmd.lun), |
876 | 62.9k | req->req.cmd.tag, req->req.cmd.cdb[0]); |
877 | | |
878 | 62.9k | d = virtio_scsi_device_get(s, req->req.cmd.lun); |
879 | 62.9k | if (!d) { |
880 | 18.6k | req->resp.cmd.response = VIRTIO_SCSI_S_BAD_TARGET; |
881 | 18.6k | virtio_scsi_complete_cmd_req(req); |
882 | 18.6k | return -ENOENT; |
883 | 18.6k | } |
884 | 44.2k | req->sreq = scsi_req_new(d, req->req.cmd.tag, |
885 | 44.2k | virtio_scsi_get_lun(req->req.cmd.lun), |
886 | 44.2k | req->req.cmd.cdb, cdb_size, req); |
887 | | |
888 | 44.2k | if (req->sreq->cmd.mode != SCSI_XFER_NONE |
889 | 33.5k | && (req->sreq->cmd.mode != req->mode || |
890 | 28.6k | req->sreq->cmd.xfer > req->qsgl.size)) { |
891 | 4.91k | req->resp.cmd.response = VIRTIO_SCSI_S_OVERRUN; |
892 | 4.91k | virtio_scsi_complete_cmd_req(req); |
893 | 4.91k | object_unref(OBJECT(d)); |
894 | 4.91k | return -ENOBUFS; |
895 | 4.91k | } |
896 | 39.3k | scsi_req_ref(req->sreq); |
897 | 39.3k | defer_call_begin(); |
898 | 39.3k | object_unref(OBJECT(d)); |
899 | 39.3k | return 0; |
900 | 44.2k | } |
901 | | |
902 | | static void virtio_scsi_handle_cmd_req_submit(VirtIOSCSI *s, VirtIOSCSIReq *req) |
903 | 39.3k | { |
904 | 39.3k | SCSIRequest *sreq = req->sreq; |
905 | 39.3k | if (scsi_req_enqueue(sreq)) { |
906 | 21.1k | scsi_req_continue(sreq); |
907 | 21.1k | } |
908 | 39.3k | defer_call_end(); |
909 | 39.3k | scsi_req_unref(sreq); |
910 | 39.3k | } |
911 | | |
912 | | static void virtio_scsi_handle_cmd_vq(VirtIOSCSI *s, VirtQueue *vq) |
913 | 26.7k | { |
914 | 26.7k | VirtIOSCSIReq *req, *next; |
915 | 26.7k | int ret = 0; |
916 | 26.7k | bool suppress_notifications = virtio_queue_get_notification(vq); |
917 | | |
918 | 26.7k | QTAILQ_HEAD(, VirtIOSCSIReq) reqs = QTAILQ_HEAD_INITIALIZER(reqs); |
919 | | |
920 | 26.7k | do { |
921 | 26.7k | VirtIOSCSICommon *vs = (VirtIOSCSICommon *)s; |
922 | 26.7k | size_t cdb_size = qatomic_read(&vs->cdb_size); |
923 | | |
924 | 26.7k | if (suppress_notifications) { |
925 | 26.7k | virtio_queue_set_notification(vq, 0); |
926 | 26.7k | } |
927 | | |
928 | 90.5k | while ((req = virtio_scsi_pop_req(s, vq, cdb_size, NULL))) { |
929 | 63.8k | ret = virtio_scsi_handle_cmd_req_prepare(s, req, cdb_size); |
930 | 63.8k | if (!ret) { |
931 | 39.3k | QTAILQ_INSERT_TAIL(&reqs, req, next); |
932 | 39.3k | } else if (ret == -EINVAL) { |
933 | | /* The device is broken and shouldn't process any request */ |
934 | 742 | while (!QTAILQ_EMPTY(&reqs)) { |
935 | 0 | req = QTAILQ_FIRST(&reqs); |
936 | 0 | QTAILQ_REMOVE(&reqs, req, next); |
937 | 0 | defer_call_end(); |
938 | | /* Drop both the ref from _prepare and the initial ref */ |
939 | 0 | scsi_req_unref(req->sreq); |
940 | 0 | scsi_req_unref_detach_hba(req->sreq); |
941 | 0 | virtqueue_detach_element(req->vq, &req->elem, 0); |
942 | 0 | virtio_scsi_free_req(req); |
943 | 0 | } |
944 | 742 | } |
945 | 63.8k | } |
946 | | |
947 | 26.7k | if (suppress_notifications) { |
948 | 26.7k | virtio_queue_set_notification(vq, 1); |
949 | 26.7k | } |
950 | 26.7k | } while (ret != -EINVAL && !virtio_queue_empty(vq)); |
951 | | |
952 | 39.3k | QTAILQ_FOREACH_SAFE(req, &reqs, next, next) { |
953 | 39.3k | virtio_scsi_handle_cmd_req_submit(s, req); |
954 | 39.3k | } |
955 | 26.7k | } |
956 | | |
957 | | static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq) |
958 | 26.7k | { |
959 | | /* use non-QOM casts in the data path */ |
960 | 26.7k | VirtIOSCSI *s = (VirtIOSCSI *)vdev; |
961 | | |
962 | 26.7k | if (virtio_scsi_defer_to_dataplane(s)) { |
963 | 0 | return; |
964 | 0 | } |
965 | | |
966 | 26.7k | virtio_scsi_handle_cmd_vq(s, vq); |
967 | 26.7k | } |
968 | | |
969 | | static void virtio_scsi_get_config(VirtIODevice *vdev, |
970 | | uint8_t *config) |
971 | 7.22k | { |
972 | 7.22k | VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config; |
973 | 7.22k | VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(vdev); |
974 | | |
975 | 7.22k | virtio_stl_p(vdev, &scsiconf->num_queues, s->conf.num_queues); |
976 | 7.22k | virtio_stl_p(vdev, &scsiconf->seg_max, |
977 | 7.22k | s->conf.seg_max_adjust ? s->conf.virtqueue_size - 2 : 128 - 2); |
978 | 7.22k | virtio_stl_p(vdev, &scsiconf->max_sectors, s->conf.max_sectors); |
979 | 7.22k | virtio_stl_p(vdev, &scsiconf->cmd_per_lun, s->conf.cmd_per_lun); |
980 | 7.22k | virtio_stl_p(vdev, &scsiconf->event_info_size, sizeof(VirtIOSCSIEvent)); |
981 | 7.22k | virtio_stl_p(vdev, &scsiconf->sense_size, s->sense_size); |
982 | 7.22k | virtio_stl_p(vdev, &scsiconf->cdb_size, s->cdb_size); |
983 | 7.22k | virtio_stw_p(vdev, &scsiconf->max_channel, VIRTIO_SCSI_MAX_CHANNEL); |
984 | 7.22k | virtio_stw_p(vdev, &scsiconf->max_target, VIRTIO_SCSI_MAX_TARGET); |
985 | 7.22k | virtio_stl_p(vdev, &scsiconf->max_lun, VIRTIO_SCSI_MAX_LUN); |
986 | 7.22k | } |
987 | | |
988 | | static void virtio_scsi_set_config(VirtIODevice *vdev, |
989 | | const uint8_t *config) |
990 | 10.9k | { |
991 | 10.9k | VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config; |
992 | 10.9k | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev); |
993 | | |
994 | 10.9k | if ((uint32_t) virtio_ldl_p(vdev, &scsiconf->sense_size) >= 65536 || |
995 | 9.05k | (uint32_t) virtio_ldl_p(vdev, &scsiconf->cdb_size) >= 256) { |
996 | 3.68k | virtio_error(vdev, |
997 | 3.68k | "bad data written to virtio-scsi configuration space"); |
998 | 3.68k | return; |
999 | 3.68k | } |
1000 | | |
1001 | 7.24k | vs->sense_size = virtio_ldl_p(vdev, &scsiconf->sense_size); |
1002 | 7.24k | qatomic_set(&vs->cdb_size, virtio_ldl_p(vdev, &scsiconf->cdb_size)); |
1003 | 7.24k | } |
1004 | | |
1005 | | static uint64_t virtio_scsi_get_features(VirtIODevice *vdev, |
1006 | | uint64_t requested_features, |
1007 | | Error **errp) |
1008 | 2 | { |
1009 | 2 | VirtIOSCSI *s = VIRTIO_SCSI(vdev); |
1010 | | |
1011 | | /* Firstly sync all virtio-scsi possible supported features */ |
1012 | 2 | requested_features |= s->host_features; |
1013 | 2 | return requested_features; |
1014 | 2 | } |
1015 | | |
1016 | | static void virtio_scsi_reset(VirtIODevice *vdev) |
1017 | 59.7k | { |
1018 | 59.7k | VirtIOSCSI *s = VIRTIO_SCSI(vdev); |
1019 | 59.7k | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev); |
1020 | | |
1021 | 59.7k | assert(!s->dataplane_started); |
1022 | | |
1023 | 59.7k | virtio_scsi_flush_defer_tmf_to_aio_context(s); |
1024 | | |
1025 | 59.7k | qatomic_inc(&s->resetting); |
1026 | 59.7k | bus_cold_reset(BUS(&s->bus)); |
1027 | 59.7k | qatomic_dec(&s->resetting); |
1028 | | |
1029 | 59.7k | vs->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE; |
1030 | 59.7k | vs->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE; |
1031 | | |
1032 | 59.7k | WITH_QEMU_LOCK_GUARD(&s->event_lock) { |
1033 | 59.7k | s->events_dropped = false; |
1034 | 59.7k | } |
1035 | 59.7k | } |
1036 | | |
1037 | | typedef struct { |
1038 | | uint32_t event; |
1039 | | uint32_t reason; |
1040 | | union { |
1041 | | /* Used by messages specific to a device */ |
1042 | | struct { |
1043 | | uint32_t id; |
1044 | | uint32_t lun; |
1045 | | } address; |
1046 | | }; |
1047 | | } VirtIOSCSIEventInfo; |
1048 | | |
1049 | | static void virtio_scsi_push_event(VirtIOSCSI *s, |
1050 | | const VirtIOSCSIEventInfo *info) |
1051 | 0 | { |
1052 | 0 | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s); |
1053 | 0 | VirtIOSCSIReq *req; |
1054 | 0 | VirtIOSCSIEvent *evt; |
1055 | 0 | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
1056 | 0 | uint32_t event = info->event; |
1057 | 0 | uint32_t reason = info->reason; |
1058 | |
|
1059 | 0 | if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) { |
1060 | 0 | return; |
1061 | 0 | } |
1062 | | |
1063 | 0 | req = virtio_scsi_pop_req(s, vs->event_vq, 0, &s->event_lock); |
1064 | 0 | WITH_QEMU_LOCK_GUARD(&s->event_lock) { |
1065 | 0 | if (!req) { |
1066 | 0 | s->events_dropped = true; |
1067 | 0 | return; |
1068 | 0 | } |
1069 | | |
1070 | 0 | if (s->events_dropped) { |
1071 | 0 | event |= VIRTIO_SCSI_T_EVENTS_MISSED; |
1072 | 0 | s->events_dropped = false; |
1073 | 0 | } |
1074 | 0 | } |
1075 | | |
1076 | 0 | if (virtio_scsi_parse_req(req, 0, sizeof(VirtIOSCSIEvent))) { |
1077 | 0 | virtio_scsi_bad_req(req, &s->event_lock); |
1078 | 0 | return; |
1079 | 0 | } |
1080 | | |
1081 | 0 | evt = &req->resp.event; |
1082 | 0 | memset(evt, 0, sizeof(VirtIOSCSIEvent)); |
1083 | 0 | evt->event = virtio_tswap32(vdev, event); |
1084 | 0 | evt->reason = virtio_tswap32(vdev, reason); |
1085 | 0 | if (event != VIRTIO_SCSI_T_EVENTS_MISSED) { |
1086 | 0 | evt->lun[0] = 1; |
1087 | 0 | evt->lun[1] = info->address.id; |
1088 | | |
1089 | | /* Linux wants us to keep the same encoding we use for REPORT LUNS. */ |
1090 | 0 | if (info->address.lun >= 256) { |
1091 | 0 | evt->lun[2] = (info->address.lun >> 8) | 0x40; |
1092 | 0 | } |
1093 | 0 | evt->lun[3] = info->address.lun & 0xFF; |
1094 | 0 | } |
1095 | 0 | trace_virtio_scsi_event(virtio_scsi_get_lun(evt->lun), event, reason); |
1096 | |
|
1097 | 0 | virtio_scsi_complete_req(req, &s->event_lock); |
1098 | 0 | } |
1099 | | |
1100 | | static void virtio_scsi_handle_event_vq(VirtIOSCSI *s, VirtQueue *vq) |
1101 | 1.18k | { |
1102 | 1.18k | bool events_dropped; |
1103 | | |
1104 | 1.18k | WITH_QEMU_LOCK_GUARD(&s->event_lock) { |
1105 | 1.18k | events_dropped = s->events_dropped; |
1106 | 1.18k | } |
1107 | | |
1108 | 1.18k | if (events_dropped) { |
1109 | 0 | VirtIOSCSIEventInfo info = { |
1110 | 0 | .event = VIRTIO_SCSI_T_NO_EVENT, |
1111 | 0 | }; |
1112 | 0 | virtio_scsi_push_event(s, &info); |
1113 | 0 | } |
1114 | 1.18k | } |
1115 | | |
1116 | | static void virtio_scsi_handle_event(VirtIODevice *vdev, VirtQueue *vq) |
1117 | 1.18k | { |
1118 | 1.18k | VirtIOSCSI *s = VIRTIO_SCSI(vdev); |
1119 | | |
1120 | 1.18k | if (virtio_scsi_defer_to_dataplane(s)) { |
1121 | 0 | return; |
1122 | 0 | } |
1123 | | |
1124 | 1.18k | virtio_scsi_handle_event_vq(s, vq); |
1125 | 1.18k | } |
1126 | | |
1127 | | static void virtio_scsi_change(SCSIBus *bus, SCSIDevice *dev, SCSISense sense) |
1128 | 0 | { |
1129 | 0 | VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus); |
1130 | 0 | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
1131 | |
|
1132 | 0 | if (virtio_vdev_has_feature(vdev, VIRTIO_SCSI_F_CHANGE) && |
1133 | 0 | dev->type != TYPE_ROM) { |
1134 | 0 | VirtIOSCSIEventInfo info = { |
1135 | 0 | .event = VIRTIO_SCSI_T_PARAM_CHANGE, |
1136 | 0 | .reason = sense.asc | (sense.ascq << 8), |
1137 | 0 | .address = { |
1138 | 0 | .id = dev->id, |
1139 | 0 | .lun = dev->lun, |
1140 | 0 | }, |
1141 | 0 | }; |
1142 | |
|
1143 | 0 | virtio_scsi_push_event(s, &info); |
1144 | 0 | } |
1145 | 0 | } |
1146 | | |
1147 | | static void virtio_scsi_pre_hotplug(const HotplugHandler *hotplug_dev, |
1148 | | DeviceState *dev, Error **errp) |
1149 | 2 | { |
1150 | 2 | SCSIDevice *sd = SCSI_DEVICE(dev); |
1151 | 2 | sd->hba_supports_iothread = true; |
1152 | 2 | } |
1153 | | |
1154 | | static void virtio_scsi_hotplug(const HotplugHandler *hotplug_dev, DeviceState *dev, |
1155 | | Error **errp) |
1156 | 2 | { |
1157 | 2 | VirtIODevice *vdev = VIRTIO_DEVICE(hotplug_dev); |
1158 | 2 | VirtIOSCSI *s = VIRTIO_SCSI(vdev); |
1159 | 2 | AioContext *ctx = s->vq_aio_context[VIRTIO_SCSI_VQ_NUM_FIXED]; |
1160 | 2 | SCSIDevice *sd = SCSI_DEVICE(dev); |
1161 | | |
1162 | 2 | if (ctx != qemu_get_aio_context() && !s->dataplane_fenced) { |
1163 | | /* |
1164 | | * Try to make the BlockBackend's AioContext match ours. Ignore failure |
1165 | | * because I/O will still work although block jobs and other users |
1166 | | * might be slower when multiple AioContexts use a BlockBackend. |
1167 | | */ |
1168 | 0 | blk_set_aio_context(sd->conf.blk, ctx, NULL); |
1169 | 0 | } |
1170 | | |
1171 | 2 | if (virtio_vdev_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG)) { |
1172 | 0 | VirtIOSCSIEventInfo info = { |
1173 | 0 | .event = VIRTIO_SCSI_T_TRANSPORT_RESET, |
1174 | 0 | .reason = VIRTIO_SCSI_EVT_RESET_RESCAN, |
1175 | 0 | .address = { |
1176 | 0 | .id = sd->id, |
1177 | 0 | .lun = sd->lun, |
1178 | 0 | }, |
1179 | 0 | }; |
1180 | |
|
1181 | 0 | virtio_scsi_push_event(s, &info); |
1182 | 0 | scsi_bus_set_ua(&s->bus, SENSE_CODE(REPORTED_LUNS_CHANGED)); |
1183 | 0 | } |
1184 | 2 | } |
1185 | | |
1186 | | static void virtio_scsi_hotunplug(const HotplugHandler *hotplug_dev, DeviceState *dev, |
1187 | | Error **errp) |
1188 | 0 | { |
1189 | 0 | VirtIODevice *vdev = VIRTIO_DEVICE(hotplug_dev); |
1190 | 0 | VirtIOSCSI *s = VIRTIO_SCSI(vdev); |
1191 | 0 | SCSIDevice *sd = SCSI_DEVICE(dev); |
1192 | 0 | VirtIOSCSIEventInfo info = { |
1193 | 0 | .event = VIRTIO_SCSI_T_TRANSPORT_RESET, |
1194 | 0 | .reason = VIRTIO_SCSI_EVT_RESET_REMOVED, |
1195 | 0 | .address = { |
1196 | 0 | .id = sd->id, |
1197 | 0 | .lun = sd->lun, |
1198 | 0 | }, |
1199 | 0 | }; |
1200 | |
|
1201 | 0 | qdev_simple_device_unplug_cb(hotplug_dev, dev, errp); |
1202 | |
|
1203 | 0 | if (s->vq_aio_context[VIRTIO_SCSI_VQ_NUM_FIXED] != qemu_get_aio_context()) { |
1204 | | /* If other users keep the BlockBackend in the iothread, that's ok */ |
1205 | 0 | blk_set_aio_context(sd->conf.blk, qemu_get_aio_context(), NULL); |
1206 | 0 | } |
1207 | |
|
1208 | 0 | if (virtio_vdev_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG)) { |
1209 | 0 | virtio_scsi_push_event(s, &info); |
1210 | 0 | scsi_bus_set_ua(&s->bus, SENSE_CODE(REPORTED_LUNS_CHANGED)); |
1211 | 0 | } |
1212 | 0 | } |
1213 | | |
1214 | | /* Suspend virtqueue ioeventfd processing during drain */ |
1215 | | static void virtio_scsi_drained_begin(SCSIBus *bus) |
1216 | 109k | { |
1217 | 109k | VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus); |
1218 | 109k | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
1219 | 109k | uint32_t total_queues = VIRTIO_SCSI_VQ_NUM_FIXED + |
1220 | 109k | s->parent_obj.conf.num_queues; |
1221 | | |
1222 | | /* |
1223 | | * Drain is called when stopping dataplane but the host notifier has |
1224 | | * already been detached. Detaching multiple times is a no-op if nothing |
1225 | | * else is using the monitoring same file descriptor, but avoid it just in |
1226 | | * case. |
1227 | | * |
1228 | | * Also, don't detach if dataplane has not even been started yet because |
1229 | | * the host notifier isn't attached. |
1230 | | */ |
1231 | 109k | if (s->dataplane_stopping || !s->dataplane_started) { |
1232 | 108k | return; |
1233 | 108k | } |
1234 | | |
1235 | 2.55k | for (uint32_t i = 0; i < total_queues; i++) { |
1236 | 2.32k | VirtQueue *vq = virtio_get_queue(vdev, i); |
1237 | 2.32k | virtio_queue_aio_detach_host_notifier(vq, s->vq_aio_context[i]); |
1238 | 2.32k | } |
1239 | 232 | } |
1240 | | |
1241 | | /* Resume virtqueue ioeventfd processing after drain */ |
1242 | | static void virtio_scsi_drained_end(SCSIBus *bus) |
1243 | 109k | { |
1244 | 109k | VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus); |
1245 | 109k | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s); |
1246 | 109k | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
1247 | 109k | uint32_t total_queues = VIRTIO_SCSI_VQ_NUM_FIXED + |
1248 | 109k | s->parent_obj.conf.num_queues; |
1249 | | |
1250 | | /* |
1251 | | * Drain is called when stopping dataplane. Keep the host notifier detached |
1252 | | * so it's not left dangling after dataplane is stopped. |
1253 | | * |
1254 | | * Also, don't attach if dataplane has not even been started yet. We're not |
1255 | | * ready. |
1256 | | */ |
1257 | 109k | if (s->dataplane_stopping || !s->dataplane_started) { |
1258 | 108k | return; |
1259 | 108k | } |
1260 | | |
1261 | 2.55k | for (uint32_t i = 0; i < total_queues; i++) { |
1262 | 2.32k | VirtQueue *vq = virtio_get_queue(vdev, i); |
1263 | 2.32k | AioContext *ctx = s->vq_aio_context[i]; |
1264 | | |
1265 | 2.32k | if (vq == vs->event_vq) { |
1266 | 232 | virtio_queue_aio_attach_host_notifier_no_poll(vq, ctx); |
1267 | 2.08k | } else { |
1268 | 2.08k | virtio_queue_aio_attach_host_notifier(vq, ctx); |
1269 | 2.08k | } |
1270 | 2.32k | } |
1271 | 232 | } |
1272 | | |
1273 | | static struct SCSIBusInfo virtio_scsi_scsi_info = { |
1274 | | .tcq = true, |
1275 | | .max_channel = VIRTIO_SCSI_MAX_CHANNEL, |
1276 | | .max_target = VIRTIO_SCSI_MAX_TARGET, |
1277 | | .max_lun = VIRTIO_SCSI_MAX_LUN, |
1278 | | |
1279 | | .complete = virtio_scsi_command_complete, |
1280 | | .fail = virtio_scsi_command_failed, |
1281 | | .cancel = virtio_scsi_request_cancelled, |
1282 | | .change = virtio_scsi_change, |
1283 | | .parse_cdb = virtio_scsi_parse_cdb, |
1284 | | .get_sg_list = virtio_scsi_get_sg_list, |
1285 | | .save_request = virtio_scsi_save_request, |
1286 | | .load_request = virtio_scsi_load_request, |
1287 | | .drained_begin = virtio_scsi_drained_begin, |
1288 | | .drained_end = virtio_scsi_drained_end, |
1289 | | }; |
1290 | | |
1291 | | void virtio_scsi_common_realize(DeviceState *dev, |
1292 | | VirtIOHandleOutput ctrl, |
1293 | | VirtIOHandleOutput evt, |
1294 | | VirtIOHandleOutput cmd, |
1295 | | Error **errp) |
1296 | 2 | { |
1297 | 2 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); |
1298 | 2 | VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(dev); |
1299 | 2 | int i; |
1300 | | |
1301 | 2 | virtio_init(vdev, VIRTIO_ID_SCSI, sizeof(VirtIOSCSIConfig)); |
1302 | | |
1303 | 2 | if (s->conf.num_queues == VIRTIO_SCSI_AUTO_NUM_QUEUES) { |
1304 | 0 | s->conf.num_queues = 1; |
1305 | 0 | } |
1306 | 2 | if (s->conf.num_queues == 0 || |
1307 | 2 | s->conf.num_queues > VIRTIO_QUEUE_MAX - VIRTIO_SCSI_VQ_NUM_FIXED) { |
1308 | 0 | error_setg(errp, "Invalid number of queues (= %" PRIu32 "), " |
1309 | 0 | "must be a positive integer less than %d.", |
1310 | 0 | s->conf.num_queues, |
1311 | 0 | VIRTIO_QUEUE_MAX - VIRTIO_SCSI_VQ_NUM_FIXED); |
1312 | 0 | virtio_cleanup(vdev); |
1313 | 0 | return; |
1314 | 0 | } |
1315 | 2 | if (s->conf.virtqueue_size <= 2) { |
1316 | 0 | error_setg(errp, "invalid virtqueue_size property (= %" PRIu32 "), " |
1317 | 0 | "must be > 2", s->conf.virtqueue_size); |
1318 | 0 | return; |
1319 | 0 | } |
1320 | 2 | s->cmd_vqs = g_new0(VirtQueue *, s->conf.num_queues); |
1321 | 2 | s->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE; |
1322 | 2 | s->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE; |
1323 | | |
1324 | 2 | s->ctrl_vq = virtio_add_queue(vdev, s->conf.virtqueue_size, ctrl); |
1325 | 2 | s->event_vq = virtio_add_queue(vdev, s->conf.virtqueue_size, evt); |
1326 | 18 | for (i = 0; i < s->conf.num_queues; i++) { |
1327 | 16 | s->cmd_vqs[i] = virtio_add_queue(vdev, s->conf.virtqueue_size, cmd); |
1328 | 16 | } |
1329 | 2 | } |
1330 | | |
1331 | | static void virtio_scsi_device_realize(DeviceState *dev, Error **errp) |
1332 | 2 | { |
1333 | 2 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); |
1334 | 2 | VirtIOSCSI *s = VIRTIO_SCSI(dev); |
1335 | 2 | Error *err = NULL; |
1336 | | |
1337 | 2 | qemu_mutex_init(&s->ctrl_lock); |
1338 | 2 | qemu_mutex_init(&s->event_lock); |
1339 | | |
1340 | 2 | virtio_scsi_common_realize(dev, |
1341 | 2 | virtio_scsi_handle_ctrl, |
1342 | 2 | virtio_scsi_handle_event, |
1343 | 2 | virtio_scsi_handle_cmd, |
1344 | 2 | &err); |
1345 | 2 | if (err != NULL) { |
1346 | 0 | error_propagate(errp, err); |
1347 | 0 | return; |
1348 | 0 | } |
1349 | | |
1350 | 2 | scsi_bus_init_named(&s->bus, sizeof(s->bus), dev, |
1351 | 2 | &virtio_scsi_scsi_info, vdev->bus_name); |
1352 | | /* override default SCSI bus hotplug-handler, with virtio-scsi's one */ |
1353 | 2 | qbus_set_hotplug_handler(BUS(&s->bus), OBJECT(dev)); |
1354 | | |
1355 | 2 | virtio_scsi_dataplane_setup(s, errp); |
1356 | 2 | } |
1357 | | |
1358 | | void virtio_scsi_common_unrealize(DeviceState *dev) |
1359 | 0 | { |
1360 | 0 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); |
1361 | 0 | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(dev); |
1362 | 0 | int i; |
1363 | |
|
1364 | 0 | virtio_delete_queue(vs->ctrl_vq); |
1365 | 0 | virtio_delete_queue(vs->event_vq); |
1366 | 0 | for (i = 0; i < vs->conf.num_queues; i++) { |
1367 | 0 | virtio_delete_queue(vs->cmd_vqs[i]); |
1368 | 0 | } |
1369 | 0 | g_free(vs->cmd_vqs); |
1370 | 0 | virtio_cleanup(vdev); |
1371 | 0 | } |
1372 | | |
1373 | | /* main loop */ |
1374 | | static void virtio_scsi_device_unrealize(DeviceState *dev) |
1375 | 0 | { |
1376 | 0 | VirtIOSCSI *s = VIRTIO_SCSI(dev); |
1377 | |
|
1378 | 0 | virtio_scsi_dataplane_cleanup(s); |
1379 | 0 | qbus_set_hotplug_handler(BUS(&s->bus), NULL); |
1380 | 0 | virtio_scsi_common_unrealize(dev); |
1381 | 0 | qemu_mutex_destroy(&s->event_lock); |
1382 | 0 | qemu_mutex_destroy(&s->ctrl_lock); |
1383 | 0 | } |
1384 | | |
1385 | | static const Property virtio_scsi_properties[] = { |
1386 | | DEFINE_PROP_UINT32("num_queues", VirtIOSCSI, parent_obj.conf.num_queues, |
1387 | | VIRTIO_SCSI_AUTO_NUM_QUEUES), |
1388 | | DEFINE_PROP_UINT32("virtqueue_size", VirtIOSCSI, |
1389 | | parent_obj.conf.virtqueue_size, 256), |
1390 | | DEFINE_PROP_BOOL("seg_max_adjust", VirtIOSCSI, |
1391 | | parent_obj.conf.seg_max_adjust, true), |
1392 | | DEFINE_PROP_UINT32("max_sectors", VirtIOSCSI, parent_obj.conf.max_sectors, |
1393 | | 0xFFFF), |
1394 | | DEFINE_PROP_UINT32("cmd_per_lun", VirtIOSCSI, parent_obj.conf.cmd_per_lun, |
1395 | | 128), |
1396 | | DEFINE_PROP_BIT("hotplug", VirtIOSCSI, host_features, |
1397 | | VIRTIO_SCSI_F_HOTPLUG, true), |
1398 | | DEFINE_PROP_BIT("param_change", VirtIOSCSI, host_features, |
1399 | | VIRTIO_SCSI_F_CHANGE, true), |
1400 | | DEFINE_PROP_LINK("iothread", VirtIOSCSI, parent_obj.conf.iothread, |
1401 | | TYPE_IOTHREAD, IOThread *), |
1402 | | DEFINE_PROP_IOTHREAD_VQ_MAPPING_LIST("iothread-vq-mapping", VirtIOSCSI, |
1403 | | parent_obj.conf.iothread_vq_mapping_list), |
1404 | | }; |
1405 | | |
1406 | | static const VMStateDescription vmstate_virtio_scsi = { |
1407 | | .name = "virtio-scsi", |
1408 | | .minimum_version_id = 1, |
1409 | | .version_id = 1, |
1410 | | .fields = (const VMStateField[]) { |
1411 | | VMSTATE_VIRTIO_DEVICE, |
1412 | | VMSTATE_END_OF_LIST() |
1413 | | }, |
1414 | | }; |
1415 | | |
1416 | | static void virtio_scsi_common_class_init(ObjectClass *klass, const void *data) |
1417 | 63 | { |
1418 | 63 | VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); |
1419 | 63 | DeviceClass *dc = DEVICE_CLASS(klass); |
1420 | | |
1421 | 63 | vdc->get_config = virtio_scsi_get_config; |
1422 | 63 | set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); |
1423 | 63 | } |
1424 | | |
1425 | | static void virtio_scsi_class_init(ObjectClass *klass, const void *data) |
1426 | 63 | { |
1427 | 63 | DeviceClass *dc = DEVICE_CLASS(klass); |
1428 | 63 | VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); |
1429 | 63 | HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass); |
1430 | | |
1431 | 63 | device_class_set_props(dc, virtio_scsi_properties); |
1432 | 63 | dc->vmsd = &vmstate_virtio_scsi; |
1433 | 63 | set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); |
1434 | 63 | vdc->realize = virtio_scsi_device_realize; |
1435 | 63 | vdc->unrealize = virtio_scsi_device_unrealize; |
1436 | 63 | vdc->set_config = virtio_scsi_set_config; |
1437 | 63 | vdc->get_features = virtio_scsi_get_features; |
1438 | 63 | vdc->reset = virtio_scsi_reset; |
1439 | 63 | vdc->start_ioeventfd = virtio_scsi_dataplane_start; |
1440 | 63 | vdc->stop_ioeventfd = virtio_scsi_dataplane_stop; |
1441 | 63 | hc->pre_plug = virtio_scsi_pre_hotplug; |
1442 | 63 | hc->plug = virtio_scsi_hotplug; |
1443 | 63 | hc->unplug = virtio_scsi_hotunplug; |
1444 | 63 | } |
1445 | | |
1446 | | static const TypeInfo virtio_scsi_common_info = { |
1447 | | .name = TYPE_VIRTIO_SCSI_COMMON, |
1448 | | .parent = TYPE_VIRTIO_DEVICE, |
1449 | | .instance_size = sizeof(VirtIOSCSICommon), |
1450 | | .abstract = true, |
1451 | | .class_init = virtio_scsi_common_class_init, |
1452 | | }; |
1453 | | |
1454 | | static const TypeInfo virtio_scsi_info = { |
1455 | | .name = TYPE_VIRTIO_SCSI, |
1456 | | .parent = TYPE_VIRTIO_SCSI_COMMON, |
1457 | | .instance_size = sizeof(VirtIOSCSI), |
1458 | | .class_init = virtio_scsi_class_init, |
1459 | | .secure = true, |
1460 | | .interfaces = (const InterfaceInfo[]) { |
1461 | | { TYPE_HOTPLUG_HANDLER }, |
1462 | | { } |
1463 | | } |
1464 | | }; |
1465 | | |
1466 | | static void virtio_register_types(void) |
1467 | 63 | { |
1468 | 63 | type_register_static(&virtio_scsi_common_info); |
1469 | 63 | type_register_static(&virtio_scsi_info); |
1470 | 63 | } |
1471 | | |
1472 | | type_init(virtio_register_types) |