scsi: move request-related callbacks from SCSIDeviceInfo to SCSIReqOps
[qemu.git] / hw / scsi-bus.c
blobdf28cc898294e4a17afdadfa48f9528d1d641c96
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"
9 static char *scsibus_get_fw_dev_path(DeviceState *dev);
10 static int scsi_build_sense(uint8_t *in_buf, int in_len,
11 uint8_t *buf, int len, bool fixed);
13 static struct BusInfo scsi_bus_info = {
14 .name = "SCSI",
15 .size = sizeof(SCSIBus),
16 .get_fw_dev_path = scsibus_get_fw_dev_path,
17 .props = (Property[]) {
18 DEFINE_PROP_UINT32("scsi-id", SCSIDevice, id, -1),
19 DEFINE_PROP_END_OF_LIST(),
22 static int next_scsi_bus;
24 /* Create a scsi bus, and attach devices to it. */
25 void scsi_bus_new(SCSIBus *bus, DeviceState *host, int tcq, int ndev,
26 const SCSIBusOps *ops)
28 qbus_create_inplace(&bus->qbus, &scsi_bus_info, host, NULL);
29 bus->busnr = next_scsi_bus++;
30 bus->tcq = tcq;
31 bus->ndev = ndev;
32 bus->ops = ops;
33 bus->qbus.allow_hotplug = 1;
36 static int scsi_qdev_init(DeviceState *qdev, DeviceInfo *base)
38 SCSIDevice *dev = DO_UPCAST(SCSIDevice, qdev, qdev);
39 SCSIDeviceInfo *info = DO_UPCAST(SCSIDeviceInfo, qdev, base);
40 SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus);
41 int rc = -1;
43 if (dev->id == -1) {
44 for (dev->id = 0; dev->id < bus->ndev; dev->id++) {
45 if (bus->devs[dev->id] == NULL)
46 break;
49 if (dev->id >= bus->ndev) {
50 error_report("bad scsi device id: %d", dev->id);
51 goto err;
54 if (bus->devs[dev->id]) {
55 qdev_free(&bus->devs[dev->id]->qdev);
57 bus->devs[dev->id] = dev;
59 dev->info = info;
60 QTAILQ_INIT(&dev->requests);
61 rc = dev->info->init(dev);
62 if (rc != 0) {
63 bus->devs[dev->id] = NULL;
66 err:
67 return rc;
70 static int scsi_qdev_exit(DeviceState *qdev)
72 SCSIDevice *dev = DO_UPCAST(SCSIDevice, qdev, qdev);
73 SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus);
75 assert(bus->devs[dev->id] != NULL);
76 if (bus->devs[dev->id]->info->destroy) {
77 bus->devs[dev->id]->info->destroy(bus->devs[dev->id]);
79 bus->devs[dev->id] = NULL;
80 return 0;
83 void scsi_qdev_register(SCSIDeviceInfo *info)
85 info->qdev.bus_info = &scsi_bus_info;
86 info->qdev.init = scsi_qdev_init;
87 info->qdev.unplug = qdev_simple_unplug_cb;
88 info->qdev.exit = scsi_qdev_exit;
89 qdev_register(&info->qdev);
92 /* handle legacy '-drive if=scsi,...' cmd line args */
93 SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv,
94 int unit, bool removable)
96 const char *driver;
97 DeviceState *dev;
99 driver = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk";
100 dev = qdev_create(&bus->qbus, driver);
101 qdev_prop_set_uint32(dev, "scsi-id", unit);
102 if (qdev_prop_exists(dev, "removable")) {
103 qdev_prop_set_bit(dev, "removable", removable);
105 if (qdev_prop_set_drive(dev, "drive", bdrv) < 0) {
106 qdev_free(dev);
107 return NULL;
109 if (qdev_init(dev) < 0)
110 return NULL;
111 return DO_UPCAST(SCSIDevice, qdev, dev);
114 int scsi_bus_legacy_handle_cmdline(SCSIBus *bus)
116 Location loc;
117 DriveInfo *dinfo;
118 int res = 0, unit;
120 loc_push_none(&loc);
121 for (unit = 0; unit < bus->ndev; unit++) {
122 dinfo = drive_get(IF_SCSI, bus->busnr, unit);
123 if (dinfo == NULL) {
124 continue;
126 qemu_opts_loc_restore(dinfo->opts);
127 if (!scsi_bus_legacy_add_drive(bus, dinfo->bdrv, unit, false)) {
128 res = -1;
129 break;
132 loc_pop(&loc);
133 return res;
136 SCSIRequest *scsi_req_alloc(SCSIReqOps *reqops, SCSIDevice *d, uint32_t tag,
137 uint32_t lun, void *hba_private)
139 SCSIRequest *req;
141 req = qemu_mallocz(reqops->size);
142 req->refcount = 1;
143 req->bus = scsi_bus_from_device(d);
144 req->dev = d;
145 req->tag = tag;
146 req->lun = lun;
147 req->hba_private = hba_private;
148 req->status = -1;
149 req->sense_len = 0;
150 req->ops = reqops;
151 trace_scsi_req_alloc(req->dev->id, req->lun, req->tag);
152 return req;
155 SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag, uint32_t lun,
156 void *hba_private)
158 return d->info->alloc_req(d, tag, lun, hba_private);
161 uint8_t *scsi_req_get_buf(SCSIRequest *req)
163 return req->ops->get_buf(req);
166 int scsi_req_get_sense(SCSIRequest *req, uint8_t *buf, int len)
168 assert(len >= 14);
169 if (!req->sense_len) {
170 return 0;
172 return scsi_build_sense(req->sense, req->sense_len, buf, len, true);
175 int scsi_device_get_sense(SCSIDevice *dev, uint8_t *buf, int len, bool fixed)
177 return scsi_build_sense(dev->sense, dev->sense_len, buf, len, fixed);
180 void scsi_req_build_sense(SCSIRequest *req, SCSISense sense)
182 trace_scsi_req_build_sense(req->dev->id, req->lun, req->tag,
183 sense.key, sense.asc, sense.ascq);
184 memset(req->sense, 0, 18);
185 req->sense[0] = 0xf0;
186 req->sense[2] = sense.key;
187 req->sense[12] = sense.asc;
188 req->sense[13] = sense.ascq;
189 req->sense_len = 18;
192 int32_t scsi_req_enqueue(SCSIRequest *req, uint8_t *buf)
194 int32_t rc;
196 assert(!req->enqueued);
197 scsi_req_ref(req);
198 req->enqueued = true;
199 QTAILQ_INSERT_TAIL(&req->dev->requests, req, next);
201 scsi_req_ref(req);
202 rc = req->ops->send_command(req, buf);
203 scsi_req_unref(req);
204 return rc;
207 static void scsi_req_dequeue(SCSIRequest *req)
209 trace_scsi_req_dequeue(req->dev->id, req->lun, req->tag);
210 if (req->enqueued) {
211 QTAILQ_REMOVE(&req->dev->requests, req, next);
212 req->enqueued = false;
213 scsi_req_unref(req);
217 static int scsi_req_length(SCSIRequest *req, uint8_t *cmd)
219 switch (cmd[0] >> 5) {
220 case 0:
221 req->cmd.xfer = cmd[4];
222 req->cmd.len = 6;
223 /* length 0 means 256 blocks */
224 if (req->cmd.xfer == 0)
225 req->cmd.xfer = 256;
226 break;
227 case 1:
228 case 2:
229 req->cmd.xfer = cmd[8] | (cmd[7] << 8);
230 req->cmd.len = 10;
231 break;
232 case 4:
233 req->cmd.xfer = cmd[13] | (cmd[12] << 8) | (cmd[11] << 16) | (cmd[10] << 24);
234 req->cmd.len = 16;
235 break;
236 case 5:
237 req->cmd.xfer = cmd[9] | (cmd[8] << 8) | (cmd[7] << 16) | (cmd[6] << 24);
238 req->cmd.len = 12;
239 break;
240 default:
241 trace_scsi_req_parse_bad(req->dev->id, req->lun, req->tag, cmd[0]);
242 return -1;
245 switch(cmd[0]) {
246 case TEST_UNIT_READY:
247 case REWIND:
248 case START_STOP:
249 case SEEK_6:
250 case WRITE_FILEMARKS:
251 case SPACE:
252 case RESERVE:
253 case RELEASE:
254 case ERASE:
255 case ALLOW_MEDIUM_REMOVAL:
256 case VERIFY_10:
257 case SEEK_10:
258 case SYNCHRONIZE_CACHE:
259 case LOCK_UNLOCK_CACHE:
260 case LOAD_UNLOAD:
261 case SET_CD_SPEED:
262 case SET_LIMITS:
263 case WRITE_LONG_10:
264 case MOVE_MEDIUM:
265 case UPDATE_BLOCK:
266 req->cmd.xfer = 0;
267 break;
268 case MODE_SENSE:
269 break;
270 case WRITE_SAME_10:
271 req->cmd.xfer = 1;
272 break;
273 case READ_CAPACITY_10:
274 req->cmd.xfer = 8;
275 break;
276 case READ_BLOCK_LIMITS:
277 req->cmd.xfer = 6;
278 break;
279 case READ_POSITION:
280 req->cmd.xfer = 20;
281 break;
282 case SEND_VOLUME_TAG:
283 req->cmd.xfer *= 40;
284 break;
285 case MEDIUM_SCAN:
286 req->cmd.xfer *= 8;
287 break;
288 case WRITE_10:
289 case WRITE_VERIFY_10:
290 case WRITE_6:
291 case WRITE_12:
292 case WRITE_VERIFY_12:
293 case WRITE_16:
294 case WRITE_VERIFY_16:
295 req->cmd.xfer *= req->dev->blocksize;
296 break;
297 case READ_10:
298 case READ_6:
299 case READ_REVERSE:
300 case RECOVER_BUFFERED_DATA:
301 case READ_12:
302 case READ_16:
303 req->cmd.xfer *= req->dev->blocksize;
304 break;
305 case INQUIRY:
306 req->cmd.xfer = cmd[4] | (cmd[3] << 8);
307 break;
308 case MAINTENANCE_OUT:
309 case MAINTENANCE_IN:
310 if (req->dev->type == TYPE_ROM) {
311 /* GPCMD_REPORT_KEY and GPCMD_SEND_KEY from multi media commands */
312 req->cmd.xfer = cmd[9] | (cmd[8] << 8);
314 break;
316 return 0;
319 static int scsi_req_stream_length(SCSIRequest *req, uint8_t *cmd)
321 switch(cmd[0]) {
322 /* stream commands */
323 case READ_6:
324 case READ_REVERSE:
325 case RECOVER_BUFFERED_DATA:
326 case WRITE_6:
327 req->cmd.len = 6;
328 req->cmd.xfer = cmd[4] | (cmd[3] << 8) | (cmd[2] << 16);
329 if (cmd[1] & 0x01) /* fixed */
330 req->cmd.xfer *= req->dev->blocksize;
331 break;
332 case REWIND:
333 case START_STOP:
334 req->cmd.len = 6;
335 req->cmd.xfer = 0;
336 break;
337 /* generic commands */
338 default:
339 return scsi_req_length(req, cmd);
341 return 0;
344 static void scsi_req_xfer_mode(SCSIRequest *req)
346 switch (req->cmd.buf[0]) {
347 case WRITE_6:
348 case WRITE_10:
349 case WRITE_VERIFY_10:
350 case WRITE_12:
351 case WRITE_VERIFY_12:
352 case WRITE_16:
353 case WRITE_VERIFY_16:
354 case COPY:
355 case COPY_VERIFY:
356 case COMPARE:
357 case CHANGE_DEFINITION:
358 case LOG_SELECT:
359 case MODE_SELECT:
360 case MODE_SELECT_10:
361 case SEND_DIAGNOSTIC:
362 case WRITE_BUFFER:
363 case FORMAT_UNIT:
364 case REASSIGN_BLOCKS:
365 case SEARCH_EQUAL:
366 case SEARCH_HIGH:
367 case SEARCH_LOW:
368 case UPDATE_BLOCK:
369 case WRITE_LONG_10:
370 case WRITE_SAME_10:
371 case SEARCH_HIGH_12:
372 case SEARCH_EQUAL_12:
373 case SEARCH_LOW_12:
374 case MEDIUM_SCAN:
375 case SEND_VOLUME_TAG:
376 case PERSISTENT_RESERVE_OUT:
377 case MAINTENANCE_OUT:
378 req->cmd.mode = SCSI_XFER_TO_DEV;
379 break;
380 default:
381 if (req->cmd.xfer)
382 req->cmd.mode = SCSI_XFER_FROM_DEV;
383 else {
384 req->cmd.mode = SCSI_XFER_NONE;
386 break;
390 static uint64_t scsi_req_lba(SCSIRequest *req)
392 uint8_t *buf = req->cmd.buf;
393 uint64_t lba;
395 switch (buf[0] >> 5) {
396 case 0:
397 lba = (uint64_t) buf[3] | ((uint64_t) buf[2] << 8) |
398 (((uint64_t) buf[1] & 0x1f) << 16);
399 break;
400 case 1:
401 case 2:
402 lba = (uint64_t) buf[5] | ((uint64_t) buf[4] << 8) |
403 ((uint64_t) buf[3] << 16) | ((uint64_t) buf[2] << 24);
404 break;
405 case 4:
406 lba = (uint64_t) buf[9] | ((uint64_t) buf[8] << 8) |
407 ((uint64_t) buf[7] << 16) | ((uint64_t) buf[6] << 24) |
408 ((uint64_t) buf[5] << 32) | ((uint64_t) buf[4] << 40) |
409 ((uint64_t) buf[3] << 48) | ((uint64_t) buf[2] << 56);
410 break;
411 case 5:
412 lba = (uint64_t) buf[5] | ((uint64_t) buf[4] << 8) |
413 ((uint64_t) buf[3] << 16) | ((uint64_t) buf[2] << 24);
414 break;
415 default:
416 lba = -1;
419 return lba;
422 int scsi_req_parse(SCSIRequest *req, uint8_t *buf)
424 int rc;
426 if (req->dev->type == TYPE_TAPE) {
427 rc = scsi_req_stream_length(req, buf);
428 } else {
429 rc = scsi_req_length(req, buf);
431 if (rc != 0)
432 return rc;
434 memcpy(req->cmd.buf, buf, req->cmd.len);
435 scsi_req_xfer_mode(req);
436 req->cmd.lba = scsi_req_lba(req);
437 trace_scsi_req_parsed(req->dev->id, req->lun, req->tag, buf[0],
438 req->cmd.mode, req->cmd.xfer);
439 if (req->cmd.lba != -1) {
440 trace_scsi_req_parsed_lba(req->dev->id, req->lun, req->tag, buf[0],
441 req->cmd.lba);
443 return 0;
447 * Predefined sense codes
450 /* No sense data available */
451 const struct SCSISense sense_code_NO_SENSE = {
452 .key = NO_SENSE , .asc = 0x00 , .ascq = 0x00
455 /* LUN not ready, Manual intervention required */
456 const struct SCSISense sense_code_LUN_NOT_READY = {
457 .key = NOT_READY, .asc = 0x04, .ascq = 0x03
460 /* LUN not ready, Medium not present */
461 const struct SCSISense sense_code_NO_MEDIUM = {
462 .key = NOT_READY, .asc = 0x3a, .ascq = 0x00
465 /* Hardware error, internal target failure */
466 const struct SCSISense sense_code_TARGET_FAILURE = {
467 .key = HARDWARE_ERROR, .asc = 0x44, .ascq = 0x00
470 /* Illegal request, invalid command operation code */
471 const struct SCSISense sense_code_INVALID_OPCODE = {
472 .key = ILLEGAL_REQUEST, .asc = 0x20, .ascq = 0x00
475 /* Illegal request, LBA out of range */
476 const struct SCSISense sense_code_LBA_OUT_OF_RANGE = {
477 .key = ILLEGAL_REQUEST, .asc = 0x21, .ascq = 0x00
480 /* Illegal request, Invalid field in CDB */
481 const struct SCSISense sense_code_INVALID_FIELD = {
482 .key = ILLEGAL_REQUEST, .asc = 0x24, .ascq = 0x00
485 /* Illegal request, LUN not supported */
486 const struct SCSISense sense_code_LUN_NOT_SUPPORTED = {
487 .key = ILLEGAL_REQUEST, .asc = 0x25, .ascq = 0x00
490 /* Command aborted, I/O process terminated */
491 const struct SCSISense sense_code_IO_ERROR = {
492 .key = ABORTED_COMMAND, .asc = 0x00, .ascq = 0x06
495 /* Command aborted, I_T Nexus loss occurred */
496 const struct SCSISense sense_code_I_T_NEXUS_LOSS = {
497 .key = ABORTED_COMMAND, .asc = 0x29, .ascq = 0x07
500 /* Command aborted, Logical Unit failure */
501 const struct SCSISense sense_code_LUN_FAILURE = {
502 .key = ABORTED_COMMAND, .asc = 0x3e, .ascq = 0x01
506 * scsi_build_sense
508 * Convert between fixed and descriptor sense buffers
510 int scsi_build_sense(uint8_t *in_buf, int in_len,
511 uint8_t *buf, int len, bool fixed)
513 bool fixed_in;
514 SCSISense sense;
515 if (!fixed && len < 8) {
516 return 0;
519 if (in_len == 0) {
520 sense.key = NO_SENSE;
521 sense.asc = 0;
522 sense.ascq = 0;
523 } else {
524 fixed_in = (in_buf[0] & 2) == 0;
526 if (fixed == fixed_in) {
527 memcpy(buf, in_buf, MIN(len, in_len));
528 return MIN(len, in_len);
531 if (fixed_in) {
532 sense.key = in_buf[2];
533 sense.asc = in_buf[12];
534 sense.ascq = in_buf[13];
535 } else {
536 sense.key = in_buf[1];
537 sense.asc = in_buf[2];
538 sense.ascq = in_buf[3];
542 memset(buf, 0, len);
543 if (fixed) {
544 /* Return fixed format sense buffer */
545 buf[0] = 0xf0;
546 buf[2] = sense.key;
547 buf[7] = 7;
548 buf[12] = sense.asc;
549 buf[13] = sense.ascq;
550 return MIN(len, 18);
551 } else {
552 /* Return descriptor format sense buffer */
553 buf[0] = 0x72;
554 buf[1] = sense.key;
555 buf[2] = sense.asc;
556 buf[3] = sense.ascq;
557 return 8;
561 static const char *scsi_command_name(uint8_t cmd)
563 static const char *names[] = {
564 [ TEST_UNIT_READY ] = "TEST_UNIT_READY",
565 [ REWIND ] = "REWIND",
566 [ REQUEST_SENSE ] = "REQUEST_SENSE",
567 [ FORMAT_UNIT ] = "FORMAT_UNIT",
568 [ READ_BLOCK_LIMITS ] = "READ_BLOCK_LIMITS",
569 [ REASSIGN_BLOCKS ] = "REASSIGN_BLOCKS",
570 [ READ_6 ] = "READ_6",
571 [ WRITE_6 ] = "WRITE_6",
572 [ SEEK_6 ] = "SEEK_6",
573 [ READ_REVERSE ] = "READ_REVERSE",
574 [ WRITE_FILEMARKS ] = "WRITE_FILEMARKS",
575 [ SPACE ] = "SPACE",
576 [ INQUIRY ] = "INQUIRY",
577 [ RECOVER_BUFFERED_DATA ] = "RECOVER_BUFFERED_DATA",
578 [ MAINTENANCE_IN ] = "MAINTENANCE_IN",
579 [ MAINTENANCE_OUT ] = "MAINTENANCE_OUT",
580 [ MODE_SELECT ] = "MODE_SELECT",
581 [ RESERVE ] = "RESERVE",
582 [ RELEASE ] = "RELEASE",
583 [ COPY ] = "COPY",
584 [ ERASE ] = "ERASE",
585 [ MODE_SENSE ] = "MODE_SENSE",
586 [ START_STOP ] = "START_STOP",
587 [ RECEIVE_DIAGNOSTIC ] = "RECEIVE_DIAGNOSTIC",
588 [ SEND_DIAGNOSTIC ] = "SEND_DIAGNOSTIC",
589 [ ALLOW_MEDIUM_REMOVAL ] = "ALLOW_MEDIUM_REMOVAL",
590 [ READ_CAPACITY_10 ] = "READ_CAPACITY_10",
591 [ READ_10 ] = "READ_10",
592 [ WRITE_10 ] = "WRITE_10",
593 [ SEEK_10 ] = "SEEK_10",
594 [ WRITE_VERIFY_10 ] = "WRITE_VERIFY_10",
595 [ VERIFY_10 ] = "VERIFY_10",
596 [ SEARCH_HIGH ] = "SEARCH_HIGH",
597 [ SEARCH_EQUAL ] = "SEARCH_EQUAL",
598 [ SEARCH_LOW ] = "SEARCH_LOW",
599 [ SET_LIMITS ] = "SET_LIMITS",
600 [ PRE_FETCH ] = "PRE_FETCH",
601 /* READ_POSITION and PRE_FETCH use the same operation code */
602 [ SYNCHRONIZE_CACHE ] = "SYNCHRONIZE_CACHE",
603 [ LOCK_UNLOCK_CACHE ] = "LOCK_UNLOCK_CACHE",
604 [ READ_DEFECT_DATA ] = "READ_DEFECT_DATA",
605 [ MEDIUM_SCAN ] = "MEDIUM_SCAN",
606 [ COMPARE ] = "COMPARE",
607 [ COPY_VERIFY ] = "COPY_VERIFY",
608 [ WRITE_BUFFER ] = "WRITE_BUFFER",
609 [ READ_BUFFER ] = "READ_BUFFER",
610 [ UPDATE_BLOCK ] = "UPDATE_BLOCK",
611 [ READ_LONG_10 ] = "READ_LONG_10",
612 [ WRITE_LONG_10 ] = "WRITE_LONG_10",
613 [ CHANGE_DEFINITION ] = "CHANGE_DEFINITION",
614 [ WRITE_SAME_10 ] = "WRITE_SAME_10",
615 [ UNMAP ] = "UNMAP",
616 [ READ_TOC ] = "READ_TOC",
617 [ REPORT_DENSITY_SUPPORT ] = "REPORT_DENSITY_SUPPORT",
618 [ GET_CONFIGURATION ] = "GET_CONFIGURATION",
619 [ LOG_SELECT ] = "LOG_SELECT",
620 [ LOG_SENSE ] = "LOG_SENSE",
621 [ MODE_SELECT_10 ] = "MODE_SELECT_10",
622 [ RESERVE_10 ] = "RESERVE_10",
623 [ RELEASE_10 ] = "RELEASE_10",
624 [ MODE_SENSE_10 ] = "MODE_SENSE_10",
625 [ PERSISTENT_RESERVE_IN ] = "PERSISTENT_RESERVE_IN",
626 [ PERSISTENT_RESERVE_OUT ] = "PERSISTENT_RESERVE_OUT",
627 [ WRITE_FILEMARKS_16 ] = "WRITE_FILEMARKS_16",
628 [ EXTENDED_COPY ] = "EXTENDED_COPY",
629 [ ATA_PASSTHROUGH ] = "ATA_PASSTHROUGH",
630 [ ACCESS_CONTROL_IN ] = "ACCESS_CONTROL_IN",
631 [ ACCESS_CONTROL_OUT ] = "ACCESS_CONTROL_OUT",
632 [ READ_16 ] = "READ_16",
633 [ COMPARE_AND_WRITE ] = "COMPARE_AND_WRITE",
634 [ WRITE_16 ] = "WRITE_16",
635 [ WRITE_VERIFY_16 ] = "WRITE_VERIFY_16",
636 [ VERIFY_16 ] = "VERIFY_16",
637 [ SYNCHRONIZE_CACHE_16 ] = "SYNCHRONIZE_CACHE_16",
638 [ LOCATE_16 ] = "LOCATE_16",
639 [ WRITE_SAME_16 ] = "WRITE_SAME_16",
640 [ ERASE_16 ] = "ERASE_16",
641 [ SERVICE_ACTION_IN ] = "SERVICE_ACTION_IN",
642 [ WRITE_LONG_16 ] = "WRITE_LONG_16",
643 [ REPORT_LUNS ] = "REPORT_LUNS",
644 [ BLANK ] = "BLANK",
645 [ MAINTENANCE_IN ] = "MAINTENANCE_IN",
646 [ MAINTENANCE_OUT ] = "MAINTENANCE_OUT",
647 [ MOVE_MEDIUM ] = "MOVE_MEDIUM",
648 [ LOAD_UNLOAD ] = "LOAD_UNLOAD",
649 [ READ_12 ] = "READ_12",
650 [ WRITE_12 ] = "WRITE_12",
651 [ WRITE_VERIFY_12 ] = "WRITE_VERIFY_12",
652 [ VERIFY_12 ] = "VERIFY_12",
653 [ SEARCH_HIGH_12 ] = "SEARCH_HIGH_12",
654 [ SEARCH_EQUAL_12 ] = "SEARCH_EQUAL_12",
655 [ SEARCH_LOW_12 ] = "SEARCH_LOW_12",
656 [ READ_ELEMENT_STATUS ] = "READ_ELEMENT_STATUS",
657 [ SEND_VOLUME_TAG ] = "SEND_VOLUME_TAG",
658 [ READ_DEFECT_DATA_12 ] = "READ_DEFECT_DATA_12",
659 [ SET_CD_SPEED ] = "SET_CD_SPEED",
662 if (cmd >= ARRAY_SIZE(names) || names[cmd] == NULL)
663 return "*UNKNOWN*";
664 return names[cmd];
667 SCSIRequest *scsi_req_ref(SCSIRequest *req)
669 req->refcount++;
670 return req;
673 void scsi_req_unref(SCSIRequest *req)
675 if (--req->refcount == 0) {
676 if (req->ops->free_req) {
677 req->ops->free_req(req);
679 qemu_free(req);
683 /* Tell the device that we finished processing this chunk of I/O. It
684 will start the next chunk or complete the command. */
685 void scsi_req_continue(SCSIRequest *req)
687 trace_scsi_req_continue(req->dev->id, req->lun, req->tag);
688 if (req->cmd.mode == SCSI_XFER_TO_DEV) {
689 req->ops->write_data(req);
690 } else {
691 req->ops->read_data(req);
695 /* Called by the devices when data is ready for the HBA. The HBA should
696 start a DMA operation to read or fill the device's data buffer.
697 Once it completes, calling scsi_req_continue will restart I/O. */
698 void scsi_req_data(SCSIRequest *req, int len)
700 trace_scsi_req_data(req->dev->id, req->lun, req->tag, len);
701 req->bus->ops->transfer_data(req, len);
704 void scsi_req_print(SCSIRequest *req)
706 FILE *fp = stderr;
707 int i;
709 fprintf(fp, "[%s id=%d] %s",
710 req->dev->qdev.parent_bus->name,
711 req->dev->id,
712 scsi_command_name(req->cmd.buf[0]));
713 for (i = 1; i < req->cmd.len; i++) {
714 fprintf(fp, " 0x%02x", req->cmd.buf[i]);
716 switch (req->cmd.mode) {
717 case SCSI_XFER_NONE:
718 fprintf(fp, " - none\n");
719 break;
720 case SCSI_XFER_FROM_DEV:
721 fprintf(fp, " - from-dev len=%zd\n", req->cmd.xfer);
722 break;
723 case SCSI_XFER_TO_DEV:
724 fprintf(fp, " - to-dev len=%zd\n", req->cmd.xfer);
725 break;
726 default:
727 fprintf(fp, " - Oops\n");
728 break;
732 void scsi_req_complete(SCSIRequest *req, int status)
734 assert(req->status == -1);
735 req->status = status;
737 assert(req->sense_len < sizeof(req->sense));
738 if (status == GOOD) {
739 req->sense_len = 0;
742 if (req->sense_len) {
743 memcpy(req->dev->sense, req->sense, req->sense_len);
745 req->dev->sense_len = req->sense_len;
747 scsi_req_ref(req);
748 scsi_req_dequeue(req);
749 req->bus->ops->complete(req, req->status);
750 scsi_req_unref(req);
753 void scsi_req_cancel(SCSIRequest *req)
755 if (req->ops->cancel_io) {
756 req->ops->cancel_io(req);
758 scsi_req_ref(req);
759 scsi_req_dequeue(req);
760 if (req->bus->ops->cancel) {
761 req->bus->ops->cancel(req);
763 scsi_req_unref(req);
766 void scsi_req_abort(SCSIRequest *req, int status)
768 if (req->ops->cancel_io) {
769 req->ops->cancel_io(req);
771 scsi_req_complete(req, status);
774 void scsi_device_purge_requests(SCSIDevice *sdev)
776 SCSIRequest *req;
778 while (!QTAILQ_EMPTY(&sdev->requests)) {
779 req = QTAILQ_FIRST(&sdev->requests);
780 scsi_req_cancel(req);
784 static char *scsibus_get_fw_dev_path(DeviceState *dev)
786 SCSIDevice *d = DO_UPCAST(SCSIDevice, qdev, dev);
787 SCSIBus *bus = scsi_bus_from_device(d);
788 char path[100];
789 int i;
791 for (i = 0; i < bus->ndev; i++) {
792 if (bus->devs[i] == d) {
793 break;
797 assert(i != bus->ndev);
799 snprintf(path, sizeof(path), "%s@%x", qdev_fw_name(dev), i);
801 return strdup(path);