?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qtest: fix 32-bit build
[qemu/cris-port.git] / hw / scsi-bus.c
blob8e76c5d32c99af013d9a5db265629b2090ed873a
1 #include "hw.h"
2 #include "qemu-error.h"
3 #include "scsi.h"
4 #include "scsi-defs.h"
5 #include "qdev.h"
6 #include "blockdev.h"
7 #include "trace.h"
8 #include "dma.h"
9
10 static char *scsibus_get_dev_path(DeviceState *dev);
11 static char *scsibus_get_fw_dev_path(DeviceState *dev);
12 static int scsi_req_parse(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf);
13 static void scsi_req_dequeue(SCSIRequest *req);
14
15 static struct BusInfo scsi_bus_info = {
16 .name = "SCSI",
17 .size = sizeof(SCSIBus),
18 .get_dev_path = scsibus_get_dev_path,
19 .get_fw_dev_path = scsibus_get_fw_dev_path,
20 .props = (Property[]) {
21 DEFINE_PROP_UINT32("channel", SCSIDevice, channel, 0),
22 DEFINE_PROP_UINT32("scsi-id", SCSIDevice, id, -1),
23 DEFINE_PROP_UINT32("lun", SCSIDevice, lun, -1),
24 DEFINE_PROP_END_OF_LIST(),
25 },
26 };
27 static int next_scsi_bus;
28
29 static int scsi_device_init(SCSIDevice *s)
30 {
31 SCSIDeviceClass *sc = SCSI_DEVICE_GET_CLASS(s);
32 if (sc->init) {
33 return sc->init(s);
34 }
35 return 0;
36 }
37
38 static void scsi_device_destroy(SCSIDevice *s)
39 {
40 SCSIDeviceClass *sc = SCSI_DEVICE_GET_CLASS(s);
41 if (sc->destroy) {
42 sc->destroy(s);
43 }
44 }
45
46 static SCSIRequest *scsi_device_alloc_req(SCSIDevice *s, uint32_t tag, uint32_t lun,
47 uint8_t *buf, void *hba_private)
48 {
49 SCSIDeviceClass *sc = SCSI_DEVICE_GET_CLASS(s);
50 if (sc->alloc_req) {
51 return sc->alloc_req(s, tag, lun, buf, hba_private);
52 }
53
54 return NULL;
55 }
56
57 static void scsi_device_unit_attention_reported(SCSIDevice *s)
58 {
59 SCSIDeviceClass *sc = SCSI_DEVICE_GET_CLASS(s);
60 if (sc->unit_attention_reported) {
61 sc->unit_attention_reported(s);
62 }
63 }
64
65 /* Create a scsi bus, and attach devices to it. */
66 void scsi_bus_new(SCSIBus *bus, DeviceState *host, const SCSIBusInfo *info)
67 {
68 qbus_create_inplace(&bus->qbus, &scsi_bus_info, host, NULL);
69 bus->busnr = next_scsi_bus++;
70 bus->info = info;
71 bus->qbus.allow_hotplug = 1;
72 }
73
74 static void scsi_dma_restart_bh(void *opaque)
75 {
76 SCSIDevice *s = opaque;
77 SCSIRequest *req, *next;
78
79 qemu_bh_delete(s->bh);
80 s->bh = NULL;
81
82 QTAILQ_FOREACH_SAFE(req, &s->requests, next, next) {
83 scsi_req_ref(req);
84 if (req->retry) {
85 req->retry = false;
86 switch (req->cmd.mode) {
87 case SCSI_XFER_FROM_DEV:
88 case SCSI_XFER_TO_DEV:
89 scsi_req_continue(req);
90 break;
91 case SCSI_XFER_NONE:
92 assert(!req->sg);
93 scsi_req_dequeue(req);
94 scsi_req_enqueue(req);
95 break;
96 }
97 }
98 scsi_req_unref(req);
99 }
100 }
101
102 void scsi_req_retry(SCSIRequest *req)
103 {
104 /* No need to save a reference, because scsi_dma_restart_bh just
105 * looks at the request list. */
106 req->retry = true;
107 }
108
109 static void scsi_dma_restart_cb(void *opaque, int running, RunState state)
110 {
111 SCSIDevice *s = opaque;
112
113 if (!running) {
114 return;
115 }
116 if (!s->bh) {
117 s->bh = qemu_bh_new(scsi_dma_restart_bh, s);
118 qemu_bh_schedule(s->bh);
119 }
120 }
121
122 static int scsi_qdev_init(DeviceState *qdev)
123 {
124 SCSIDevice *dev = SCSI_DEVICE(qdev);
125 SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus);
126 SCSIDevice *d;
127 int rc = -1;
128
129 if (dev->channel > bus->info->max_channel) {
130 error_report("bad scsi channel id: %d", dev->channel);
131 goto err;
132 }
133 if (dev->id != -1 && dev->id > bus->info->max_target) {
134 error_report("bad scsi device id: %d", dev->id);
135 goto err;
136 }
137 if (dev->lun != -1 && dev->lun > bus->info->max_lun) {
138 error_report("bad scsi device lun: %d", dev->lun);
139 goto err;
140 }
141
142 if (dev->id == -1) {
143 int id = -1;
144 if (dev->lun == -1) {
145 dev->lun = 0;
146 }
147 do {
148 d = scsi_device_find(bus, dev->channel, ++id, dev->lun);
149 } while (d && d->lun == dev->lun && id < bus->info->max_target);
150 if (d && d->lun == dev->lun) {
151 error_report("no free target");
152 goto err;
153 }
154 dev->id = id;
155 } else if (dev->lun == -1) {
156 int lun = -1;
157 do {
158 d = scsi_device_find(bus, dev->channel, dev->id, ++lun);
159 } while (d && d->lun == lun && lun < bus->info->max_lun);
160 if (d && d->lun == lun) {
161 error_report("no free lun");
162 goto err;
163 }
164 dev->lun = lun;
165 } else {
166 d = scsi_device_find(bus, dev->channel, dev->id, dev->lun);
167 assert(d);
168 if (d->lun == dev->lun && dev != d) {
169 qdev_free(&d->qdev);
170 }
171 }
172
173 QTAILQ_INIT(&dev->requests);
174 rc = scsi_device_init(dev);
175 if (rc == 0) {
176 dev->vmsentry = qemu_add_vm_change_state_handler(scsi_dma_restart_cb,
177 dev);
178 }
179
180 err:
181 return rc;
182 }
183
184 static int scsi_qdev_exit(DeviceState *qdev)
185 {
186 SCSIDevice *dev = SCSI_DEVICE(qdev);
187
188 if (dev->vmsentry) {
189 qemu_del_vm_change_state_handler(dev->vmsentry);
190 }
191 scsi_device_destroy(dev);
192 return 0;
193 }
194
195 /* handle legacy '-drive if=scsi,...' cmd line args */
196 SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv,
197 int unit, bool removable, int bootindex)
198 {
199 const char *driver;
200 DeviceState *dev;
201
202 driver = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk";
203 dev = qdev_create(&bus->qbus, driver);
204 qdev_prop_set_uint32(dev, "scsi-id", unit);
205 if (bootindex >= 0) {
206 qdev_prop_set_int32(dev, "bootindex", bootindex);
207 }
208 if (qdev_prop_exists(dev, "removable")) {
209 qdev_prop_set_bit(dev, "removable", removable);
210 }
211 if (qdev_prop_set_drive(dev, "drive", bdrv) < 0) {
212 qdev_free(dev);
213 return NULL;
214 }
215 if (qdev_init(dev) < 0)
216 return NULL;
217 return SCSI_DEVICE(dev);
218 }
219
220 int scsi_bus_legacy_handle_cmdline(SCSIBus *bus)
221 {
222 Location loc;
223 DriveInfo *dinfo;
224 int res = 0, unit;
225
226 loc_push_none(&loc);
227 for (unit = 0; unit <= bus->info->max_target; unit++) {
228 dinfo = drive_get(IF_SCSI, bus->busnr, unit);
229 if (dinfo == NULL) {
230 continue;
231 }
232 qemu_opts_loc_restore(dinfo->opts);
233 if (!scsi_bus_legacy_add_drive(bus, dinfo->bdrv, unit, false, -1)) {
234 res = -1;
235 break;
236 }
237 }
238 loc_pop(&loc);
239 return res;
240 }
241
242 /* SCSIReqOps implementation for invalid commands. */
243
244 static int32_t scsi_invalid_command(SCSIRequest *req, uint8_t *buf)
245 {
246 scsi_req_build_sense(req, SENSE_CODE(INVALID_OPCODE));
247 scsi_req_complete(req, CHECK_CONDITION);
248 return 0;
249 }
250
251 static const struct SCSIReqOps reqops_invalid_opcode = {
252 .size = sizeof(SCSIRequest),
253 .send_command = scsi_invalid_command
254 };
255
256 /* SCSIReqOps implementation for unit attention conditions. */
257
258 static int32_t scsi_unit_attention(SCSIRequest *req, uint8_t *buf)
259 {
260 if (req->dev && req->dev->unit_attention.key == UNIT_ATTENTION) {
261 scsi_req_build_sense(req, req->dev->unit_attention);
262 } else if (req->bus->unit_attention.key == UNIT_ATTENTION) {
263 scsi_req_build_sense(req, req->bus->unit_attention);
264 }
265 scsi_req_complete(req, CHECK_CONDITION);
266 return 0;
267 }
268
269 static const struct SCSIReqOps reqops_unit_attention = {
270 .size = sizeof(SCSIRequest),
271 .send_command = scsi_unit_attention
272 };
273
274 /* SCSIReqOps implementation for REPORT LUNS and for commands sent to
275 an invalid LUN. */
276
277 typedef struct SCSITargetReq SCSITargetReq;
278
279 struct SCSITargetReq {
280 SCSIRequest req;
281 int len;
282 uint8_t buf[2056];
283 };
284
285 static void store_lun(uint8_t *outbuf, int lun)
286 {
287 if (lun < 256) {
288 outbuf[1] = lun;
289 return;
290 }
291 outbuf[1] = (lun & 255);
292 outbuf[0] = (lun >> 8) | 0x40;
293 }
294
295 static bool scsi_target_emulate_report_luns(SCSITargetReq *r)
296 {
297 DeviceState *qdev;
298 int i, len, n;
299 int channel, id;
300 bool found_lun0;
301
302 if (r->req.cmd.xfer < 16) {
303 return false;
304 }
305 if (r->req.cmd.buf[2] > 2) {
306 return false;
307 }
308 channel = r->req.dev->channel;
309 id = r->req.dev->id;
310 found_lun0 = false;
311 n = 0;
312 QTAILQ_FOREACH(qdev, &r->req.bus->qbus.children, sibling) {
313 SCSIDevice *dev = SCSI_DEVICE(qdev);
314
315 if (dev->channel == channel && dev->id == id) {
316 if (dev->lun == 0) {
317 found_lun0 = true;
318 }
319 n += 8;
320 }
321 }
322 if (!found_lun0) {
323 n += 8;
324 }
325 len = MIN(n + 8, r->req.cmd.xfer & ~7);
326 if (len > sizeof(r->buf)) {
327 /* TODO: > 256 LUNs? */
328 return false;
329 }
330
331 memset(r->buf, 0, len);
332 stl_be_p(&r->buf, n);
333 i = found_lun0 ? 8 : 16;
334 QTAILQ_FOREACH(qdev, &r->req.bus->qbus.children, sibling) {
335 SCSIDevice *dev = SCSI_DEVICE(qdev);
336
337 if (dev->channel == channel && dev->id == id) {
338 store_lun(&r->buf[i], dev->lun);
339 i += 8;
340 }
341 }
342 assert(i == n + 8);
343 r->len = len;
344 return true;
345 }
346
347 static bool scsi_target_emulate_inquiry(SCSITargetReq *r)
348 {
349 assert(r->req.dev->lun != r->req.lun);
350 if (r->req.cmd.buf[1] & 0x2) {
351 /* Command support data - optional, not implemented */
352 return false;
353 }
354
355 if (r->req.cmd.buf[1] & 0x1) {
356 /* Vital product data */
357 uint8_t page_code = r->req.cmd.buf[2];
358 if (r->req.cmd.xfer < 4) {
359 return false;
360 }
361
362 r->buf[r->len++] = page_code ; /* this page */
363 r->buf[r->len++] = 0x00;
364
365 switch (page_code) {
366 case 0x00: /* Supported page codes, mandatory */
367 {
368 int pages;
369 pages = r->len++;
370 r->buf[r->len++] = 0x00; /* list of supported pages (this page) */
371 r->buf[pages] = r->len - pages - 1; /* number of pages */
372 break;
373 }
374 default:
375 return false;
376 }
377 /* done with EVPD */
378 assert(r->len < sizeof(r->buf));
379 r->len = MIN(r->req.cmd.xfer, r->len);
380 return true;
381 }
382
383 /* Standard INQUIRY data */
384 if (r->req.cmd.buf[2] != 0) {
385 return false;
386 }
387
388 /* PAGE CODE == 0 */
389 if (r->req.cmd.xfer < 5) {
390 return false;
391 }
392
393 r->len = MIN(r->req.cmd.xfer, 36);
394 memset(r->buf, 0, r->len);
395 if (r->req.lun != 0) {
396 r->buf[0] = TYPE_NO_LUN;
397 } else {
398 r->buf[0] = TYPE_NOT_PRESENT | TYPE_INACTIVE;
399 r->buf[2] = 5; /* Version */
400 r->buf[3] = 2 | 0x10; /* HiSup, response data format */
401 r->buf[4] = r->len - 5; /* Additional Length = (Len - 1) - 4 */
402 r->buf[7] = 0x10 | (r->req.bus->info->tcq ? 0x02 : 0); /* Sync, TCQ. */
403 memcpy(&r->buf[8], "QEMU ", 8);
404 memcpy(&r->buf[16], "QEMU TARGET ", 16);
405 strncpy((char *) &r->buf[32], QEMU_VERSION, 4);
406 }
407 return true;
408 }
409
410 static int32_t scsi_target_send_command(SCSIRequest *req, uint8_t *buf)
411 {
412 SCSITargetReq *r = DO_UPCAST(SCSITargetReq, req, req);
413
414 switch (buf[0]) {
415 case REPORT_LUNS:
416 if (!scsi_target_emulate_report_luns(r)) {
417 goto illegal_request;
418 }
419 break;
420 case INQUIRY:
421 if (!scsi_target_emulate_inquiry(r)) {
422 goto illegal_request;
423 }
424 break;
425 case REQUEST_SENSE:
426 if (req->cmd.xfer < 4) {
427 goto illegal_request;
428 }
429 r->len = scsi_device_get_sense(r->req.dev, r->buf,
430 MIN(req->cmd.xfer, sizeof r->buf),
431 (req->cmd.buf[1] & 1) == 0);
432 if (r->req.dev->sense_is_ua) {
433 scsi_device_unit_attention_reported(req->dev);
434 r->req.dev->sense_len = 0;
435 r->req.dev->sense_is_ua = false;
436 }
437 break;
438 default:
439 scsi_req_build_sense(req, SENSE_CODE(LUN_NOT_SUPPORTED));
440 scsi_req_complete(req, CHECK_CONDITION);
441 return 0;
442 illegal_request:
443 scsi_req_build_sense(req, SENSE_CODE(INVALID_FIELD));
444 scsi_req_complete(req, CHECK_CONDITION);
445 return 0;
446 }
447
448 if (!r->len) {
449 scsi_req_complete(req, GOOD);
450 }
451 return r->len;
452 }
453
454 static void scsi_target_read_data(SCSIRequest *req)
455 {
456 SCSITargetReq *r = DO_UPCAST(SCSITargetReq, req, req);
457 uint32_t n;
458
459 n = r->len;
460 if (n > 0) {
461 r->len = 0;
462 scsi_req_data(&r->req, n);
463 } else {
464 scsi_req_complete(&r->req, GOOD);
465 }
466 }
467
468 static uint8_t *scsi_target_get_buf(SCSIRequest *req)
469 {
470 SCSITargetReq *r = DO_UPCAST(SCSITargetReq, req, req);
471
472 return r->buf;
473 }
474
475 static const struct SCSIReqOps reqops_target_command = {
476 .size = sizeof(SCSITargetReq),
477 .send_command = scsi_target_send_command,
478 .read_data = scsi_target_read_data,
479 .get_buf = scsi_target_get_buf,
480 };
481
482
483 SCSIRequest *scsi_req_alloc(const SCSIReqOps *reqops, SCSIDevice *d,
484 uint32_t tag, uint32_t lun, void *hba_private)
485 {
486 SCSIRequest *req;
487
488 req = g_malloc0(reqops->size);
489 req->refcount = 1;
490 req->bus = scsi_bus_from_device(d);
491 req->dev = d;
492 req->tag = tag;
493 req->lun = lun;
494 req->hba_private = hba_private;
495 req->status = -1;
496 req->sense_len = 0;
497 req->ops = reqops;
498 trace_scsi_req_alloc(req->dev->id, req->lun, req->tag);
499 return req;
500 }
501
502 SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag, uint32_t lun,
503 uint8_t *buf, void *hba_private)
504 {
505 SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, d->qdev.parent_bus);
506 SCSIRequest *req;
507 SCSICommand cmd;
508
509 if (scsi_req_parse(&cmd, d, buf) != 0) {
510 trace_scsi_req_parse_bad(d->id, lun, tag, buf[0]);
511 req = scsi_req_alloc(&reqops_invalid_opcode, d, tag, lun, hba_private);
512 } else {
513 trace_scsi_req_parsed(d->id, lun, tag, buf[0],
514 cmd.mode, cmd.xfer);
515 if (cmd.lba != -1) {
516 trace_scsi_req_parsed_lba(d->id, lun, tag, buf[0],
517 cmd.lba);
518 }
519
520 if ((d->unit_attention.key == UNIT_ATTENTION ||
521 bus->unit_attention.key == UNIT_ATTENTION) &&
522 (buf[0] != INQUIRY &&
523 buf[0] != REPORT_LUNS &&
524 buf[0] != GET_CONFIGURATION &&
525 buf[0] != GET_EVENT_STATUS_NOTIFICATION &&
526
527 /*
528 * If we already have a pending unit attention condition,
529 * report this one before triggering another one.
530 */
531 !(buf[0] == REQUEST_SENSE && d->sense_is_ua))) {
532 req = scsi_req_alloc(&reqops_unit_attention, d, tag, lun,
533 hba_private);
534 } else if (lun != d->lun ||
535 buf[0] == REPORT_LUNS ||
536 (buf[0] == REQUEST_SENSE && (d->sense_len || cmd.xfer < 4))) {
537 req = scsi_req_alloc(&reqops_target_command, d, tag, lun,
538 hba_private);
539 } else {
540 req = scsi_device_alloc_req(d, tag, lun, buf, hba_private);
541 }
542 }
543
544 req->cmd = cmd;
545 req->resid = req->cmd.xfer;
546
547 switch (buf[0]) {
548 case INQUIRY:
549 trace_scsi_inquiry(d->id, lun, tag, cmd.buf[1], cmd.buf[2]);
550 break;
551 case TEST_UNIT_READY:
552 trace_scsi_test_unit_ready(d->id, lun, tag);
553 break;
554 case REPORT_LUNS:
555 trace_scsi_report_luns(d->id, lun, tag);
556 break;
557 case REQUEST_SENSE:
558 trace_scsi_request_sense(d->id, lun, tag);
559 break;
560 default:
561 break;
562 }
563
564 return req;
565 }
566
567 uint8_t *scsi_req_get_buf(SCSIRequest *req)
568 {
569 return req->ops->get_buf(req);
570 }
571
572 static void scsi_clear_unit_attention(SCSIRequest *req)
573 {
574 SCSISense *ua;
575 if (req->dev->unit_attention.key != UNIT_ATTENTION &&
576 req->bus->unit_attention.key != UNIT_ATTENTION) {
577 return;
578 }
579
580 /*
581 * If an INQUIRY command enters the enabled command state,
582 * the device server shall [not] clear any unit attention condition;
583 * See also MMC-6, paragraphs 6.5 and 6.6.2.
584 */
585 if (req->cmd.buf[0] == INQUIRY ||
586 req->cmd.buf[0] == GET_CONFIGURATION ||
587 req->cmd.buf[0] == GET_EVENT_STATUS_NOTIFICATION) {
588 return;
589 }
590
591 if (req->dev->unit_attention.key == UNIT_ATTENTION) {
592 ua = &req->dev->unit_attention;
593 } else {
594 ua = &req->bus->unit_attention;
595 }
596
597 /*
598 * If a REPORT LUNS command enters the enabled command state, [...]
599 * the device server shall clear any pending unit attention condition
600 * with an additional sense code of REPORTED LUNS DATA HAS CHANGED.
601 */
602 if (req->cmd.buf[0] == REPORT_LUNS &&
603 !(ua->asc == SENSE_CODE(REPORTED_LUNS_CHANGED).asc &&
604 ua->ascq == SENSE_CODE(REPORTED_LUNS_CHANGED).ascq)) {
605 return;
606 }
607
608 *ua = SENSE_CODE(NO_SENSE);
609 }
610
611 int scsi_req_get_sense(SCSIRequest *req, uint8_t *buf, int len)
612 {
613 int ret;
614
615 assert(len >= 14);
616 if (!req->sense_len) {
617 return 0;
618 }
619
620 ret = scsi_build_sense(req->sense, req->sense_len, buf, len, true);
621
622 /*
623 * FIXME: clearing unit attention conditions upon autosense should be done
624 * only if the UA_INTLCK_CTRL field in the Control mode page is set to 00b
625 * (SAM-5, 5.14).
626 *
627 * We assume UA_INTLCK_CTRL to be 00b for HBAs that support autosense, and
628 * 10b for HBAs that do not support it (do not call scsi_req_get_sense).
629 * Here we handle unit attention clearing for UA_INTLCK_CTRL == 00b.
630 */
631 if (req->dev->sense_is_ua) {
632 scsi_device_unit_attention_reported(req->dev);
633 req->dev->sense_len = 0;
634 req->dev->sense_is_ua = false;
635 }
636 return ret;
637 }
638
639 int scsi_device_get_sense(SCSIDevice *dev, uint8_t *buf, int len, bool fixed)
640 {
641 return scsi_build_sense(dev->sense, dev->sense_len, buf, len, fixed);
642 }
643
644 void scsi_req_build_sense(SCSIRequest *req, SCSISense sense)
645 {
646 trace_scsi_req_build_sense(req->dev->id, req->lun, req->tag,
647 sense.key, sense.asc, sense.ascq);
648 memset(req->sense, 0, 18);
649 req->sense[0] = 0xf0;
650 req->sense[2] = sense.key;
651 req->sense[7] = 10;
652 req->sense[12] = sense.asc;
653 req->sense[13] = sense.ascq;
654 req->sense_len = 18;
655 }
656
657 static void scsi_req_enqueue_internal(SCSIRequest *req)
658 {
659 assert(!req->enqueued);
660 scsi_req_ref(req);
661 if (req->bus->info->get_sg_list) {
662 req->sg = req->bus->info->get_sg_list(req);
663 } else {
664 req->sg = NULL;
665 }
666 req->enqueued = true;
667 QTAILQ_INSERT_TAIL(&req->dev->requests, req, next);
668 }
669
670 int32_t scsi_req_enqueue(SCSIRequest *req)
671 {
672 int32_t rc;
673
674 assert(!req->retry);
675 scsi_req_enqueue_internal(req);
676 scsi_req_ref(req);
677 rc = req->ops->send_command(req, req->cmd.buf);
678 scsi_req_unref(req);
679 return rc;
680 }
681
682 static void scsi_req_dequeue(SCSIRequest *req)
683 {
684 trace_scsi_req_dequeue(req->dev->id, req->lun, req->tag);
685 req->retry = false;
686 if (req->enqueued) {
687 QTAILQ_REMOVE(&req->dev->requests, req, next);
688 req->enqueued = false;
689 scsi_req_unref(req);
690 }
691 }
692
693 static int scsi_get_performance_length(int num_desc, int type, int data_type)
694 {
695 /* MMC-6, paragraph 6.7. */
696 switch (type) {
697 case 0:
698 if ((data_type & 3) == 0) {
699 /* Each descriptor is as in Table 295 - Nominal performance. */
700 return 16 * num_desc + 8;
701 } else {
702 /* Each descriptor is as in Table 296 - Exceptions. */
703 return 6 * num_desc + 8;
704 }
705 case 1:
706 case 4:
707 case 5:
708 return 8 * num_desc + 8;
709 case 2:
710 return 2048 * num_desc + 8;
711 case 3:
712 return 16 * num_desc + 8;
713 default:
714 return 8;
715 }
716 }
717
718 static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)
719 {
720 switch (buf[0] >> 5) {
721 case 0:
722 cmd->xfer = buf[4];
723 cmd->len = 6;
724 /* length 0 means 256 blocks */
725 if (cmd->xfer == 0) {
726 cmd->xfer = 256;
727 }
728 break;
729 case 1:
730 case 2:
731 cmd->xfer = lduw_be_p(&buf[7]);
732 cmd->len = 10;
733 break;
734 case 4:
735 cmd->xfer = ldl_be_p(&buf[10]) & 0xffffffffULL;
736 cmd->len = 16;
737 break;
738 case 5:
739 cmd->xfer = ldl_be_p(&buf[6]) & 0xffffffffULL;
740 cmd->len = 12;
741 break;
742 default:
743 return -1;
744 }
745
746 switch (buf[0]) {
747 case TEST_UNIT_READY:
748 case REWIND:
749 case START_STOP:
750 case SET_CAPACITY:
751 case WRITE_FILEMARKS:
752 case WRITE_FILEMARKS_16:
753 case SPACE:
754 case RESERVE:
755 case RELEASE:
756 case ERASE:
757 case ALLOW_MEDIUM_REMOVAL:
758 case VERIFY_10:
759 case SEEK_10:
760 case SYNCHRONIZE_CACHE:
761 case SYNCHRONIZE_CACHE_16:
762 case LOCATE_16:
763 case LOCK_UNLOCK_CACHE:
764 case LOAD_UNLOAD:
765 case SET_CD_SPEED:
766 case SET_LIMITS:
767 case WRITE_LONG_10:
768 case MOVE_MEDIUM:
769 case UPDATE_BLOCK:
770 case RESERVE_TRACK:
771 case SET_READ_AHEAD:
772 case PRE_FETCH:
773 case PRE_FETCH_16:
774 case ALLOW_OVERWRITE:
775 cmd->xfer = 0;
776 break;
777 case MODE_SENSE:
778 break;
779 case WRITE_SAME_10:
780 cmd->xfer = 1;
781 break;
782 case READ_CAPACITY_10:
783 cmd->xfer = 8;
784 break;
785 case READ_BLOCK_LIMITS:
786 cmd->xfer = 6;
787 break;
788 case SEND_VOLUME_TAG:
789 /* GPCMD_SET_STREAMING from multimedia commands. */
790 if (dev->type == TYPE_ROM) {
791 cmd->xfer = buf[10] | (buf[9] << 8);
792 } else {
793 cmd->xfer = buf[9] | (buf[8] << 8);
794 }
795 break;
796 case WRITE_10:
797 case WRITE_VERIFY_10:
798 case WRITE_6:
799 case WRITE_12:
800 case WRITE_VERIFY_12:
801 case WRITE_16:
802 case WRITE_VERIFY_16:
803 cmd->xfer *= dev->blocksize;
804 break;
805 case READ_10:
806 case READ_6:
807 case READ_REVERSE:
808 case RECOVER_BUFFERED_DATA:
809 case READ_12:
810 case READ_16:
811 cmd->xfer *= dev->blocksize;
812 break;
813 case FORMAT_UNIT:
814 /* MMC mandates the parameter list to be 12-bytes long. Parameters
815 * for block devices are restricted to the header right now. */
816 if (dev->type == TYPE_ROM && (buf[1] & 16)) {
817 cmd->xfer = 12;
818 } else {
819 cmd->xfer = (buf[1] & 16) == 0 ? 0 : (buf[1] & 32 ? 8 : 4);
820 }
821 break;
822 case INQUIRY:
823 case RECEIVE_DIAGNOSTIC:
824 case SEND_DIAGNOSTIC:
825 cmd->xfer = buf[4] | (buf[3] << 8);
826 break;
827 case READ_CD:
828 case READ_BUFFER:
829 case WRITE_BUFFER:
830 case SEND_CUE_SHEET:
831 cmd->xfer = buf[8] | (buf[7] << 8) | (buf[6] << 16);
832 break;
833 case PERSISTENT_RESERVE_OUT:
834 cmd->xfer = ldl_be_p(&buf[5]) & 0xffffffffULL;
835 break;
836 case ERASE_12:
837 if (dev->type == TYPE_ROM) {
838 /* MMC command GET PERFORMANCE. */
839 cmd->xfer = scsi_get_performance_length(buf[9] | (buf[8] << 8),
840 buf[10], buf[1] & 0x1f);
841 }
842 break;
843 case MECHANISM_STATUS:
844 case READ_DVD_STRUCTURE:
845 case SEND_DVD_STRUCTURE:
846 case MAINTENANCE_OUT:
847 case MAINTENANCE_IN:
848 if (dev->type == TYPE_ROM) {
849 /* GPCMD_REPORT_KEY and GPCMD_SEND_KEY from multi media commands */
850 cmd->xfer = buf[9] | (buf[8] << 8);
851 }
852 break;
853 }
854 return 0;
855 }
856
857 static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)
858 {
859 switch (buf[0]) {
860 /* stream commands */
861 case ERASE_12:
862 case ERASE_16:
863 cmd->xfer = 0;
864 break;
865 case READ_6:
866 case READ_REVERSE:
867 case RECOVER_BUFFERED_DATA:
868 case WRITE_6:
869 cmd->len = 6;
870 cmd->xfer = buf[4] | (buf[3] << 8) | (buf[2] << 16);
871 if (buf[1] & 0x01) { /* fixed */
872 cmd->xfer *= dev->blocksize;
873 }
874 break;
875 case REWIND:
876 case START_STOP:
877 cmd->len = 6;
878 cmd->xfer = 0;
879 break;
880 case SPACE_16:
881 cmd->xfer = buf[13] | (buf[12] << 8);
882 break;
883 case READ_POSITION:
884 cmd->xfer = buf[8] | (buf[7] << 8);
885 break;
886 case FORMAT_UNIT:
887 cmd->xfer = buf[4] | (buf[3] << 8);
888 break;
889 /* generic commands */
890 default:
891 return scsi_req_length(cmd, dev, buf);
892 }
893 return 0;
894 }
895
896 static void scsi_cmd_xfer_mode(SCSICommand *cmd)
897 {
898 switch (cmd->buf[0]) {
899 case WRITE_6:
900 case WRITE_10:
901 case WRITE_VERIFY_10:
902 case WRITE_12:
903 case WRITE_VERIFY_12:
904 case WRITE_16:
905 case WRITE_VERIFY_16:
906 case COPY:
907 case COPY_VERIFY:
908 case COMPARE:
909 case CHANGE_DEFINITION:
910 case LOG_SELECT:
911 case MODE_SELECT:
912 case MODE_SELECT_10:
913 case SEND_DIAGNOSTIC:
914 case WRITE_BUFFER:
915 case FORMAT_UNIT:
916 case REASSIGN_BLOCKS:
917 case SEARCH_EQUAL:
918 case SEARCH_HIGH:
919 case SEARCH_LOW:
920 case UPDATE_BLOCK:
921 case WRITE_LONG_10:
922 case WRITE_SAME_10:
923 case SEARCH_HIGH_12:
924 case SEARCH_EQUAL_12:
925 case SEARCH_LOW_12:
926 case MEDIUM_SCAN:
927 case SEND_VOLUME_TAG:
928 case SEND_CUE_SHEET:
929 case SEND_DVD_STRUCTURE:
930 case PERSISTENT_RESERVE_OUT:
931 case MAINTENANCE_OUT:
932 cmd->mode = SCSI_XFER_TO_DEV;
933 break;
934 default:
935 if (cmd->xfer)
936 cmd->mode = SCSI_XFER_FROM_DEV;
937 else {
938 cmd->mode = SCSI_XFER_NONE;
939 }
940 break;
941 }
942 }
943
944 static uint64_t scsi_cmd_lba(SCSICommand *cmd)
945 {
946 uint8_t *buf = cmd->buf;
947 uint64_t lba;
948
949 switch (buf[0] >> 5) {
950 case 0:
951 lba = ldl_be_p(&buf[0]) & 0x1fffff;
952 break;
953 case 1:
954 case 2:
955 case 5:
956 lba = ldl_be_p(&buf[2]) & 0xffffffffULL;
957 break;
958 case 4:
959 lba = ldq_be_p(&buf[2]);
960 break;
961 default:
962 lba = -1;
963
964 }
965 return lba;
966 }
967
968 int scsi_req_parse(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)
969 {
970 int rc;
971
972 if (dev->type == TYPE_TAPE) {
973 rc = scsi_req_stream_length(cmd, dev, buf);
974 } else {
975 rc = scsi_req_length(cmd, dev, buf);
976 }
977 if (rc != 0)
978 return rc;
979
980 memcpy(cmd->buf, buf, cmd->len);
981 scsi_cmd_xfer_mode(cmd);
982 cmd->lba = scsi_cmd_lba(cmd);
983 return 0;
984 }
985
986 /*
987 * Predefined sense codes
988 */
989
990 /* No sense data available */
991 const struct SCSISense sense_code_NO_SENSE = {
992 .key = NO_SENSE , .asc = 0x00 , .ascq = 0x00
993 };
994
995 /* LUN not ready, Manual intervention required */
996 const struct SCSISense sense_code_LUN_NOT_READY = {
997 .key = NOT_READY, .asc = 0x04, .ascq = 0x03
998 };
999
1000 /* LUN not ready, Medium not present */
1001 const struct SCSISense sense_code_NO_MEDIUM = {
1002 .key = NOT_READY, .asc = 0x3a, .ascq = 0x00
1003 };
1004
1005 /* LUN not ready, medium removal prevented */
1006 const struct SCSISense sense_code_NOT_READY_REMOVAL_PREVENTED = {
1007 .key = NOT_READY, .asc = 0x53, .ascq = 0x00
1008 };
1009
1010 /* Hardware error, internal target failure */
1011 const struct SCSISense sense_code_TARGET_FAILURE = {
1012 .key = HARDWARE_ERROR, .asc = 0x44, .ascq = 0x00
1013 };
1014
1015 /* Illegal request, invalid command operation code */
1016 const struct SCSISense sense_code_INVALID_OPCODE = {
1017 .key = ILLEGAL_REQUEST, .asc = 0x20, .ascq = 0x00
1018 };
1019
1020 /* Illegal request, LBA out of range */
1021 const struct SCSISense sense_code_LBA_OUT_OF_RANGE = {
1022 .key = ILLEGAL_REQUEST, .asc = 0x21, .ascq = 0x00
1023 };
1024
1025 /* Illegal request, Invalid field in CDB */
1026 const struct SCSISense sense_code_INVALID_FIELD = {
1027 .key = ILLEGAL_REQUEST, .asc = 0x24, .ascq = 0x00
1028 };
1029
1030 /* Illegal request, LUN not supported */
1031 const struct SCSISense sense_code_LUN_NOT_SUPPORTED = {
1032 .key = ILLEGAL_REQUEST, .asc = 0x25, .ascq = 0x00
1033 };
1034
1035 /* Illegal request, Saving parameters not supported */
1036 const struct SCSISense sense_code_SAVING_PARAMS_NOT_SUPPORTED = {
1037 .key = ILLEGAL_REQUEST, .asc = 0x39, .ascq = 0x00
1038 };
1039
1040 /* Illegal request, Incompatible medium installed */
1041 const struct SCSISense sense_code_INCOMPATIBLE_FORMAT = {
1042 .key = ILLEGAL_REQUEST, .asc = 0x30, .ascq = 0x00
1043 };
1044
1045 /* Illegal request, medium removal prevented */
1046 const struct SCSISense sense_code_ILLEGAL_REQ_REMOVAL_PREVENTED = {
1047 .key = ILLEGAL_REQUEST, .asc = 0x53, .ascq = 0x00
1048 };
1049
1050 /* Command aborted, I/O process terminated */
1051 const struct SCSISense sense_code_IO_ERROR = {
1052 .key = ABORTED_COMMAND, .asc = 0x00, .ascq = 0x06
1053 };
1054
1055 /* Command aborted, I_T Nexus loss occurred */
1056 const struct SCSISense sense_code_I_T_NEXUS_LOSS = {
1057 .key = ABORTED_COMMAND, .asc = 0x29, .ascq = 0x07
1058 };
1059
1060 /* Command aborted, Logical Unit failure */
1061 const struct SCSISense sense_code_LUN_FAILURE = {
1062 .key = ABORTED_COMMAND, .asc = 0x3e, .ascq = 0x01
1063 };
1064
1065 /* Unit attention, Power on, reset or bus device reset occurred */
1066 const struct SCSISense sense_code_RESET = {
1067 .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x00
1068 };
1069
1070 /* Unit attention, No medium */
1071 const struct SCSISense sense_code_UNIT_ATTENTION_NO_MEDIUM = {
1072 .key = UNIT_ATTENTION, .asc = 0x3a, .ascq = 0x00
1073 };
1074
1075 /* Unit attention, Medium may have changed */
1076 const struct SCSISense sense_code_MEDIUM_CHANGED = {
1077 .key = UNIT_ATTENTION, .asc = 0x28, .ascq = 0x00
1078 };
1079
1080 /* Unit attention, Reported LUNs data has changed */
1081 const struct SCSISense sense_code_REPORTED_LUNS_CHANGED = {
1082 .key = UNIT_ATTENTION, .asc = 0x3f, .ascq = 0x0e
1083 };
1084
1085 /* Unit attention, Device internal reset */
1086 const struct SCSISense sense_code_DEVICE_INTERNAL_RESET = {
1087 .key = UNIT_ATTENTION, .asc = 0x29, .ascq = 0x04
1088 };
1089
1090 /*
1091 * scsi_build_sense
1092 *
1093 * Convert between fixed and descriptor sense buffers
1094 */
1095 int scsi_build_sense(uint8_t *in_buf, int in_len,
1096 uint8_t *buf, int len, bool fixed)
1097 {
1098 bool fixed_in;
1099 SCSISense sense;
1100 if (!fixed && len < 8) {
1101 return 0;
1102 }
1103
1104 if (in_len == 0) {
1105 sense.key = NO_SENSE;
1106 sense.asc = 0;
1107 sense.ascq = 0;
1108 } else {
1109 fixed_in = (in_buf[0] & 2) == 0;
1110
1111 if (fixed == fixed_in) {
1112 memcpy(buf, in_buf, MIN(len, in_len));
1113 return MIN(len, in_len);
1114 }
1115
1116 if (fixed_in) {
1117 sense.key = in_buf[2];
1118 sense.asc = in_buf[12];
1119 sense.ascq = in_buf[13];
1120 } else {
1121 sense.key = in_buf[1];
1122 sense.asc = in_buf[2];
1123 sense.ascq = in_buf[3];
1124 }
1125 }
1126
1127 memset(buf, 0, len);
1128 if (fixed) {
1129 /* Return fixed format sense buffer */
1130 buf[0] = 0xf0;
1131 buf[2] = sense.key;
1132 buf[7] = 10;
1133 buf[12] = sense.asc;
1134 buf[13] = sense.ascq;
1135 return MIN(len, 18);
1136 } else {
1137 /* Return descriptor format sense buffer */
1138 buf[0] = 0x72;
1139 buf[1] = sense.key;
1140 buf[2] = sense.asc;
1141 buf[3] = sense.ascq;
1142 return 8;
1143 }
1144 }
1145
1146 static const char *scsi_command_name(uint8_t cmd)
1147 {
1148 static const char *names[] = {
1149 [ TEST_UNIT_READY ] = "TEST_UNIT_READY",
1150 [ REWIND ] = "REWIND",
1151 [ REQUEST_SENSE ] = "REQUEST_SENSE",
1152 [ FORMAT_UNIT ] = "FORMAT_UNIT",
1153 [ READ_BLOCK_LIMITS ] = "READ_BLOCK_LIMITS",
1154 [ REASSIGN_BLOCKS ] = "REASSIGN_BLOCKS",
1155 [ READ_6 ] = "READ_6",
1156 [ WRITE_6 ] = "WRITE_6",
1157 [ SET_CAPACITY ] = "SET_CAPACITY",
1158 [ READ_REVERSE ] = "READ_REVERSE",
1159 [ WRITE_FILEMARKS ] = "WRITE_FILEMARKS",
1160 [ SPACE ] = "SPACE",
1161 [ INQUIRY ] = "INQUIRY",
1162 [ RECOVER_BUFFERED_DATA ] = "RECOVER_BUFFERED_DATA",
1163 [ MAINTENANCE_IN ] = "MAINTENANCE_IN",
1164 [ MAINTENANCE_OUT ] = "MAINTENANCE_OUT",
1165 [ MODE_SELECT ] = "MODE_SELECT",
1166 [ RESERVE ] = "RESERVE",
1167 [ RELEASE ] = "RELEASE",
1168 [ COPY ] = "COPY",
1169 [ ERASE ] = "ERASE",
1170 [ MODE_SENSE ] = "MODE_SENSE",
1171 [ START_STOP ] = "START_STOP",
1172 [ RECEIVE_DIAGNOSTIC ] = "RECEIVE_DIAGNOSTIC",
1173 [ SEND_DIAGNOSTIC ] = "SEND_DIAGNOSTIC",
1174 [ ALLOW_MEDIUM_REMOVAL ] = "ALLOW_MEDIUM_REMOVAL",
1175 [ READ_CAPACITY_10 ] = "READ_CAPACITY_10",
1176 [ READ_10 ] = "READ_10",
1177 [ WRITE_10 ] = "WRITE_10",
1178 [ SEEK_10 ] = "SEEK_10",
1179 [ WRITE_VERIFY_10 ] = "WRITE_VERIFY_10",
1180 [ VERIFY_10 ] = "VERIFY_10",
1181 [ SEARCH_HIGH ] = "SEARCH_HIGH",
1182 [ SEARCH_EQUAL ] = "SEARCH_EQUAL",
1183 [ SEARCH_LOW ] = "SEARCH_LOW",
1184 [ SET_LIMITS ] = "SET_LIMITS",
1185 [ PRE_FETCH ] = "PRE_FETCH/READ_POSITION",
1186 /* READ_POSITION and PRE_FETCH use the same operation code */
1187 [ SYNCHRONIZE_CACHE ] = "SYNCHRONIZE_CACHE",
1188 [ LOCK_UNLOCK_CACHE ] = "LOCK_UNLOCK_CACHE",
1189 [ READ_DEFECT_DATA ] = "READ_DEFECT_DATA",
1190 [ MEDIUM_SCAN ] = "MEDIUM_SCAN",
1191 [ COMPARE ] = "COMPARE",
1192 [ COPY_VERIFY ] = "COPY_VERIFY",
1193 [ WRITE_BUFFER ] = "WRITE_BUFFER",
1194 [ READ_BUFFER ] = "READ_BUFFER",
1195 [ UPDATE_BLOCK ] = "UPDATE_BLOCK",
1196 [ READ_LONG_10 ] = "READ_LONG_10",
1197 [ WRITE_LONG_10 ] = "WRITE_LONG_10",
1198 [ CHANGE_DEFINITION ] = "CHANGE_DEFINITION",
1199 [ WRITE_SAME_10 ] = "WRITE_SAME_10",
1200 [ UNMAP ] = "UNMAP",
1201 [ READ_TOC ] = "READ_TOC",
1202 [ REPORT_DENSITY_SUPPORT ] = "REPORT_DENSITY_SUPPORT",
1203 [ GET_CONFIGURATION ] = "GET_CONFIGURATION",
1204 [ LOG_SELECT ] = "LOG_SELECT",
1205 [ LOG_SENSE ] = "LOG_SENSE",
1206 [ MODE_SELECT_10 ] = "MODE_SELECT_10",
1207 [ RESERVE_10 ] = "RESERVE_10",
1208 [ RELEASE_10 ] = "RELEASE_10",
1209 [ MODE_SENSE_10 ] = "MODE_SENSE_10",
1210 [ PERSISTENT_RESERVE_IN ] = "PERSISTENT_RESERVE_IN",
1211 [ PERSISTENT_RESERVE_OUT ] = "PERSISTENT_RESERVE_OUT",
1212 [ WRITE_FILEMARKS_16 ] = "WRITE_FILEMARKS_16",
1213 [ EXTENDED_COPY ] = "EXTENDED_COPY",
1214 [ ATA_PASSTHROUGH ] = "ATA_PASSTHROUGH",
1215 [ ACCESS_CONTROL_IN ] = "ACCESS_CONTROL_IN",
1216 [ ACCESS_CONTROL_OUT ] = "ACCESS_CONTROL_OUT",
1217 [ READ_16 ] = "READ_16",
1218 [ COMPARE_AND_WRITE ] = "COMPARE_AND_WRITE",
1219 [ WRITE_16 ] = "WRITE_16",
1220 [ WRITE_VERIFY_16 ] = "WRITE_VERIFY_16",
1221 [ VERIFY_16 ] = "VERIFY_16",
1222 [ PRE_FETCH_16 ] = "PRE_FETCH_16",
1223 [ SYNCHRONIZE_CACHE_16 ] = "SPACE_16/SYNCHRONIZE_CACHE_16",
1224 /* SPACE_16 and SYNCHRONIZE_CACHE_16 use the same operation code */
1225 [ LOCATE_16 ] = "LOCATE_16",
1226 [ WRITE_SAME_16 ] = "ERASE_16/WRITE_SAME_16",
1227 /* ERASE_16 and WRITE_SAME_16 use the same operation code */
1228 [ SERVICE_ACTION_IN_16 ] = "SERVICE_ACTION_IN_16",
1229 [ WRITE_LONG_16 ] = "WRITE_LONG_16",
1230 [ REPORT_LUNS ] = "REPORT_LUNS",
1231 [ BLANK ] = "BLANK",
1232 [ MOVE_MEDIUM ] = "MOVE_MEDIUM",
1233 [ LOAD_UNLOAD ] = "LOAD_UNLOAD",
1234 [ READ_12 ] = "READ_12",
1235 [ WRITE_12 ] = "WRITE_12",
1236 [ ERASE_12 ] = "ERASE_12/GET_PERFORMANCE",
1237 /* ERASE_12 and GET_PERFORMANCE use the same operation code */
1238 [ SERVICE_ACTION_IN_12 ] = "SERVICE_ACTION_IN_12",
1239 [ WRITE_VERIFY_12 ] = "WRITE_VERIFY_12",
1240 [ VERIFY_12 ] = "VERIFY_12",
1241 [ SEARCH_HIGH_12 ] = "SEARCH_HIGH_12",
1242 [ SEARCH_EQUAL_12 ] = "SEARCH_EQUAL_12",
1243 [ SEARCH_LOW_12 ] = "SEARCH_LOW_12",
1244 [ READ_ELEMENT_STATUS ] = "READ_ELEMENT_STATUS",
1245 [ SEND_VOLUME_TAG ] = "SEND_VOLUME_TAG/SET_STREAMING",
1246 /* SEND_VOLUME_TAG and SET_STREAMING use the same operation code */
1247 [ READ_CD ] = "READ_CD",
1248 [ READ_DEFECT_DATA_12 ] = "READ_DEFECT_DATA_12",
1249 [ READ_DVD_STRUCTURE ] = "READ_DVD_STRUCTURE",
1250 [ RESERVE_TRACK ] = "RESERVE_TRACK",
1251 [ SEND_CUE_SHEET ] = "SEND_CUE_SHEET",
1252 [ SEND_DVD_STRUCTURE ] = "SEND_DVD_STRUCTURE",
1253 [ SET_CD_SPEED ] = "SET_CD_SPEED",
1254 [ SET_READ_AHEAD ] = "SET_READ_AHEAD",
1255 [ ALLOW_OVERWRITE ] = "ALLOW_OVERWRITE",
1256 [ MECHANISM_STATUS ] = "MECHANISM_STATUS",
1257 };
1258
1259 if (cmd >= ARRAY_SIZE(names) || names[cmd] == NULL)
1260 return "*UNKNOWN*";
1261 return names[cmd];
1262 }
1263
1264 SCSIRequest *scsi_req_ref(SCSIRequest *req)
1265 {
1266 req->refcount++;
1267 return req;
1268 }
1269
1270 void scsi_req_unref(SCSIRequest *req)
1271 {
1272 if (--req->refcount == 0) {
1273 if (req->ops->free_req) {
1274 req->ops->free_req(req);
1275 }
1276 g_free(req);
1277 }
1278 }
1279
1280 /* Tell the device that we finished processing this chunk of I/O. It
1281 will start the next chunk or complete the command. */
1282 void scsi_req_continue(SCSIRequest *req)
1283 {
1284 trace_scsi_req_continue(req->dev->id, req->lun, req->tag);
1285 if (req->cmd.mode == SCSI_XFER_TO_DEV) {
1286 req->ops->write_data(req);
1287 } else {
1288 req->ops->read_data(req);
1289 }
1290 }
1291
1292 /* Called by the devices when data is ready for the HBA. The HBA should
1293 start a DMA operation to read or fill the device's data buffer.
1294 Once it completes, calling scsi_req_continue will restart I/O. */
1295 void scsi_req_data(SCSIRequest *req, int len)
1296 {
1297 uint8_t *buf;
1298 if (req->io_canceled) {
1299 trace_scsi_req_data_canceled(req->dev->id, req->lun, req->tag, len);
1300 return;
1301 }
1302 trace_scsi_req_data(req->dev->id, req->lun, req->tag, len);
1303 assert(req->cmd.mode != SCSI_XFER_NONE);
1304 if (!req->sg) {
1305 req->resid -= len;
1306 req->bus->info->transfer_data(req, len);
1307 return;
1308 }
1309
1310 /* If the device calls scsi_req_data and the HBA specified a
1311 * scatter/gather list, the transfer has to happen in a single
1312 * step. */
1313 assert(!req->dma_started);
1314 req->dma_started = true;
1315
1316 buf = scsi_req_get_buf(req);
1317 if (req->cmd.mode == SCSI_XFER_FROM_DEV) {
1318 req->resid = dma_buf_read(buf, len, req->sg);
1319 } else {
1320 req->resid = dma_buf_write(buf, len, req->sg);
1321 }
1322 scsi_req_continue(req);
1323 }
1324
1325 void scsi_req_print(SCSIRequest *req)
1326 {
1327 FILE *fp = stderr;
1328 int i;
1329
1330 fprintf(fp, "[%s id=%d] %s",
1331 req->dev->qdev.parent_bus->name,
1332 req->dev->id,
1333 scsi_command_name(req->cmd.buf[0]));
1334 for (i = 1; i < req->cmd.len; i++) {
1335 fprintf(fp, " 0x%02x", req->cmd.buf[i]);
1336 }
1337 switch (req->cmd.mode) {
1338 case SCSI_XFER_NONE:
1339 fprintf(fp, " - none\n");
1340 break;
1341 case SCSI_XFER_FROM_DEV:
1342 fprintf(fp, " - from-dev len=%zd\n", req->cmd.xfer);
1343 break;
1344 case SCSI_XFER_TO_DEV:
1345 fprintf(fp, " - to-dev len=%zd\n", req->cmd.xfer);
1346 break;
1347 default:
1348 fprintf(fp, " - Oops\n");
1349 break;
1350 }
1351 }
1352
1353 void scsi_req_complete(SCSIRequest *req, int status)
1354 {
1355 assert(req->status == -1);
1356 req->status = status;
1357
1358 assert(req->sense_len < sizeof(req->sense));
1359 if (status == GOOD) {
1360 req->sense_len = 0;
1361 }
1362
1363 if (req->sense_len) {
1364 memcpy(req->dev->sense, req->sense, req->sense_len);
1365 req->dev->sense_len = req->sense_len;
1366 req->dev->sense_is_ua = (req->ops == &reqops_unit_attention);
1367 } else {
1368 req->dev->sense_len = 0;
1369 req->dev->sense_is_ua = false;
1370 }
1371
1372 /*
1373 * Unit attention state is now stored in the device's sense buffer
1374 * if the HBA didn't do autosense. Clear the pending unit attention
1375 * flags.
1376 */
1377 scsi_clear_unit_attention(req);
1378
1379 scsi_req_ref(req);
1380 scsi_req_dequeue(req);
1381 req->bus->info->complete(req, req->status, req->resid);
1382 scsi_req_unref(req);
1383 }
1384
1385 void scsi_req_cancel(SCSIRequest *req)
1386 {
1387 if (!req->enqueued) {
1388 return;
1389 }
1390 scsi_req_ref(req);
1391 scsi_req_dequeue(req);
1392 req->io_canceled = true;
1393 if (req->ops->cancel_io) {
1394 req->ops->cancel_io(req);
1395 }
1396 if (req->bus->info->cancel) {
1397 req->bus->info->cancel(req);
1398 }
1399 scsi_req_unref(req);
1400 }
1401
1402 void scsi_req_abort(SCSIRequest *req, int status)
1403 {
1404 if (!req->enqueued) {
1405 return;
1406 }
1407 scsi_req_ref(req);
1408 scsi_req_dequeue(req);
1409 req->io_canceled = true;
1410 if (req->ops->cancel_io) {
1411 req->ops->cancel_io(req);
1412 }
1413 scsi_req_complete(req, status);
1414 scsi_req_unref(req);
1415 }
1416
1417 void scsi_device_purge_requests(SCSIDevice *sdev, SCSISense sense)
1418 {
1419 SCSIRequest *req;
1420
1421 while (!QTAILQ_EMPTY(&sdev->requests)) {
1422 req = QTAILQ_FIRST(&sdev->requests);
1423 scsi_req_cancel(req);
1424 }
1425 sdev->unit_attention = sense;
1426 }
1427
1428 static char *scsibus_get_dev_path(DeviceState *dev)
1429 {
1430 SCSIDevice *d = DO_UPCAST(SCSIDevice, qdev, dev);
1431 DeviceState *hba = dev->parent_bus->parent;
1432 char *id = NULL;
1433
1434 if (hba && hba->parent_bus && hba->parent_bus->info->get_dev_path) {
1435 id = hba->parent_bus->info->get_dev_path(hba);
1436 }
1437 if (id) {
1438 return g_strdup_printf("%s/%d:%d:%d", id, d->channel, d->id, d->lun);
1439 } else {
1440 return g_strdup_printf("%d:%d:%d", d->channel, d->id, d->lun);
1441 }
1442 }
1443
1444 static char *scsibus_get_fw_dev_path(DeviceState *dev)
1445 {
1446 SCSIDevice *d = SCSI_DEVICE(dev);
1447 char path[100];
1448
1449 snprintf(path, sizeof(path), "channel@%x/%s@%x,%x", d->channel,
1450 qdev_fw_name(dev), d->id, d->lun);
1451
1452 return strdup(path);
1453 }
1454
1455 SCSIDevice *scsi_device_find(SCSIBus *bus, int channel, int id, int lun)
1456 {
1457 DeviceState *qdev;
1458 SCSIDevice *target_dev = NULL;
1459
1460 QTAILQ_FOREACH_REVERSE(qdev, &bus->qbus.children, ChildrenHead, sibling) {
1461 SCSIDevice *dev = SCSI_DEVICE(qdev);
1462
1463 if (dev->channel == channel && dev->id == id) {
1464 if (dev->lun == lun) {
1465 return dev;
1466 }
1467 target_dev = dev;
1468 }
1469 }
1470 return target_dev;
1471 }
1472
1473 /* SCSI request list. For simplicity, pv points to the whole device */
1474
1475 static void put_scsi_requests(QEMUFile *f, void *pv, size_t size)
1476 {
1477 SCSIDevice *s = pv;
1478 SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, s->qdev.parent_bus);
1479 SCSIRequest *req;
1480
1481 QTAILQ_FOREACH(req, &s->requests, next) {
1482 assert(!req->io_canceled);
1483 assert(req->status == -1);
1484 assert(req->retry);
1485 assert(req->enqueued);
1486
1487 qemu_put_sbyte(f, 1);
1488 qemu_put_buffer(f, req->cmd.buf, sizeof(req->cmd.buf));
1489 qemu_put_be32s(f, &req->tag);
1490 qemu_put_be32s(f, &req->lun);
1491 if (bus->info->save_request) {
1492 bus->info->save_request(f, req);
1493 }
1494 if (req->ops->save_request) {
1495 req->ops->save_request(f, req);
1496 }
1497 }
1498 qemu_put_sbyte(f, 0);
1499 }
1500
1501 static int get_scsi_requests(QEMUFile *f, void *pv, size_t size)
1502 {
1503 SCSIDevice *s = pv;
1504 SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, s->qdev.parent_bus);
1505
1506 while (qemu_get_sbyte(f)) {
1507 uint8_t buf[SCSI_CMD_BUF_SIZE];
1508 uint32_t tag;
1509 uint32_t lun;
1510 SCSIRequest *req;
1511
1512 qemu_get_buffer(f, buf, sizeof(buf));
1513 qemu_get_be32s(f, &tag);
1514 qemu_get_be32s(f, &lun);
1515 req = scsi_req_new(s, tag, lun, buf, NULL);
1516 if (bus->info->load_request) {
1517 req->hba_private = bus->info->load_request(f, req);
1518 }
1519 if (req->ops->load_request) {
1520 req->ops->load_request(f, req);
1521 }
1522
1523 /* Just restart it later. */
1524 req->retry = true;
1525 scsi_req_enqueue_internal(req);
1526
1527 /* At this point, the request will be kept alive by the reference
1528 * added by scsi_req_enqueue_internal, so we can release our reference.
1529 * The HBA of course will add its own reference in the load_request
1530 * callback if it needs to hold on the SCSIRequest.
1531 */
1532 scsi_req_unref(req);
1533 }
1534
1535 return 0;
1536 }
1537
1538 const VMStateInfo vmstate_info_scsi_requests = {
1539 .name = "scsi-requests",
1540 .get = get_scsi_requests,
1541 .put = put_scsi_requests,
1542 };
1543
1544 const VMStateDescription vmstate_scsi_device = {
1545 .name = "SCSIDevice",
1546 .version_id = 1,
1547 .minimum_version_id = 1,
1548 .minimum_version_id_old = 1,
1549 .fields = (VMStateField[]) {
1550 VMSTATE_UINT8(unit_attention.key, SCSIDevice),
1551 VMSTATE_UINT8(unit_attention.asc, SCSIDevice),
1552 VMSTATE_UINT8(unit_attention.ascq, SCSIDevice),
1553 VMSTATE_BOOL(sense_is_ua, SCSIDevice),
1554 VMSTATE_UINT8_ARRAY(sense, SCSIDevice, SCSI_SENSE_BUF_SIZE),
1555 VMSTATE_UINT32(sense_len, SCSIDevice),
1556 {
1557 .name = "requests",
1558 .version_id = 0,
1559 .field_exists = NULL,
1560 .size = 0, /* ouch */
1561 .info = &vmstate_info_scsi_requests,
1562 .flags = VMS_SINGLE,
1563 .offset = 0,
1564 },
1565 VMSTATE_END_OF_LIST()
1566 }
1567 };
1568
1569 static void scsi_device_class_init(ObjectClass *klass, void *data)
1570 {
1571 DeviceClass *k = DEVICE_CLASS(klass);
1572 k->bus_info = &scsi_bus_info;
1573 k->init = scsi_qdev_init;
1574 k->unplug = qdev_simple_unplug_cb;
1575 k->exit = scsi_qdev_exit;
1576 }
1577
1578 static TypeInfo scsi_device_type_info = {
1579 .name = TYPE_SCSI_DEVICE,
1580 .parent = TYPE_DEVICE,
1581 .instance_size = sizeof(SCSIDevice),
1582 .abstract = true,
1583 .class_size = sizeof(SCSIDeviceClass),
1584 .class_init = scsi_device_class_init,
1585 };
1586
1587 static void scsi_register_types(void)
1588 {
1589 type_register_static(&scsi_device_type_info);
1590 }
1591
1592 type_init(scsi_register_types)
CRIS target port of Qemu