Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/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, &notifier->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)