blockdev: Store -drive option media in DriveInfo
[qemu.git] / hw / scsi-disk.c
1 /*
2 * SCSI Device emulation
3 *
4 * Copyright (c) 2006 CodeSourcery.
5 * Based on code by Fabrice Bellard
6 *
7 * Written by Paul Brook
8 * Modifications:
9 * 2009-Dec-12 Artyom Tarasenko : implemented stamdard inquiry for the case
10 * when the allocation length of CDB is smaller
11 * than 36.
12 * 2009-Oct-13 Artyom Tarasenko : implemented the block descriptor in the
13 * MODE SENSE response.
14 *
15 * This code is licenced under the LGPL.
16 *
17 * Note that this file only handles the SCSI architecture model and device
18 * commands. Emulation of interface/link layer protocols is handled by
19 * the host adapter emulator.
20 */
21
22 //#define DEBUG_SCSI
23
24 #ifdef DEBUG_SCSI
25 #define DPRINTF(fmt, ...) \
26 do { printf("scsi-disk: " fmt , ## __VA_ARGS__); } while (0)
27 #else
28 #define DPRINTF(fmt, ...) do {} while(0)
29 #endif
30
31 #define BADF(fmt, ...) \
32 do { fprintf(stderr, "scsi-disk: " fmt , ## __VA_ARGS__); } while (0)
33
34 #include "qemu-common.h"
35 #include "qemu-error.h"
36 #include "scsi.h"
37 #include "scsi-defs.h"
38 #include "sysemu.h"
39 #include "blockdev.h"
40
41 #define SCSI_DMA_BUF_SIZE 131072
42 #define SCSI_MAX_INQUIRY_LEN 256
43
44 #define SCSI_REQ_STATUS_RETRY 0x01
45 #define SCSI_REQ_STATUS_RETRY_TYPE_MASK 0x06
46 #define SCSI_REQ_STATUS_RETRY_READ 0x00
47 #define SCSI_REQ_STATUS_RETRY_WRITE 0x02
48 #define SCSI_REQ_STATUS_RETRY_FLUSH 0x04
49
50 typedef struct SCSIDiskState SCSIDiskState;
51
52 typedef struct SCSISense {
53 uint8_t key;
54 } SCSISense;
55
56 typedef struct SCSIDiskReq {
57 SCSIRequest req;
58 /* ??? We should probably keep track of whether the data transfer is
59 a read or a write. Currently we rely on the host getting it right. */
60 /* Both sector and sector_count are in terms of qemu 512 byte blocks. */
61 uint64_t sector;
62 uint32_t sector_count;
63 struct iovec iov;
64 QEMUIOVector qiov;
65 uint32_t status;
66 } SCSIDiskReq;
67
68 typedef enum { SCSI_HD, SCSI_CD } SCSIDriveKind;
69
70 struct SCSIDiskState
71 {
72 SCSIDevice qdev;
73 BlockDriverState *bs;
74 /* The qemu block layer uses a fixed 512 byte sector size.
75 This is the number of 512 byte blocks in a single scsi sector. */
76 int cluster_size;
77 uint32_t removable;
78 uint64_t max_lba;
79 QEMUBH *bh;
80 char *version;
81 char *serial;
82 SCSISense sense;
83 SCSIDriveKind drive_kind;
84 };
85
86 static int scsi_handle_rw_error(SCSIDiskReq *r, int error, int type);
87 static int scsi_disk_emulate_command(SCSIDiskReq *r, uint8_t *outbuf);
88
89 static SCSIDiskReq *scsi_new_request(SCSIDiskState *s, uint32_t tag,
90 uint32_t lun)
91 {
92 SCSIRequest *req;
93 SCSIDiskReq *r;
94
95 req = scsi_req_alloc(sizeof(SCSIDiskReq), &s->qdev, tag, lun);
96 r = DO_UPCAST(SCSIDiskReq, req, req);
97 r->iov.iov_base = qemu_blockalign(s->bs, SCSI_DMA_BUF_SIZE);
98 return r;
99 }
100
101 static void scsi_remove_request(SCSIDiskReq *r)
102 {
103 qemu_vfree(r->iov.iov_base);
104 scsi_req_free(&r->req);
105 }
106
107 static SCSIDiskReq *scsi_find_request(SCSIDiskState *s, uint32_t tag)
108 {
109 return DO_UPCAST(SCSIDiskReq, req, scsi_req_find(&s->qdev, tag));
110 }
111
112 static void scsi_disk_clear_sense(SCSIDiskState *s)
113 {
114 memset(&s->sense, 0, sizeof(s->sense));
115 }
116
117 static void scsi_disk_set_sense(SCSIDiskState *s, uint8_t key)
118 {
119 s->sense.key = key;
120 }
121
122 static void scsi_req_set_status(SCSIDiskReq *r, int status, int sense_code)
123 {
124 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
125
126 r->req.status = status;
127 scsi_disk_set_sense(s, sense_code);
128 }
129
130 /* Helper function for command completion. */
131 static void scsi_command_complete(SCSIDiskReq *r, int status, int sense)
132 {
133 DPRINTF("Command complete tag=0x%x status=%d sense=%d\n",
134 r->req.tag, status, sense);
135 scsi_req_set_status(r, status, sense);
136 scsi_req_complete(&r->req);
137 scsi_remove_request(r);
138 }
139
140 /* Cancel a pending data transfer. */
141 static void scsi_cancel_io(SCSIDevice *d, uint32_t tag)
142 {
143 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
144 SCSIDiskReq *r;
145 DPRINTF("Cancel tag=0x%x\n", tag);
146 r = scsi_find_request(s, tag);
147 if (r) {
148 if (r->req.aiocb)
149 bdrv_aio_cancel(r->req.aiocb);
150 r->req.aiocb = NULL;
151 scsi_remove_request(r);
152 }
153 }
154
155 static void scsi_read_complete(void * opaque, int ret)
156 {
157 SCSIDiskReq *r = (SCSIDiskReq *)opaque;
158 int n;
159
160 r->req.aiocb = NULL;
161
162 if (ret) {
163 if (scsi_handle_rw_error(r, -ret, SCSI_REQ_STATUS_RETRY_READ)) {
164 return;
165 }
166 }
167
168 DPRINTF("Data ready tag=0x%x len=%zd\n", r->req.tag, r->iov.iov_len);
169
170 n = r->iov.iov_len / 512;
171 r->sector += n;
172 r->sector_count -= n;
173 r->req.bus->complete(r->req.bus, SCSI_REASON_DATA, r->req.tag, r->iov.iov_len);
174 }
175
176
177 static void scsi_read_request(SCSIDiskReq *r)
178 {
179 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
180 uint32_t n;
181
182 if (r->sector_count == (uint32_t)-1) {
183 DPRINTF("Read buf_len=%zd\n", r->iov.iov_len);
184 r->sector_count = 0;
185 r->req.bus->complete(r->req.bus, SCSI_REASON_DATA, r->req.tag, r->iov.iov_len);
186 return;
187 }
188 DPRINTF("Read sector_count=%d\n", r->sector_count);
189 if (r->sector_count == 0) {
190 scsi_command_complete(r, GOOD, NO_SENSE);
191 return;
192 }
193
194 /* No data transfer may already be in progress */
195 assert(r->req.aiocb == NULL);
196
197 n = r->sector_count;
198 if (n > SCSI_DMA_BUF_SIZE / 512)
199 n = SCSI_DMA_BUF_SIZE / 512;
200
201 r->iov.iov_len = n * 512;
202 qemu_iovec_init_external(&r->qiov, &r->iov, 1);
203 r->req.aiocb = bdrv_aio_readv(s->bs, r->sector, &r->qiov, n,
204 scsi_read_complete, r);
205 if (r->req.aiocb == NULL) {
206 scsi_read_complete(r, -EIO);
207 }
208 }
209
210 /* Read more data from scsi device into buffer. */
211 static void scsi_read_data(SCSIDevice *d, uint32_t tag)
212 {
213 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
214 SCSIDiskReq *r;
215
216 r = scsi_find_request(s, tag);
217 if (!r) {
218 BADF("Bad read tag 0x%x\n", tag);
219 /* ??? This is the wrong error. */
220 scsi_command_complete(r, CHECK_CONDITION, HARDWARE_ERROR);
221 return;
222 }
223
224 scsi_read_request(r);
225 }
226
227 static int scsi_handle_rw_error(SCSIDiskReq *r, int error, int type)
228 {
229 int is_read = (type == SCSI_REQ_STATUS_RETRY_READ);
230 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
231 BlockErrorAction action = bdrv_get_on_error(s->bs, is_read);
232
233 if (action == BLOCK_ERR_IGNORE) {
234 bdrv_mon_event(s->bs, BDRV_ACTION_IGNORE, is_read);
235 return 0;
236 }
237
238 if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)
239 || action == BLOCK_ERR_STOP_ANY) {
240
241 type &= SCSI_REQ_STATUS_RETRY_TYPE_MASK;
242 r->status |= SCSI_REQ_STATUS_RETRY | type;
243
244 bdrv_mon_event(s->bs, BDRV_ACTION_STOP, is_read);
245 vm_stop(VMSTOP_DISKFULL);
246 } else {
247 if (type == SCSI_REQ_STATUS_RETRY_READ) {
248 r->req.bus->complete(r->req.bus, SCSI_REASON_DATA, r->req.tag, 0);
249 }
250 scsi_command_complete(r, CHECK_CONDITION,
251 HARDWARE_ERROR);
252 bdrv_mon_event(s->bs, BDRV_ACTION_REPORT, is_read);
253 }
254
255 return 1;
256 }
257
258 static void scsi_write_complete(void * opaque, int ret)
259 {
260 SCSIDiskReq *r = (SCSIDiskReq *)opaque;
261 uint32_t len;
262 uint32_t n;
263
264 r->req.aiocb = NULL;
265
266 if (ret) {
267 if (scsi_handle_rw_error(r, -ret, SCSI_REQ_STATUS_RETRY_WRITE)) {
268 return;
269 }
270 }
271
272 n = r->iov.iov_len / 512;
273 r->sector += n;
274 r->sector_count -= n;
275 if (r->sector_count == 0) {
276 scsi_command_complete(r, GOOD, NO_SENSE);
277 } else {
278 len = r->sector_count * 512;
279 if (len > SCSI_DMA_BUF_SIZE) {
280 len = SCSI_DMA_BUF_SIZE;
281 }
282 r->iov.iov_len = len;
283 DPRINTF("Write complete tag=0x%x more=%d\n", r->req.tag, len);
284 r->req.bus->complete(r->req.bus, SCSI_REASON_DATA, r->req.tag, len);
285 }
286 }
287
288 static void scsi_write_request(SCSIDiskReq *r)
289 {
290 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
291 uint32_t n;
292
293 /* No data transfer may already be in progress */
294 assert(r->req.aiocb == NULL);
295
296 n = r->iov.iov_len / 512;
297 if (n) {
298 qemu_iovec_init_external(&r->qiov, &r->iov, 1);
299 r->req.aiocb = bdrv_aio_writev(s->bs, r->sector, &r->qiov, n,
300 scsi_write_complete, r);
301 if (r->req.aiocb == NULL) {
302 scsi_write_complete(r, -EIO);
303 }
304 } else {
305 /* Invoke completion routine to fetch data from host. */
306 scsi_write_complete(r, 0);
307 }
308 }
309
310 /* Write data to a scsi device. Returns nonzero on failure.
311 The transfer may complete asynchronously. */
312 static int scsi_write_data(SCSIDevice *d, uint32_t tag)
313 {
314 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
315 SCSIDiskReq *r;
316
317 DPRINTF("Write data tag=0x%x\n", tag);
318 r = scsi_find_request(s, tag);
319 if (!r) {
320 BADF("Bad write tag 0x%x\n", tag);
321 scsi_command_complete(r, CHECK_CONDITION, HARDWARE_ERROR);
322 return 1;
323 }
324
325 scsi_write_request(r);
326
327 return 0;
328 }
329
330 static void scsi_dma_restart_bh(void *opaque)
331 {
332 SCSIDiskState *s = opaque;
333 SCSIRequest *req;
334 SCSIDiskReq *r;
335
336 qemu_bh_delete(s->bh);
337 s->bh = NULL;
338
339 QTAILQ_FOREACH(req, &s->qdev.requests, next) {
340 r = DO_UPCAST(SCSIDiskReq, req, req);
341 if (r->status & SCSI_REQ_STATUS_RETRY) {
342 int status = r->status;
343 int ret;
344
345 r->status &=
346 ~(SCSI_REQ_STATUS_RETRY | SCSI_REQ_STATUS_RETRY_TYPE_MASK);
347
348 switch (status & SCSI_REQ_STATUS_RETRY_TYPE_MASK) {
349 case SCSI_REQ_STATUS_RETRY_READ:
350 scsi_read_request(r);
351 break;
352 case SCSI_REQ_STATUS_RETRY_WRITE:
353 scsi_write_request(r);
354 break;
355 case SCSI_REQ_STATUS_RETRY_FLUSH:
356 ret = scsi_disk_emulate_command(r, r->iov.iov_base);
357 if (ret == 0) {
358 scsi_command_complete(r, GOOD, NO_SENSE);
359 }
360 }
361 }
362 }
363 }
364
365 static void scsi_dma_restart_cb(void *opaque, int running, int reason)
366 {
367 SCSIDiskState *s = opaque;
368
369 if (!running)
370 return;
371
372 if (!s->bh) {
373 s->bh = qemu_bh_new(scsi_dma_restart_bh, s);
374 qemu_bh_schedule(s->bh);
375 }
376 }
377
378 /* Return a pointer to the data buffer. */
379 static uint8_t *scsi_get_buf(SCSIDevice *d, uint32_t tag)
380 {
381 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
382 SCSIDiskReq *r;
383
384 r = scsi_find_request(s, tag);
385 if (!r) {
386 BADF("Bad buffer tag 0x%x\n", tag);
387 return NULL;
388 }
389 return (uint8_t *)r->iov.iov_base;
390 }
391
392 static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
393 {
394 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
395 int buflen = 0;
396
397 if (req->cmd.buf[1] & 0x2) {
398 /* Command support data - optional, not implemented */
399 BADF("optional INQUIRY command support request not implemented\n");
400 return -1;
401 }
402
403 if (req->cmd.buf[1] & 0x1) {
404 /* Vital product data */
405 uint8_t page_code = req->cmd.buf[2];
406 if (req->cmd.xfer < 4) {
407 BADF("Error: Inquiry (EVPD[%02X]) buffer size %zd is "
408 "less than 4\n", page_code, req->cmd.xfer);
409 return -1;
410 }
411
412 if (s->drive_kind == SCSI_CD) {
413 outbuf[buflen++] = 5;
414 } else {
415 outbuf[buflen++] = 0;
416 }
417 outbuf[buflen++] = page_code ; // this page
418 outbuf[buflen++] = 0x00;
419
420 switch (page_code) {
421 case 0x00: /* Supported page codes, mandatory */
422 {
423 int pages;
424 DPRINTF("Inquiry EVPD[Supported pages] "
425 "buffer size %zd\n", req->cmd.xfer);
426 pages = buflen++;
427 outbuf[buflen++] = 0x00; // list of supported pages (this page)
428 outbuf[buflen++] = 0x80; // unit serial number
429 outbuf[buflen++] = 0x83; // device identification
430 if (s->drive_kind == SCSI_HD) {
431 outbuf[buflen++] = 0xb0; // block limits
432 outbuf[buflen++] = 0xb2; // thin provisioning
433 }
434 outbuf[pages] = buflen - pages - 1; // number of pages
435 break;
436 }
437 case 0x80: /* Device serial number, optional */
438 {
439 int l = strlen(s->serial);
440
441 if (l > req->cmd.xfer)
442 l = req->cmd.xfer;
443 if (l > 20)
444 l = 20;
445
446 DPRINTF("Inquiry EVPD[Serial number] "
447 "buffer size %zd\n", req->cmd.xfer);
448 outbuf[buflen++] = l;
449 memcpy(outbuf+buflen, s->serial, l);
450 buflen += l;
451 break;
452 }
453
454 case 0x83: /* Device identification page, mandatory */
455 {
456 int max_len = 255 - 8;
457 int id_len = strlen(bdrv_get_device_name(s->bs));
458
459 if (id_len > max_len)
460 id_len = max_len;
461 DPRINTF("Inquiry EVPD[Device identification] "
462 "buffer size %zd\n", req->cmd.xfer);
463
464 outbuf[buflen++] = 4 + id_len;
465 outbuf[buflen++] = 0x2; // ASCII
466 outbuf[buflen++] = 0; // not officially assigned
467 outbuf[buflen++] = 0; // reserved
468 outbuf[buflen++] = id_len; // length of data following
469
470 memcpy(outbuf+buflen, bdrv_get_device_name(s->bs), id_len);
471 buflen += id_len;
472 break;
473 }
474 case 0xb0: /* block limits */
475 {
476 unsigned int unmap_sectors =
477 s->qdev.conf.discard_granularity / s->qdev.blocksize;
478 unsigned int min_io_size =
479 s->qdev.conf.min_io_size / s->qdev.blocksize;
480 unsigned int opt_io_size =
481 s->qdev.conf.opt_io_size / s->qdev.blocksize;
482
483 if (s->drive_kind == SCSI_CD) {
484 DPRINTF("Inquiry (EVPD[%02X] not supported for CDROM\n",
485 page_code);
486 return -1;
487 }
488 /* required VPD size with unmap support */
489 outbuf[3] = buflen = 0x3c;
490
491 memset(outbuf + 4, 0, buflen - 4);
492
493 /* optimal transfer length granularity */
494 outbuf[6] = (min_io_size >> 8) & 0xff;
495 outbuf[7] = min_io_size & 0xff;
496
497 /* optimal transfer length */
498 outbuf[12] = (opt_io_size >> 24) & 0xff;
499 outbuf[13] = (opt_io_size >> 16) & 0xff;
500 outbuf[14] = (opt_io_size >> 8) & 0xff;
501 outbuf[15] = opt_io_size & 0xff;
502
503 /* optimal unmap granularity */
504 outbuf[28] = (unmap_sectors >> 24) & 0xff;
505 outbuf[29] = (unmap_sectors >> 16) & 0xff;
506 outbuf[30] = (unmap_sectors >> 8) & 0xff;
507 outbuf[31] = unmap_sectors & 0xff;
508 break;
509 }
510 case 0xb2: /* thin provisioning */
511 {
512 outbuf[3] = buflen = 8;
513 outbuf[4] = 0;
514 outbuf[5] = 0x40; /* write same with unmap supported */
515 outbuf[6] = 0;
516 outbuf[7] = 0;
517 break;
518 }
519 default:
520 BADF("Error: unsupported Inquiry (EVPD[%02X]) "
521 "buffer size %zd\n", page_code, req->cmd.xfer);
522 return -1;
523 }
524 /* done with EVPD */
525 return buflen;
526 }
527
528 /* Standard INQUIRY data */
529 if (req->cmd.buf[2] != 0) {
530 BADF("Error: Inquiry (STANDARD) page or code "
531 "is non-zero [%02X]\n", req->cmd.buf[2]);
532 return -1;
533 }
534
535 /* PAGE CODE == 0 */
536 if (req->cmd.xfer < 5) {
537 BADF("Error: Inquiry (STANDARD) buffer size %zd "
538 "is less than 5\n", req->cmd.xfer);
539 return -1;
540 }
541
542 buflen = req->cmd.xfer;
543 if (buflen > SCSI_MAX_INQUIRY_LEN)
544 buflen = SCSI_MAX_INQUIRY_LEN;
545
546 memset(outbuf, 0, buflen);
547
548 if (req->lun || req->cmd.buf[1] >> 5) {
549 outbuf[0] = 0x7f; /* LUN not supported */
550 return buflen;
551 }
552
553 if (s->drive_kind == SCSI_CD) {
554 outbuf[0] = 5;
555 outbuf[1] = 0x80;
556 memcpy(&outbuf[16], "QEMU CD-ROM ", 16);
557 } else {
558 outbuf[0] = 0;
559 outbuf[1] = s->removable ? 0x80 : 0;
560 memcpy(&outbuf[16], "QEMU HARDDISK ", 16);
561 }
562 memcpy(&outbuf[8], "QEMU ", 8);
563 memset(&outbuf[32], 0, 4);
564 memcpy(&outbuf[32], s->version, MIN(4, strlen(s->version)));
565 /*
566 * We claim conformance to SPC-3, which is required for guests
567 * to ask for modern features like READ CAPACITY(16) or the
568 * block characteristics VPD page by default. Not all of SPC-3
569 * is actually implemented, but we're good enough.
570 */
571 outbuf[2] = 5;
572 outbuf[3] = 2; /* Format 2 */
573
574 if (buflen > 36) {
575 outbuf[4] = buflen - 5; /* Additional Length = (Len - 1) - 4 */
576 } else {
577 /* If the allocation length of CDB is too small,
578 the additional length is not adjusted */
579 outbuf[4] = 36 - 5;
580 }
581
582 /* Sync data transfer and TCQ. */
583 outbuf[7] = 0x10 | (req->bus->tcq ? 0x02 : 0);
584 return buflen;
585 }
586
587 static int mode_sense_page(SCSIRequest *req, int page, uint8_t *p,
588 int page_control)
589 {
590 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
591 BlockDriverState *bdrv = s->bs;
592 int cylinders, heads, secs;
593
594 /*
595 * If Changeable Values are requested, a mask denoting those mode parameters
596 * that are changeable shall be returned. As we currently don't support
597 * parameter changes via MODE_SELECT all bits are returned set to zero.
598 * The buffer was already menset to zero by the caller of this function.
599 */
600 switch (page) {
601 case 4: /* Rigid disk device geometry page. */
602 p[0] = 4;
603 p[1] = 0x16;
604 if (page_control == 1) { /* Changeable Values */
605 return p[1] + 2;
606 }
607 /* if a geometry hint is available, use it */
608 bdrv_get_geometry_hint(bdrv, &cylinders, &heads, &secs);
609 p[2] = (cylinders >> 16) & 0xff;
610 p[3] = (cylinders >> 8) & 0xff;
611 p[4] = cylinders & 0xff;
612 p[5] = heads & 0xff;
613 /* Write precomp start cylinder, disabled */
614 p[6] = (cylinders >> 16) & 0xff;
615 p[7] = (cylinders >> 8) & 0xff;
616 p[8] = cylinders & 0xff;
617 /* Reduced current start cylinder, disabled */
618 p[9] = (cylinders >> 16) & 0xff;
619 p[10] = (cylinders >> 8) & 0xff;
620 p[11] = cylinders & 0xff;
621 /* Device step rate [ns], 200ns */
622 p[12] = 0;
623 p[13] = 200;
624 /* Landing zone cylinder */
625 p[14] = 0xff;
626 p[15] = 0xff;
627 p[16] = 0xff;
628 /* Medium rotation rate [rpm], 5400 rpm */
629 p[20] = (5400 >> 8) & 0xff;
630 p[21] = 5400 & 0xff;
631 return p[1] + 2;
632
633 case 5: /* Flexible disk device geometry page. */
634 p[0] = 5;
635 p[1] = 0x1e;
636 if (page_control == 1) { /* Changeable Values */
637 return p[1] + 2;
638 }
639 /* Transfer rate [kbit/s], 5Mbit/s */
640 p[2] = 5000 >> 8;
641 p[3] = 5000 & 0xff;
642 /* if a geometry hint is available, use it */
643 bdrv_get_geometry_hint(bdrv, &cylinders, &heads, &secs);
644 p[4] = heads & 0xff;
645 p[5] = secs & 0xff;
646 p[6] = s->cluster_size * 2;
647 p[8] = (cylinders >> 8) & 0xff;
648 p[9] = cylinders & 0xff;
649 /* Write precomp start cylinder, disabled */
650 p[10] = (cylinders >> 8) & 0xff;
651 p[11] = cylinders & 0xff;
652 /* Reduced current start cylinder, disabled */
653 p[12] = (cylinders >> 8) & 0xff;
654 p[13] = cylinders & 0xff;
655 /* Device step rate [100us], 100us */
656 p[14] = 0;
657 p[15] = 1;
658 /* Device step pulse width [us], 1us */
659 p[16] = 1;
660 /* Device head settle delay [100us], 100us */
661 p[17] = 0;
662 p[18] = 1;
663 /* Motor on delay [0.1s], 0.1s */
664 p[19] = 1;
665 /* Motor off delay [0.1s], 0.1s */
666 p[20] = 1;
667 /* Medium rotation rate [rpm], 5400 rpm */
668 p[28] = (5400 >> 8) & 0xff;
669 p[29] = 5400 & 0xff;
670 return p[1] + 2;
671
672 case 8: /* Caching page. */
673 p[0] = 8;
674 p[1] = 0x12;
675 if (page_control == 1) { /* Changeable Values */
676 return p[1] + 2;
677 }
678 if (bdrv_enable_write_cache(s->bs)) {
679 p[2] = 4; /* WCE */
680 }
681 return p[1] + 2;
682
683 case 0x2a: /* CD Capabilities and Mechanical Status page. */
684 if (s->drive_kind != SCSI_CD)
685 return 0;
686 p[0] = 0x2a;
687 p[1] = 0x14;
688 if (page_control == 1) { /* Changeable Values */
689 return p[1] + 2;
690 }
691 p[2] = 3; // CD-R & CD-RW read
692 p[3] = 0; // Writing not supported
693 p[4] = 0x7f; /* Audio, composite, digital out,
694 mode 2 form 1&2, multi session */
695 p[5] = 0xff; /* CD DA, DA accurate, RW supported,
696 RW corrected, C2 errors, ISRC,
697 UPC, Bar code */
698 p[6] = 0x2d | (bdrv_is_locked(s->bs)? 2 : 0);
699 /* Locking supported, jumper present, eject, tray */
700 p[7] = 0; /* no volume & mute control, no
701 changer */
702 p[8] = (50 * 176) >> 8; // 50x read speed
703 p[9] = (50 * 176) & 0xff;
704 p[10] = 0 >> 8; // No volume
705 p[11] = 0 & 0xff;
706 p[12] = 2048 >> 8; // 2M buffer
707 p[13] = 2048 & 0xff;
708 p[14] = (16 * 176) >> 8; // 16x read speed current
709 p[15] = (16 * 176) & 0xff;
710 p[18] = (16 * 176) >> 8; // 16x write speed
711 p[19] = (16 * 176) & 0xff;
712 p[20] = (16 * 176) >> 8; // 16x write speed current
713 p[21] = (16 * 176) & 0xff;
714 return p[1] + 2;
715
716 default:
717 return 0;
718 }
719 }
720
721 static int scsi_disk_emulate_mode_sense(SCSIRequest *req, uint8_t *outbuf)
722 {
723 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
724 uint64_t nb_sectors;
725 int page, dbd, buflen, page_control;
726 uint8_t *p;
727 uint8_t dev_specific_param;
728
729 dbd = req->cmd.buf[1] & 0x8;
730 page = req->cmd.buf[2] & 0x3f;
731 page_control = (req->cmd.buf[2] & 0xc0) >> 6;
732 DPRINTF("Mode Sense(%d) (page %d, xfer %zd, page_control %d)\n",
733 (req->cmd.buf[0] == MODE_SENSE) ? 6 : 10, page, req->cmd.xfer, page_control);
734 memset(outbuf, 0, req->cmd.xfer);
735 p = outbuf;
736
737 if (bdrv_is_read_only(s->bs)) {
738 dev_specific_param = 0x80; /* Readonly. */
739 } else {
740 dev_specific_param = 0x00;
741 }
742
743 if (req->cmd.buf[0] == MODE_SENSE) {
744 p[1] = 0; /* Default media type. */
745 p[2] = dev_specific_param;
746 p[3] = 0; /* Block descriptor length. */
747 p += 4;
748 } else { /* MODE_SENSE_10 */
749 p[2] = 0; /* Default media type. */
750 p[3] = dev_specific_param;
751 p[6] = p[7] = 0; /* Block descriptor length. */
752 p += 8;
753 }
754
755 bdrv_get_geometry(s->bs, &nb_sectors);
756 if (!dbd && nb_sectors) {
757 if (req->cmd.buf[0] == MODE_SENSE) {
758 outbuf[3] = 8; /* Block descriptor length */
759 } else { /* MODE_SENSE_10 */
760 outbuf[7] = 8; /* Block descriptor length */
761 }
762 nb_sectors /= s->cluster_size;
763 if (nb_sectors > 0xffffff)
764 nb_sectors = 0;
765 p[0] = 0; /* media density code */
766 p[1] = (nb_sectors >> 16) & 0xff;
767 p[2] = (nb_sectors >> 8) & 0xff;
768 p[3] = nb_sectors & 0xff;
769 p[4] = 0; /* reserved */
770 p[5] = 0; /* bytes 5-7 are the sector size in bytes */
771 p[6] = s->cluster_size * 2;
772 p[7] = 0;
773 p += 8;
774 }
775
776 if (page_control == 3) { /* Saved Values */
777 return -1; /* ILLEGAL_REQUEST */
778 }
779
780 switch (page) {
781 case 0x04:
782 case 0x05:
783 case 0x08:
784 case 0x2a:
785 p += mode_sense_page(req, page, p, page_control);
786 break;
787 case 0x3f:
788 p += mode_sense_page(req, 0x08, p, page_control);
789 p += mode_sense_page(req, 0x2a, p, page_control);
790 break;
791 default:
792 return -1; /* ILLEGAL_REQUEST */
793 }
794
795 buflen = p - outbuf;
796 /*
797 * The mode data length field specifies the length in bytes of the
798 * following data that is available to be transferred. The mode data
799 * length does not include itself.
800 */
801 if (req->cmd.buf[0] == MODE_SENSE) {
802 outbuf[0] = buflen - 1;
803 } else { /* MODE_SENSE_10 */
804 outbuf[0] = ((buflen - 2) >> 8) & 0xff;
805 outbuf[1] = (buflen - 2) & 0xff;
806 }
807 if (buflen > req->cmd.xfer)
808 buflen = req->cmd.xfer;
809 return buflen;
810 }
811
812 static int scsi_disk_emulate_read_toc(SCSIRequest *req, uint8_t *outbuf)
813 {
814 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
815 int start_track, format, msf, toclen;
816 uint64_t nb_sectors;
817
818 msf = req->cmd.buf[1] & 2;
819 format = req->cmd.buf[2] & 0xf;
820 start_track = req->cmd.buf[6];
821 bdrv_get_geometry(s->bs, &nb_sectors);
822 DPRINTF("Read TOC (track %d format %d msf %d)\n", start_track, format, msf >> 1);
823 nb_sectors /= s->cluster_size;
824 switch (format) {
825 case 0:
826 toclen = cdrom_read_toc(nb_sectors, outbuf, msf, start_track);
827 break;
828 case 1:
829 /* multi session : only a single session defined */
830 toclen = 12;
831 memset(outbuf, 0, 12);
832 outbuf[1] = 0x0a;
833 outbuf[2] = 0x01;
834 outbuf[3] = 0x01;
835 break;
836 case 2:
837 toclen = cdrom_read_toc_raw(nb_sectors, outbuf, msf, start_track);
838 break;
839 default:
840 return -1;
841 }
842 if (toclen > req->cmd.xfer)
843 toclen = req->cmd.xfer;
844 return toclen;
845 }
846
847 static int scsi_disk_emulate_command(SCSIDiskReq *r, uint8_t *outbuf)
848 {
849 SCSIRequest *req = &r->req;
850 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
851 uint64_t nb_sectors;
852 int buflen = 0;
853 int ret;
854
855 switch (req->cmd.buf[0]) {
856 case TEST_UNIT_READY:
857 if (!bdrv_is_inserted(s->bs))
858 goto not_ready;
859 break;
860 case REQUEST_SENSE:
861 if (req->cmd.xfer < 4)
862 goto illegal_request;
863 memset(outbuf, 0, 4);
864 buflen = 4;
865 if (s->sense.key == NOT_READY && req->cmd.xfer >= 18) {
866 memset(outbuf, 0, 18);
867 buflen = 18;
868 outbuf[7] = 10;
869 /* asc 0x3a, ascq 0: Medium not present */
870 outbuf[12] = 0x3a;
871 outbuf[13] = 0;
872 }
873 outbuf[0] = 0xf0;
874 outbuf[1] = 0;
875 outbuf[2] = s->sense.key;
876 scsi_disk_clear_sense(s);
877 break;
878 case INQUIRY:
879 buflen = scsi_disk_emulate_inquiry(req, outbuf);
880 if (buflen < 0)
881 goto illegal_request;
882 break;
883 case MODE_SENSE:
884 case MODE_SENSE_10:
885 buflen = scsi_disk_emulate_mode_sense(req, outbuf);
886 if (buflen < 0)
887 goto illegal_request;
888 break;
889 case READ_TOC:
890 buflen = scsi_disk_emulate_read_toc(req, outbuf);
891 if (buflen < 0)
892 goto illegal_request;
893 break;
894 case RESERVE:
895 if (req->cmd.buf[1] & 1)
896 goto illegal_request;
897 break;
898 case RESERVE_10:
899 if (req->cmd.buf[1] & 3)
900 goto illegal_request;
901 break;
902 case RELEASE:
903 if (req->cmd.buf[1] & 1)
904 goto illegal_request;
905 break;
906 case RELEASE_10:
907 if (req->cmd.buf[1] & 3)
908 goto illegal_request;
909 break;
910 case START_STOP:
911 if (s->drive_kind == SCSI_CD && (req->cmd.buf[4] & 2)) {
912 /* load/eject medium */
913 bdrv_eject(s->bs, !(req->cmd.buf[4] & 1));
914 }
915 break;
916 case ALLOW_MEDIUM_REMOVAL:
917 bdrv_set_locked(s->bs, req->cmd.buf[4] & 1);
918 break;
919 case READ_CAPACITY:
920 /* The normal LEN field for this command is zero. */
921 memset(outbuf, 0, 8);
922 bdrv_get_geometry(s->bs, &nb_sectors);
923 if (!nb_sectors)
924 goto not_ready;
925 nb_sectors /= s->cluster_size;
926 /* Returned value is the address of the last sector. */
927 nb_sectors--;
928 /* Remember the new size for read/write sanity checking. */
929 s->max_lba = nb_sectors;
930 /* Clip to 2TB, instead of returning capacity modulo 2TB. */
931 if (nb_sectors > UINT32_MAX)
932 nb_sectors = UINT32_MAX;
933 outbuf[0] = (nb_sectors >> 24) & 0xff;
934 outbuf[1] = (nb_sectors >> 16) & 0xff;
935 outbuf[2] = (nb_sectors >> 8) & 0xff;
936 outbuf[3] = nb_sectors & 0xff;
937 outbuf[4] = 0;
938 outbuf[5] = 0;
939 outbuf[6] = s->cluster_size * 2;
940 outbuf[7] = 0;
941 buflen = 8;
942 break;
943 case SYNCHRONIZE_CACHE:
944 ret = bdrv_flush(s->bs);
945 if (ret < 0) {
946 if (scsi_handle_rw_error(r, -ret, SCSI_REQ_STATUS_RETRY_FLUSH)) {
947 return -1;
948 }
949 }
950 break;
951 case GET_CONFIGURATION:
952 memset(outbuf, 0, 8);
953 /* ??? This should probably return much more information. For now
954 just return the basic header indicating the CD-ROM profile. */
955 outbuf[7] = 8; // CD-ROM
956 buflen = 8;
957 break;
958 case SERVICE_ACTION_IN:
959 /* Service Action In subcommands. */
960 if ((req->cmd.buf[1] & 31) == 0x10) {
961 DPRINTF("SAI READ CAPACITY(16)\n");
962 memset(outbuf, 0, req->cmd.xfer);
963 bdrv_get_geometry(s->bs, &nb_sectors);
964 if (!nb_sectors)
965 goto not_ready;
966 nb_sectors /= s->cluster_size;
967 /* Returned value is the address of the last sector. */
968 nb_sectors--;
969 /* Remember the new size for read/write sanity checking. */
970 s->max_lba = nb_sectors;
971 outbuf[0] = (nb_sectors >> 56) & 0xff;
972 outbuf[1] = (nb_sectors >> 48) & 0xff;
973 outbuf[2] = (nb_sectors >> 40) & 0xff;
974 outbuf[3] = (nb_sectors >> 32) & 0xff;
975 outbuf[4] = (nb_sectors >> 24) & 0xff;
976 outbuf[5] = (nb_sectors >> 16) & 0xff;
977 outbuf[6] = (nb_sectors >> 8) & 0xff;
978 outbuf[7] = nb_sectors & 0xff;
979 outbuf[8] = 0;
980 outbuf[9] = 0;
981 outbuf[10] = s->cluster_size * 2;
982 outbuf[11] = 0;
983 outbuf[12] = 0;
984 outbuf[13] = get_physical_block_exp(&s->qdev.conf);
985
986 /* set TPE bit if the format supports discard */
987 if (s->qdev.conf.discard_granularity) {
988 outbuf[14] = 0x80;
989 }
990
991 /* Protection, exponent and lowest lba field left blank. */
992 buflen = req->cmd.xfer;
993 break;
994 }
995 DPRINTF("Unsupported Service Action In\n");
996 goto illegal_request;
997 case REPORT_LUNS:
998 if (req->cmd.xfer < 16)
999 goto illegal_request;
1000 memset(outbuf, 0, 16);
1001 outbuf[3] = 8;
1002 buflen = 16;
1003 break;
1004 case VERIFY:
1005 break;
1006 case REZERO_UNIT:
1007 DPRINTF("Rezero Unit\n");
1008 if (!bdrv_is_inserted(s->bs)) {
1009 goto not_ready;
1010 }
1011 break;
1012 default:
1013 goto illegal_request;
1014 }
1015 scsi_req_set_status(r, GOOD, NO_SENSE);
1016 return buflen;
1017
1018 not_ready:
1019 scsi_command_complete(r, CHECK_CONDITION, NOT_READY);
1020 return -1;
1021
1022 illegal_request:
1023 scsi_command_complete(r, CHECK_CONDITION, ILLEGAL_REQUEST);
1024 return -1;
1025 }
1026
1027 /* Execute a scsi command. Returns the length of the data expected by the
1028 command. This will be Positive for data transfers from the device
1029 (eg. disk reads), negative for transfers to the device (eg. disk writes),
1030 and zero if the command does not transfer any data. */
1031
1032 static int32_t scsi_send_command(SCSIDevice *d, uint32_t tag,
1033 uint8_t *buf, int lun)
1034 {
1035 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
1036 uint32_t len;
1037 int is_write;
1038 uint8_t command;
1039 uint8_t *outbuf;
1040 SCSIDiskReq *r;
1041 int rc;
1042
1043 command = buf[0];
1044 r = scsi_find_request(s, tag);
1045 if (r) {
1046 BADF("Tag 0x%x already in use\n", tag);
1047 scsi_cancel_io(d, tag);
1048 }
1049 /* ??? Tags are not unique for different luns. We only implement a
1050 single lun, so this should not matter. */
1051 r = scsi_new_request(s, tag, lun);
1052 outbuf = (uint8_t *)r->iov.iov_base;
1053 is_write = 0;
1054 DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", lun, tag, buf[0]);
1055
1056 if (scsi_req_parse(&r->req, buf) != 0) {
1057 BADF("Unsupported command length, command %x\n", command);
1058 goto fail;
1059 }
1060 #ifdef DEBUG_SCSI
1061 {
1062 int i;
1063 for (i = 1; i < r->req.cmd.len; i++) {
1064 printf(" 0x%02x", buf[i]);
1065 }
1066 printf("\n");
1067 }
1068 #endif
1069
1070 if (lun || buf[1] >> 5) {
1071 /* Only LUN 0 supported. */
1072 DPRINTF("Unimplemented LUN %d\n", lun ? lun : buf[1] >> 5);
1073 if (command != REQUEST_SENSE && command != INQUIRY)
1074 goto fail;
1075 }
1076 switch (command) {
1077 case TEST_UNIT_READY:
1078 case REQUEST_SENSE:
1079 case INQUIRY:
1080 case MODE_SENSE:
1081 case MODE_SENSE_10:
1082 case RESERVE:
1083 case RESERVE_10:
1084 case RELEASE:
1085 case RELEASE_10:
1086 case START_STOP:
1087 case ALLOW_MEDIUM_REMOVAL:
1088 case READ_CAPACITY:
1089 case SYNCHRONIZE_CACHE:
1090 case READ_TOC:
1091 case GET_CONFIGURATION:
1092 case SERVICE_ACTION_IN:
1093 case REPORT_LUNS:
1094 case VERIFY:
1095 case REZERO_UNIT:
1096 rc = scsi_disk_emulate_command(r, outbuf);
1097 if (rc < 0) {
1098 return 0;
1099 }
1100
1101 r->iov.iov_len = rc;
1102 break;
1103 case READ_6:
1104 case READ_10:
1105 case READ_12:
1106 case READ_16:
1107 len = r->req.cmd.xfer / d->blocksize;
1108 DPRINTF("Read (sector %" PRId64 ", count %d)\n", r->req.cmd.lba, len);
1109 if (r->req.cmd.lba > s->max_lba)
1110 goto illegal_lba;
1111 r->sector = r->req.cmd.lba * s->cluster_size;
1112 r->sector_count = len * s->cluster_size;
1113 break;
1114 case WRITE_6:
1115 case WRITE_10:
1116 case WRITE_12:
1117 case WRITE_16:
1118 case WRITE_VERIFY:
1119 case WRITE_VERIFY_12:
1120 case WRITE_VERIFY_16:
1121 len = r->req.cmd.xfer / d->blocksize;
1122 DPRINTF("Write %s(sector %" PRId64 ", count %d)\n",
1123 (command & 0xe) == 0xe ? "And Verify " : "",
1124 r->req.cmd.lba, len);
1125 if (r->req.cmd.lba > s->max_lba)
1126 goto illegal_lba;
1127 r->sector = r->req.cmd.lba * s->cluster_size;
1128 r->sector_count = len * s->cluster_size;
1129 is_write = 1;
1130 break;
1131 case MODE_SELECT:
1132 DPRINTF("Mode Select(6) (len %lu)\n", (long)r->req.cmd.xfer);
1133 /* We don't support mode parameter changes.
1134 Allow the mode parameter header + block descriptors only. */
1135 if (r->req.cmd.xfer > 12) {
1136 goto fail;
1137 }
1138 break;
1139 case MODE_SELECT_10:
1140 DPRINTF("Mode Select(10) (len %lu)\n", (long)r->req.cmd.xfer);
1141 /* We don't support mode parameter changes.
1142 Allow the mode parameter header + block descriptors only. */
1143 if (r->req.cmd.xfer > 16) {
1144 goto fail;
1145 }
1146 break;
1147 case SEEK_6:
1148 case SEEK_10:
1149 DPRINTF("Seek(%d) (sector %" PRId64 ")\n", command == SEEK_6 ? 6 : 10,
1150 r->req.cmd.lba);
1151 if (r->req.cmd.lba > s->max_lba) {
1152 goto illegal_lba;
1153 }
1154 break;
1155 case WRITE_SAME_16:
1156 len = r->req.cmd.xfer / d->blocksize;
1157
1158 DPRINTF("WRITE SAME(16) (sector %" PRId64 ", count %d)\n",
1159 r->req.cmd.lba, len);
1160
1161 if (r->req.cmd.lba > s->max_lba) {
1162 goto illegal_lba;
1163 }
1164
1165 /*
1166 * We only support WRITE SAME with the unmap bit set for now.
1167 */
1168 if (!(buf[1] & 0x8)) {
1169 goto fail;
1170 }
1171
1172 rc = bdrv_discard(s->bs, r->req.cmd.lba * s->cluster_size,
1173 len * s->cluster_size);
1174 if (rc < 0) {
1175 /* XXX: better error code ?*/
1176 goto fail;
1177 }
1178
1179 break;
1180 default:
1181 DPRINTF("Unknown SCSI command (%2.2x)\n", buf[0]);
1182 fail:
1183 scsi_command_complete(r, CHECK_CONDITION, ILLEGAL_REQUEST);
1184 return 0;
1185 illegal_lba:
1186 scsi_command_complete(r, CHECK_CONDITION, HARDWARE_ERROR);
1187 return 0;
1188 }
1189 if (r->sector_count == 0 && r->iov.iov_len == 0) {
1190 scsi_command_complete(r, GOOD, NO_SENSE);
1191 }
1192 len = r->sector_count * 512 + r->iov.iov_len;
1193 if (is_write) {
1194 return -len;
1195 } else {
1196 if (!r->sector_count)
1197 r->sector_count = -1;
1198 return len;
1199 }
1200 }
1201
1202 static void scsi_disk_purge_requests(SCSIDiskState *s)
1203 {
1204 SCSIDiskReq *r;
1205
1206 while (!QTAILQ_EMPTY(&s->qdev.requests)) {
1207 r = DO_UPCAST(SCSIDiskReq, req, QTAILQ_FIRST(&s->qdev.requests));
1208 if (r->req.aiocb) {
1209 bdrv_aio_cancel(r->req.aiocb);
1210 }
1211 scsi_remove_request(r);
1212 }
1213 }
1214
1215 static void scsi_disk_reset(DeviceState *dev)
1216 {
1217 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev.qdev, dev);
1218 uint64_t nb_sectors;
1219
1220 scsi_disk_purge_requests(s);
1221
1222 bdrv_get_geometry(s->bs, &nb_sectors);
1223 nb_sectors /= s->cluster_size;
1224 if (nb_sectors) {
1225 nb_sectors--;
1226 }
1227 s->max_lba = nb_sectors;
1228 }
1229
1230 static void scsi_destroy(SCSIDevice *dev)
1231 {
1232 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
1233
1234 scsi_disk_purge_requests(s);
1235 blockdev_mark_auto_del(s->qdev.conf.bs);
1236 }
1237
1238 static int scsi_initfn(SCSIDevice *dev, SCSIDriveKind kind)
1239 {
1240 SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
1241 DriveInfo *dinfo;
1242
1243 if (!s->qdev.conf.bs) {
1244 error_report("scsi-disk: drive property not set");
1245 return -1;
1246 }
1247 s->bs = s->qdev.conf.bs;
1248 s->drive_kind = kind;
1249
1250 if (kind == SCSI_HD && !bdrv_is_inserted(s->bs)) {
1251 error_report("Device needs media, but drive is empty");
1252 return -1;
1253 }
1254
1255 if (!s->serial) {
1256 /* try to fall back to value set with legacy -drive serial=... */
1257 dinfo = drive_get_by_blockdev(s->bs);
1258 s->serial = qemu_strdup(*dinfo->serial ? dinfo->serial : "0");
1259 }
1260
1261 if (!s->version) {
1262 s->version = qemu_strdup(QEMU_VERSION);
1263 }
1264
1265 if (bdrv_is_sg(s->bs)) {
1266 error_report("scsi-disk: unwanted /dev/sg*");
1267 return -1;
1268 }
1269
1270 if (kind == SCSI_CD) {
1271 s->qdev.blocksize = 2048;
1272 } else {
1273 s->qdev.blocksize = s->qdev.conf.logical_block_size;
1274 }
1275 s->cluster_size = s->qdev.blocksize / 512;
1276 s->bs->buffer_alignment = s->qdev.blocksize;
1277
1278 s->qdev.type = TYPE_DISK;
1279 qemu_add_vm_change_state_handler(scsi_dma_restart_cb, s);
1280 bdrv_set_removable(s->bs, kind == SCSI_CD);
1281 add_boot_device_path(s->qdev.conf.bootindex, &dev->qdev, ",0");
1282 return 0;
1283 }
1284
1285 static int scsi_hd_initfn(SCSIDevice *dev)
1286 {
1287 return scsi_initfn(dev, SCSI_HD);
1288 }
1289
1290 static int scsi_cd_initfn(SCSIDevice *dev)
1291 {
1292 return scsi_initfn(dev, SCSI_CD);
1293 }
1294
1295 static int scsi_disk_initfn(SCSIDevice *dev)
1296 {
1297 SCSIDriveKind kind;
1298 DriveInfo *dinfo;
1299
1300 if (!dev->conf.bs) {
1301 kind = SCSI_HD; /* will die in scsi_initfn() */
1302 } else {
1303 dinfo = drive_get_by_blockdev(dev->conf.bs);
1304 kind = dinfo->media_cd ? SCSI_CD : SCSI_HD;
1305 }
1306
1307 return scsi_initfn(dev, kind);
1308 }
1309
1310 #define DEFINE_SCSI_DISK_PROPERTIES() \
1311 DEFINE_BLOCK_PROPERTIES(SCSIDiskState, qdev.conf), \
1312 DEFINE_PROP_STRING("ver", SCSIDiskState, version), \
1313 DEFINE_PROP_STRING("serial", SCSIDiskState, serial)
1314
1315 static SCSIDeviceInfo scsi_disk_info[] = {
1316 {
1317 .qdev.name = "scsi-hd",
1318 .qdev.fw_name = "disk",
1319 .qdev.desc = "virtual SCSI disk",
1320 .qdev.size = sizeof(SCSIDiskState),
1321 .qdev.reset = scsi_disk_reset,
1322 .init = scsi_hd_initfn,
1323 .destroy = scsi_destroy,
1324 .send_command = scsi_send_command,
1325 .read_data = scsi_read_data,
1326 .write_data = scsi_write_data,
1327 .cancel_io = scsi_cancel_io,
1328 .get_buf = scsi_get_buf,
1329 .qdev.props = (Property[]) {
1330 DEFINE_SCSI_DISK_PROPERTIES(),
1331 DEFINE_PROP_BIT("removable", SCSIDiskState, removable, 0, false),
1332 DEFINE_PROP_END_OF_LIST(),
1333 }
1334 },{
1335 .qdev.name = "scsi-cd",
1336 .qdev.fw_name = "disk",
1337 .qdev.desc = "virtual SCSI CD-ROM",
1338 .qdev.size = sizeof(SCSIDiskState),
1339 .qdev.reset = scsi_disk_reset,
1340 .init = scsi_cd_initfn,
1341 .destroy = scsi_destroy,
1342 .send_command = scsi_send_command,
1343 .read_data = scsi_read_data,
1344 .write_data = scsi_write_data,
1345 .cancel_io = scsi_cancel_io,
1346 .get_buf = scsi_get_buf,
1347 .qdev.props = (Property[]) {
1348 DEFINE_SCSI_DISK_PROPERTIES(),
1349 DEFINE_PROP_END_OF_LIST(),
1350 },
1351 },{
1352 .qdev.name = "scsi-disk", /* legacy -device scsi-disk */
1353 .qdev.fw_name = "disk",
1354 .qdev.desc = "virtual SCSI disk or CD-ROM (legacy)",
1355 .qdev.size = sizeof(SCSIDiskState),
1356 .qdev.reset = scsi_disk_reset,
1357 .init = scsi_disk_initfn,
1358 .destroy = scsi_destroy,
1359 .send_command = scsi_send_command,
1360 .read_data = scsi_read_data,
1361 .write_data = scsi_write_data,
1362 .cancel_io = scsi_cancel_io,
1363 .get_buf = scsi_get_buf,
1364 .qdev.props = (Property[]) {
1365 DEFINE_SCSI_DISK_PROPERTIES(),
1366 DEFINE_PROP_BIT("removable", SCSIDiskState, removable, 0, false),
1367 DEFINE_PROP_END_OF_LIST(),
1368 }
1369 }
1370 };
1371
1372 static void scsi_disk_register_devices(void)
1373 {
1374 int i;
1375
1376 for (i = 0; i < ARRAY_SIZE(scsi_disk_info); i++) {
1377 scsi_qdev_register(&scsi_disk_info[i]);
1378 }
1379 }
1380 device_init(scsi_disk_register_devices)