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 licensed 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 | #include "qemu/osdep.h" |
23 | #include "qemu/units.h" |
24 | #include "qapi/error.h" |
25 | #include "qemu/error-report.h" |
26 | #include "qemu/main-loop.h" |
27 | #include "qemu/module.h" |
28 | #include "hw/scsi/scsi.h" |
29 | #include "migration/qemu-file-types.h" |
30 | #include "migration/vmstate.h" |
31 | #include "hw/scsi/emulation.h" |
32 | #include "scsi/constants.h" |
33 | #include "sysemu/block-backend.h" |
34 | #include "sysemu/blockdev.h" |
35 | #include "hw/block/block.h" |
36 | #include "hw/qdev-properties.h" |
37 | #include "sysemu/dma.h" |
38 | #include "qemu/cutils.h" |
39 | #include "trace.h" |
40 | |
41 | #ifdef __linux |
42 | #include <scsi/sg.h> |
43 | #endif |
44 | |
45 | #define SCSI_WRITE_SAME_MAX (512 * KiB) |
46 | #define SCSI_DMA_BUF_SIZE (128 * KiB) |
47 | #define SCSI_MAX_INQUIRY_LEN 256 |
48 | #define SCSI_MAX_MODE_LEN 256 |
49 | |
50 | #define DEFAULT_DISCARD_GRANULARITY (4 * KiB) |
51 | #define DEFAULT_MAX_UNMAP_SIZE (1 * GiB) |
52 | #define DEFAULT_MAX_IO_SIZE INT_MAX /* 2 GB - 1 block */ |
53 | |
54 | #define TYPE_SCSI_DISK_BASE "scsi-disk-base" |
55 | |
56 | #define SCSI_DISK_BASE(obj) \ |
57 | OBJECT_CHECK(SCSIDiskState, (obj), TYPE_SCSI_DISK_BASE) |
58 | #define SCSI_DISK_BASE_CLASS(klass) \ |
59 | OBJECT_CLASS_CHECK(SCSIDiskClass, (klass), TYPE_SCSI_DISK_BASE) |
60 | #define SCSI_DISK_BASE_GET_CLASS(obj) \ |
61 | OBJECT_GET_CLASS(SCSIDiskClass, (obj), TYPE_SCSI_DISK_BASE) |
62 | |
63 | typedef struct SCSIDiskClass { |
64 | SCSIDeviceClass parent_class; |
65 | DMAIOFunc *dma_readv; |
66 | DMAIOFunc *dma_writev; |
67 | bool (*need_fua_emulation)(SCSICommand *cmd); |
68 | void (*update_sense)(SCSIRequest *r); |
69 | } SCSIDiskClass; |
70 | |
71 | typedef struct SCSIDiskReq { |
72 | SCSIRequest req; |
73 | /* Both sector and sector_count are in terms of qemu 512 byte blocks. */ |
74 | uint64_t sector; |
75 | uint32_t sector_count; |
76 | uint32_t buflen; |
77 | bool started; |
78 | bool need_fua_emulation; |
79 | struct iovec iov; |
80 | QEMUIOVector qiov; |
81 | BlockAcctCookie acct; |
82 | unsigned char *status; |
83 | } SCSIDiskReq; |
84 | |
85 | #define SCSI_DISK_F_REMOVABLE 0 |
86 | #define SCSI_DISK_F_DPOFUA 1 |
87 | #define SCSI_DISK_F_NO_REMOVABLE_DEVOPS 2 |
88 | |
89 | typedef struct SCSIDiskState |
90 | { |
91 | SCSIDevice qdev; |
92 | uint32_t features; |
93 | bool media_changed; |
94 | bool media_event; |
95 | bool eject_request; |
96 | uint16_t port_index; |
97 | uint64_t max_unmap_size; |
98 | uint64_t max_io_size; |
99 | QEMUBH *bh; |
100 | char *version; |
101 | char *serial; |
102 | char *vendor; |
103 | char *product; |
104 | char *device_id; |
105 | bool tray_open; |
106 | bool tray_locked; |
107 | /* |
108 | * 0x0000 - rotation rate not reported |
109 | * 0x0001 - non-rotating medium (SSD) |
110 | * 0x0002-0x0400 - reserved |
111 | * 0x0401-0xffe - rotations per minute |
112 | * 0xffff - reserved |
113 | */ |
114 | uint16_t rotation_rate; |
115 | } SCSIDiskState; |
116 | |
117 | static bool scsi_handle_rw_error(SCSIDiskReq *r, int error, bool acct_failed); |
118 | |
119 | static void scsi_free_request(SCSIRequest *req) |
120 | { |
121 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
122 | |
123 | qemu_vfree(r->iov.iov_base); |
124 | } |
125 | |
126 | /* Helper function for command completion with sense. */ |
127 | static void scsi_check_condition(SCSIDiskReq *r, SCSISense sense) |
128 | { |
129 | trace_scsi_disk_check_condition(r->req.tag, sense.key, sense.asc, |
130 | sense.ascq); |
131 | scsi_req_build_sense(&r->req, sense); |
132 | scsi_req_complete(&r->req, CHECK_CONDITION); |
133 | } |
134 | |
135 | static void scsi_init_iovec(SCSIDiskReq *r, size_t size) |
136 | { |
137 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
138 | |
139 | if (!r->iov.iov_base) { |
140 | r->buflen = size; |
141 | r->iov.iov_base = blk_blockalign(s->qdev.conf.blk, r->buflen); |
142 | } |
143 | r->iov.iov_len = MIN(r->sector_count * 512, r->buflen); |
144 | qemu_iovec_init_external(&r->qiov, &r->iov, 1); |
145 | } |
146 | |
147 | static void scsi_disk_save_request(QEMUFile *f, SCSIRequest *req) |
148 | { |
149 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
150 | |
151 | qemu_put_be64s(f, &r->sector); |
152 | qemu_put_be32s(f, &r->sector_count); |
153 | qemu_put_be32s(f, &r->buflen); |
154 | if (r->buflen) { |
155 | if (r->req.cmd.mode == SCSI_XFER_TO_DEV) { |
156 | qemu_put_buffer(f, r->iov.iov_base, r->iov.iov_len); |
157 | } else if (!req->retry) { |
158 | uint32_t len = r->iov.iov_len; |
159 | qemu_put_be32s(f, &len); |
160 | qemu_put_buffer(f, r->iov.iov_base, r->iov.iov_len); |
161 | } |
162 | } |
163 | } |
164 | |
165 | static void scsi_disk_load_request(QEMUFile *f, SCSIRequest *req) |
166 | { |
167 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
168 | |
169 | qemu_get_be64s(f, &r->sector); |
170 | qemu_get_be32s(f, &r->sector_count); |
171 | qemu_get_be32s(f, &r->buflen); |
172 | if (r->buflen) { |
173 | scsi_init_iovec(r, r->buflen); |
174 | if (r->req.cmd.mode == SCSI_XFER_TO_DEV) { |
175 | qemu_get_buffer(f, r->iov.iov_base, r->iov.iov_len); |
176 | } else if (!r->req.retry) { |
177 | uint32_t len; |
178 | qemu_get_be32s(f, &len); |
179 | r->iov.iov_len = len; |
180 | assert(r->iov.iov_len <= r->buflen); |
181 | qemu_get_buffer(f, r->iov.iov_base, r->iov.iov_len); |
182 | } |
183 | } |
184 | |
185 | qemu_iovec_init_external(&r->qiov, &r->iov, 1); |
186 | } |
187 | |
188 | static bool scsi_disk_req_check_error(SCSIDiskReq *r, int ret, bool acct_failed) |
189 | { |
190 | if (r->req.io_canceled) { |
191 | scsi_req_cancel_complete(&r->req); |
192 | return true; |
193 | } |
194 | |
195 | if (ret < 0 || (r->status && *r->status)) { |
196 | return scsi_handle_rw_error(r, -ret, acct_failed); |
197 | } |
198 | |
199 | return false; |
200 | } |
201 | |
202 | static void scsi_aio_complete(void *opaque, int ret) |
203 | { |
204 | SCSIDiskReq *r = (SCSIDiskReq *)opaque; |
205 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
206 | |
207 | assert(r->req.aiocb != NULL); |
208 | r->req.aiocb = NULL; |
209 | aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk)); |
210 | if (scsi_disk_req_check_error(r, ret, true)) { |
211 | goto done; |
212 | } |
213 | |
214 | block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); |
215 | scsi_req_complete(&r->req, GOOD); |
216 | |
217 | done: |
218 | aio_context_release(blk_get_aio_context(s->qdev.conf.blk)); |
219 | scsi_req_unref(&r->req); |
220 | } |
221 | |
222 | static bool scsi_is_cmd_fua(SCSICommand *cmd) |
223 | { |
224 | switch (cmd->buf[0]) { |
225 | case READ_10: |
226 | case READ_12: |
227 | case READ_16: |
228 | case WRITE_10: |
229 | case WRITE_12: |
230 | case WRITE_16: |
231 | return (cmd->buf[1] & 8) != 0; |
232 | |
233 | case VERIFY_10: |
234 | case VERIFY_12: |
235 | case VERIFY_16: |
236 | case WRITE_VERIFY_10: |
237 | case WRITE_VERIFY_12: |
238 | case WRITE_VERIFY_16: |
239 | return true; |
240 | |
241 | case READ_6: |
242 | case WRITE_6: |
243 | default: |
244 | return false; |
245 | } |
246 | } |
247 | |
248 | static void scsi_write_do_fua(SCSIDiskReq *r) |
249 | { |
250 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
251 | |
252 | assert(r->req.aiocb == NULL); |
253 | assert(!r->req.io_canceled); |
254 | |
255 | if (r->need_fua_emulation) { |
256 | block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0, |
257 | BLOCK_ACCT_FLUSH); |
258 | r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_aio_complete, r); |
259 | return; |
260 | } |
261 | |
262 | scsi_req_complete(&r->req, GOOD); |
263 | scsi_req_unref(&r->req); |
264 | } |
265 | |
266 | static void scsi_dma_complete_noio(SCSIDiskReq *r, int ret) |
267 | { |
268 | assert(r->req.aiocb == NULL); |
269 | if (scsi_disk_req_check_error(r, ret, false)) { |
270 | goto done; |
271 | } |
272 | |
273 | r->sector += r->sector_count; |
274 | r->sector_count = 0; |
275 | if (r->req.cmd.mode == SCSI_XFER_TO_DEV) { |
276 | scsi_write_do_fua(r); |
277 | return; |
278 | } else { |
279 | scsi_req_complete(&r->req, GOOD); |
280 | } |
281 | |
282 | done: |
283 | scsi_req_unref(&r->req); |
284 | } |
285 | |
286 | static void scsi_dma_complete(void *opaque, int ret) |
287 | { |
288 | SCSIDiskReq *r = (SCSIDiskReq *)opaque; |
289 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
290 | |
291 | assert(r->req.aiocb != NULL); |
292 | r->req.aiocb = NULL; |
293 | |
294 | aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk)); |
295 | if (ret < 0) { |
296 | block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct); |
297 | } else { |
298 | block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); |
299 | } |
300 | scsi_dma_complete_noio(r, ret); |
301 | aio_context_release(blk_get_aio_context(s->qdev.conf.blk)); |
302 | } |
303 | |
304 | static void scsi_read_complete_noio(SCSIDiskReq *r, int ret) |
305 | { |
306 | uint32_t n; |
307 | |
308 | assert(r->req.aiocb == NULL); |
309 | if (scsi_disk_req_check_error(r, ret, false)) { |
310 | goto done; |
311 | } |
312 | |
313 | n = r->qiov.size / 512; |
314 | r->sector += n; |
315 | r->sector_count -= n; |
316 | scsi_req_data(&r->req, r->qiov.size); |
317 | |
318 | done: |
319 | scsi_req_unref(&r->req); |
320 | } |
321 | |
322 | static void scsi_read_complete(void *opaque, int ret) |
323 | { |
324 | SCSIDiskReq *r = (SCSIDiskReq *)opaque; |
325 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
326 | |
327 | assert(r->req.aiocb != NULL); |
328 | r->req.aiocb = NULL; |
329 | |
330 | aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk)); |
331 | if (ret < 0) { |
332 | block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct); |
333 | } else { |
334 | block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); |
335 | trace_scsi_disk_read_complete(r->req.tag, r->qiov.size); |
336 | } |
337 | scsi_read_complete_noio(r, ret); |
338 | aio_context_release(blk_get_aio_context(s->qdev.conf.blk)); |
339 | } |
340 | |
341 | /* Actually issue a read to the block device. */ |
342 | static void scsi_do_read(SCSIDiskReq *r, int ret) |
343 | { |
344 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
345 | SCSIDiskClass *sdc = (SCSIDiskClass *) object_get_class(OBJECT(s)); |
346 | |
347 | assert (r->req.aiocb == NULL); |
348 | if (scsi_disk_req_check_error(r, ret, false)) { |
349 | goto done; |
350 | } |
351 | |
352 | /* The request is used as the AIO opaque value, so add a ref. */ |
353 | scsi_req_ref(&r->req); |
354 | |
355 | if (r->req.sg) { |
356 | dma_acct_start(s->qdev.conf.blk, &r->acct, r->req.sg, BLOCK_ACCT_READ); |
357 | r->req.resid -= r->req.sg->size; |
358 | r->req.aiocb = dma_blk_io(blk_get_aio_context(s->qdev.conf.blk), |
359 | r->req.sg, r->sector << BDRV_SECTOR_BITS, |
360 | BDRV_SECTOR_SIZE, |
361 | sdc->dma_readv, r, scsi_dma_complete, r, |
362 | DMA_DIRECTION_FROM_DEVICE); |
363 | } else { |
364 | scsi_init_iovec(r, SCSI_DMA_BUF_SIZE); |
365 | block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, |
366 | r->qiov.size, BLOCK_ACCT_READ); |
367 | r->req.aiocb = sdc->dma_readv(r->sector << BDRV_SECTOR_BITS, &r->qiov, |
368 | scsi_read_complete, r, r); |
369 | } |
370 | |
371 | done: |
372 | scsi_req_unref(&r->req); |
373 | } |
374 | |
375 | static void scsi_do_read_cb(void *opaque, int ret) |
376 | { |
377 | SCSIDiskReq *r = (SCSIDiskReq *)opaque; |
378 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
379 | |
380 | assert (r->req.aiocb != NULL); |
381 | r->req.aiocb = NULL; |
382 | |
383 | aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk)); |
384 | if (ret < 0) { |
385 | block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct); |
386 | } else { |
387 | block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); |
388 | } |
389 | scsi_do_read(opaque, ret); |
390 | aio_context_release(blk_get_aio_context(s->qdev.conf.blk)); |
391 | } |
392 | |
393 | /* Read more data from scsi device into buffer. */ |
394 | static void scsi_read_data(SCSIRequest *req) |
395 | { |
396 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
397 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
398 | bool first; |
399 | |
400 | trace_scsi_disk_read_data_count(r->sector_count); |
401 | if (r->sector_count == 0) { |
402 | /* This also clears the sense buffer for REQUEST SENSE. */ |
403 | scsi_req_complete(&r->req, GOOD); |
404 | return; |
405 | } |
406 | |
407 | /* No data transfer may already be in progress */ |
408 | assert(r->req.aiocb == NULL); |
409 | |
410 | /* The request is used as the AIO opaque value, so add a ref. */ |
411 | scsi_req_ref(&r->req); |
412 | if (r->req.cmd.mode == SCSI_XFER_TO_DEV) { |
413 | trace_scsi_disk_read_data_invalid(); |
414 | scsi_read_complete_noio(r, -EINVAL); |
415 | return; |
416 | } |
417 | |
418 | if (!blk_is_available(req->dev->conf.blk)) { |
419 | scsi_read_complete_noio(r, -ENOMEDIUM); |
420 | return; |
421 | } |
422 | |
423 | first = !r->started; |
424 | r->started = true; |
425 | if (first && r->need_fua_emulation) { |
426 | block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0, |
427 | BLOCK_ACCT_FLUSH); |
428 | r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_do_read_cb, r); |
429 | } else { |
430 | scsi_do_read(r, 0); |
431 | } |
432 | } |
433 | |
434 | /* |
435 | * scsi_handle_rw_error has two return values. False means that the error |
436 | * must be ignored, true means that the error has been processed and the |
437 | * caller should not do anything else for this request. Note that |
438 | * scsi_handle_rw_error always manages its reference counts, independent |
439 | * of the return value. |
440 | */ |
441 | static bool scsi_handle_rw_error(SCSIDiskReq *r, int error, bool acct_failed) |
442 | { |
443 | bool is_read = (r->req.cmd.mode == SCSI_XFER_FROM_DEV); |
444 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
445 | SCSIDiskClass *sdc = (SCSIDiskClass *) object_get_class(OBJECT(s)); |
446 | BlockErrorAction action = blk_get_error_action(s->qdev.conf.blk, |
447 | is_read, error); |
448 | |
449 | if (action == BLOCK_ERROR_ACTION_REPORT) { |
450 | if (acct_failed) { |
451 | block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct); |
452 | } |
453 | switch (error) { |
454 | case 0: |
455 | /* A passthrough command has run and has produced sense data; check |
456 | * whether the error has to be handled by the guest or should rather |
457 | * pause the host. |
458 | */ |
459 | assert(r->status && *r->status); |
460 | if (scsi_sense_buf_is_guest_recoverable(r->req.sense, sizeof(r->req.sense))) { |
461 | /* These errors are handled by guest. */ |
462 | sdc->update_sense(&r->req); |
463 | scsi_req_complete(&r->req, *r->status); |
464 | return true; |
465 | } |
466 | error = scsi_sense_buf_to_errno(r->req.sense, sizeof(r->req.sense)); |
467 | break; |
468 | case ENOMEDIUM: |
469 | scsi_check_condition(r, SENSE_CODE(NO_MEDIUM)); |
470 | break; |
471 | case ENOMEM: |
472 | scsi_check_condition(r, SENSE_CODE(TARGET_FAILURE)); |
473 | break; |
474 | case EINVAL: |
475 | scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); |
476 | break; |
477 | case ENOSPC: |
478 | scsi_check_condition(r, SENSE_CODE(SPACE_ALLOC_FAILED)); |
479 | break; |
480 | default: |
481 | scsi_check_condition(r, SENSE_CODE(IO_ERROR)); |
482 | break; |
483 | } |
484 | } |
485 | |
486 | blk_error_action(s->qdev.conf.blk, action, is_read, error); |
487 | if (action == BLOCK_ERROR_ACTION_IGNORE) { |
488 | scsi_req_complete(&r->req, 0); |
489 | return true; |
490 | } |
491 | |
492 | if (action == BLOCK_ERROR_ACTION_STOP) { |
493 | scsi_req_retry(&r->req); |
494 | } |
495 | return true; |
496 | } |
497 | |
498 | static void scsi_write_complete_noio(SCSIDiskReq *r, int ret) |
499 | { |
500 | uint32_t n; |
501 | |
502 | assert (r->req.aiocb == NULL); |
503 | if (scsi_disk_req_check_error(r, ret, false)) { |
504 | goto done; |
505 | } |
506 | |
507 | n = r->qiov.size / 512; |
508 | r->sector += n; |
509 | r->sector_count -= n; |
510 | if (r->sector_count == 0) { |
511 | scsi_write_do_fua(r); |
512 | return; |
513 | } else { |
514 | scsi_init_iovec(r, SCSI_DMA_BUF_SIZE); |
515 | trace_scsi_disk_write_complete_noio(r->req.tag, r->qiov.size); |
516 | scsi_req_data(&r->req, r->qiov.size); |
517 | } |
518 | |
519 | done: |
520 | scsi_req_unref(&r->req); |
521 | } |
522 | |
523 | static void scsi_write_complete(void * opaque, int ret) |
524 | { |
525 | SCSIDiskReq *r = (SCSIDiskReq *)opaque; |
526 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
527 | |
528 | assert (r->req.aiocb != NULL); |
529 | r->req.aiocb = NULL; |
530 | |
531 | aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk)); |
532 | if (ret < 0) { |
533 | block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct); |
534 | } else { |
535 | block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); |
536 | } |
537 | scsi_write_complete_noio(r, ret); |
538 | aio_context_release(blk_get_aio_context(s->qdev.conf.blk)); |
539 | } |
540 | |
541 | static void scsi_write_data(SCSIRequest *req) |
542 | { |
543 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
544 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
545 | SCSIDiskClass *sdc = (SCSIDiskClass *) object_get_class(OBJECT(s)); |
546 | |
547 | /* No data transfer may already be in progress */ |
548 | assert(r->req.aiocb == NULL); |
549 | |
550 | /* The request is used as the AIO opaque value, so add a ref. */ |
551 | scsi_req_ref(&r->req); |
552 | if (r->req.cmd.mode != SCSI_XFER_TO_DEV) { |
553 | trace_scsi_disk_write_data_invalid(); |
554 | scsi_write_complete_noio(r, -EINVAL); |
555 | return; |
556 | } |
557 | |
558 | if (!r->req.sg && !r->qiov.size) { |
559 | /* Called for the first time. Ask the driver to send us more data. */ |
560 | r->started = true; |
561 | scsi_write_complete_noio(r, 0); |
562 | return; |
563 | } |
564 | if (!blk_is_available(req->dev->conf.blk)) { |
565 | scsi_write_complete_noio(r, -ENOMEDIUM); |
566 | return; |
567 | } |
568 | |
569 | if (r->req.cmd.buf[0] == VERIFY_10 || r->req.cmd.buf[0] == VERIFY_12 || |
570 | r->req.cmd.buf[0] == VERIFY_16) { |
571 | if (r->req.sg) { |
572 | scsi_dma_complete_noio(r, 0); |
573 | } else { |
574 | scsi_write_complete_noio(r, 0); |
575 | } |
576 | return; |
577 | } |
578 | |
579 | if (r->req.sg) { |
580 | dma_acct_start(s->qdev.conf.blk, &r->acct, r->req.sg, BLOCK_ACCT_WRITE); |
581 | r->req.resid -= r->req.sg->size; |
582 | r->req.aiocb = dma_blk_io(blk_get_aio_context(s->qdev.conf.blk), |
583 | r->req.sg, r->sector << BDRV_SECTOR_BITS, |
584 | BDRV_SECTOR_SIZE, |
585 | sdc->dma_writev, r, scsi_dma_complete, r, |
586 | DMA_DIRECTION_TO_DEVICE); |
587 | } else { |
588 | block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, |
589 | r->qiov.size, BLOCK_ACCT_WRITE); |
590 | r->req.aiocb = sdc->dma_writev(r->sector << BDRV_SECTOR_BITS, &r->qiov, |
591 | scsi_write_complete, r, r); |
592 | } |
593 | } |
594 | |
595 | /* Return a pointer to the data buffer. */ |
596 | static uint8_t *scsi_get_buf(SCSIRequest *req) |
597 | { |
598 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
599 | |
600 | return (uint8_t *)r->iov.iov_base; |
601 | } |
602 | |
603 | static int scsi_disk_emulate_vpd_page(SCSIRequest *req, uint8_t *outbuf) |
604 | { |
605 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); |
606 | uint8_t page_code = req->cmd.buf[2]; |
607 | int start, buflen = 0; |
608 | |
609 | outbuf[buflen++] = s->qdev.type & 0x1f; |
610 | outbuf[buflen++] = page_code; |
611 | outbuf[buflen++] = 0x00; |
612 | outbuf[buflen++] = 0x00; |
613 | start = buflen; |
614 | |
615 | switch (page_code) { |
616 | case 0x00: /* Supported page codes, mandatory */ |
617 | { |
618 | trace_scsi_disk_emulate_vpd_page_00(req->cmd.xfer); |
619 | outbuf[buflen++] = 0x00; /* list of supported pages (this page) */ |
620 | if (s->serial) { |
621 | outbuf[buflen++] = 0x80; /* unit serial number */ |
622 | } |
623 | outbuf[buflen++] = 0x83; /* device identification */ |
624 | if (s->qdev.type == TYPE_DISK) { |
625 | outbuf[buflen++] = 0xb0; /* block limits */ |
626 | outbuf[buflen++] = 0xb1; /* block device characteristics */ |
627 | outbuf[buflen++] = 0xb2; /* thin provisioning */ |
628 | } |
629 | break; |
630 | } |
631 | case 0x80: /* Device serial number, optional */ |
632 | { |
633 | int l; |
634 | |
635 | if (!s->serial) { |
636 | trace_scsi_disk_emulate_vpd_page_80_not_supported(); |
637 | return -1; |
638 | } |
639 | |
640 | l = strlen(s->serial); |
641 | if (l > 36) { |
642 | l = 36; |
643 | } |
644 | |
645 | trace_scsi_disk_emulate_vpd_page_80(req->cmd.xfer); |
646 | memcpy(outbuf + buflen, s->serial, l); |
647 | buflen += l; |
648 | break; |
649 | } |
650 | |
651 | case 0x83: /* Device identification page, mandatory */ |
652 | { |
653 | int id_len = s->device_id ? MIN(strlen(s->device_id), 255 - 8) : 0; |
654 | |
655 | trace_scsi_disk_emulate_vpd_page_83(req->cmd.xfer); |
656 | |
657 | if (id_len) { |
658 | outbuf[buflen++] = 0x2; /* ASCII */ |
659 | outbuf[buflen++] = 0; /* not officially assigned */ |
660 | outbuf[buflen++] = 0; /* reserved */ |
661 | outbuf[buflen++] = id_len; /* length of data following */ |
662 | memcpy(outbuf + buflen, s->device_id, id_len); |
663 | buflen += id_len; |
664 | } |
665 | |
666 | if (s->qdev.wwn) { |
667 | outbuf[buflen++] = 0x1; /* Binary */ |
668 | outbuf[buflen++] = 0x3; /* NAA */ |
669 | outbuf[buflen++] = 0; /* reserved */ |
670 | outbuf[buflen++] = 8; |
671 | stq_be_p(&outbuf[buflen], s->qdev.wwn); |
672 | buflen += 8; |
673 | } |
674 | |
675 | if (s->qdev.port_wwn) { |
676 | outbuf[buflen++] = 0x61; /* SAS / Binary */ |
677 | outbuf[buflen++] = 0x93; /* PIV / Target port / NAA */ |
678 | outbuf[buflen++] = 0; /* reserved */ |
679 | outbuf[buflen++] = 8; |
680 | stq_be_p(&outbuf[buflen], s->qdev.port_wwn); |
681 | buflen += 8; |
682 | } |
683 | |
684 | if (s->port_index) { |
685 | outbuf[buflen++] = 0x61; /* SAS / Binary */ |
686 | |
687 | /* PIV/Target port/relative target port */ |
688 | outbuf[buflen++] = 0x94; |
689 | |
690 | outbuf[buflen++] = 0; /* reserved */ |
691 | outbuf[buflen++] = 4; |
692 | stw_be_p(&outbuf[buflen + 2], s->port_index); |
693 | buflen += 4; |
694 | } |
695 | break; |
696 | } |
697 | case 0xb0: /* block limits */ |
698 | { |
699 | SCSIBlockLimits bl = {}; |
700 | |
701 | if (s->qdev.type == TYPE_ROM) { |
702 | trace_scsi_disk_emulate_vpd_page_b0_not_supported(); |
703 | return -1; |
704 | } |
705 | bl.wsnz = 1; |
706 | bl.unmap_sectors = |
707 | s->qdev.conf.discard_granularity / s->qdev.blocksize; |
708 | bl.min_io_size = |
709 | s->qdev.conf.min_io_size / s->qdev.blocksize; |
710 | bl.opt_io_size = |
711 | s->qdev.conf.opt_io_size / s->qdev.blocksize; |
712 | bl.max_unmap_sectors = |
713 | s->max_unmap_size / s->qdev.blocksize; |
714 | bl.max_io_sectors = |
715 | s->max_io_size / s->qdev.blocksize; |
716 | /* 255 descriptors fit in 4 KiB with an 8-byte header */ |
717 | bl.max_unmap_descr = 255; |
718 | |
719 | if (s->qdev.type == TYPE_DISK) { |
720 | int max_transfer_blk = blk_get_max_transfer(s->qdev.conf.blk); |
721 | int max_io_sectors_blk = |
722 | max_transfer_blk / s->qdev.blocksize; |
723 | |
724 | bl.max_io_sectors = |
725 | MIN_NON_ZERO(max_io_sectors_blk, bl.max_io_sectors); |
726 | } |
727 | buflen += scsi_emulate_block_limits(outbuf + buflen, &bl); |
728 | break; |
729 | } |
730 | case 0xb1: /* block device characteristics */ |
731 | { |
732 | buflen = 0x40; |
733 | outbuf[4] = (s->rotation_rate >> 8) & 0xff; |
734 | outbuf[5] = s->rotation_rate & 0xff; |
735 | outbuf[6] = 0; /* PRODUCT TYPE */ |
736 | outbuf[7] = 0; /* WABEREQ | WACEREQ | NOMINAL FORM FACTOR */ |
737 | outbuf[8] = 0; /* VBULS */ |
738 | break; |
739 | } |
740 | case 0xb2: /* thin provisioning */ |
741 | { |
742 | buflen = 8; |
743 | outbuf[4] = 0; |
744 | outbuf[5] = 0xe0; /* unmap & write_same 10/16 all supported */ |
745 | outbuf[6] = s->qdev.conf.discard_granularity ? 2 : 1; |
746 | outbuf[7] = 0; |
747 | break; |
748 | } |
749 | default: |
750 | return -1; |
751 | } |
752 | /* done with EVPD */ |
753 | assert(buflen - start <= 255); |
754 | outbuf[start - 1] = buflen - start; |
755 | return buflen; |
756 | } |
757 | |
758 | static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf) |
759 | { |
760 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); |
761 | int buflen = 0; |
762 | |
763 | if (req->cmd.buf[1] & 0x1) { |
764 | /* Vital product data */ |
765 | return scsi_disk_emulate_vpd_page(req, outbuf); |
766 | } |
767 | |
768 | /* Standard INQUIRY data */ |
769 | if (req->cmd.buf[2] != 0) { |
770 | return -1; |
771 | } |
772 | |
773 | /* PAGE CODE == 0 */ |
774 | buflen = req->cmd.xfer; |
775 | if (buflen > SCSI_MAX_INQUIRY_LEN) { |
776 | buflen = SCSI_MAX_INQUIRY_LEN; |
777 | } |
778 | |
779 | outbuf[0] = s->qdev.type & 0x1f; |
780 | outbuf[1] = (s->features & (1 << SCSI_DISK_F_REMOVABLE)) ? 0x80 : 0; |
781 | |
782 | strpadcpy((char *) &outbuf[16], 16, s->product, ' '); |
783 | strpadcpy((char *) &outbuf[8], 8, s->vendor, ' '); |
784 | |
785 | memset(&outbuf[32], 0, 4); |
786 | memcpy(&outbuf[32], s->version, MIN(4, strlen(s->version))); |
787 | /* |
788 | * We claim conformance to SPC-3, which is required for guests |
789 | * to ask for modern features like READ CAPACITY(16) or the |
790 | * block characteristics VPD page by default. Not all of SPC-3 |
791 | * is actually implemented, but we're good enough. |
792 | */ |
793 | outbuf[2] = s->qdev.default_scsi_version; |
794 | outbuf[3] = 2 | 0x10; /* Format 2, HiSup */ |
795 | |
796 | if (buflen > 36) { |
797 | outbuf[4] = buflen - 5; /* Additional Length = (Len - 1) - 4 */ |
798 | } else { |
799 | /* If the allocation length of CDB is too small, |
800 | the additional length is not adjusted */ |
801 | outbuf[4] = 36 - 5; |
802 | } |
803 | |
804 | /* Sync data transfer and TCQ. */ |
805 | outbuf[7] = 0x10 | (req->bus->info->tcq ? 0x02 : 0); |
806 | return buflen; |
807 | } |
808 | |
809 | static inline bool media_is_dvd(SCSIDiskState *s) |
810 | { |
811 | uint64_t nb_sectors; |
812 | if (s->qdev.type != TYPE_ROM) { |
813 | return false; |
814 | } |
815 | if (!blk_is_available(s->qdev.conf.blk)) { |
816 | return false; |
817 | } |
818 | blk_get_geometry(s->qdev.conf.blk, &nb_sectors); |
819 | return nb_sectors > CD_MAX_SECTORS; |
820 | } |
821 | |
822 | static inline bool media_is_cd(SCSIDiskState *s) |
823 | { |
824 | uint64_t nb_sectors; |
825 | if (s->qdev.type != TYPE_ROM) { |
826 | return false; |
827 | } |
828 | if (!blk_is_available(s->qdev.conf.blk)) { |
829 | return false; |
830 | } |
831 | blk_get_geometry(s->qdev.conf.blk, &nb_sectors); |
832 | return nb_sectors <= CD_MAX_SECTORS; |
833 | } |
834 | |
835 | static int scsi_read_disc_information(SCSIDiskState *s, SCSIDiskReq *r, |
836 | uint8_t *outbuf) |
837 | { |
838 | uint8_t type = r->req.cmd.buf[1] & 7; |
839 | |
840 | if (s->qdev.type != TYPE_ROM) { |
841 | return -1; |
842 | } |
843 | |
844 | /* Types 1/2 are only defined for Blu-Ray. */ |
845 | if (type != 0) { |
846 | scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); |
847 | return -1; |
848 | } |
849 | |
850 | memset(outbuf, 0, 34); |
851 | outbuf[1] = 32; |
852 | outbuf[2] = 0xe; /* last session complete, disc finalized */ |
853 | outbuf[3] = 1; /* first track on disc */ |
854 | outbuf[4] = 1; /* # of sessions */ |
855 | outbuf[5] = 1; /* first track of last session */ |
856 | outbuf[6] = 1; /* last track of last session */ |
857 | outbuf[7] = 0x20; /* unrestricted use */ |
858 | outbuf[8] = 0x00; /* CD-ROM or DVD-ROM */ |
859 | /* 9-10-11: most significant byte corresponding bytes 4-5-6 */ |
860 | /* 12-23: not meaningful for CD-ROM or DVD-ROM */ |
861 | /* 24-31: disc bar code */ |
862 | /* 32: disc application code */ |
863 | /* 33: number of OPC tables */ |
864 | |
865 | return 34; |
866 | } |
867 | |
868 | static int scsi_read_dvd_structure(SCSIDiskState *s, SCSIDiskReq *r, |
869 | uint8_t *outbuf) |
870 | { |
871 | static const int rds_caps_size[5] = { |
872 | [0] = 2048 + 4, |
873 | [1] = 4 + 4, |
874 | [3] = 188 + 4, |
875 | [4] = 2048 + 4, |
876 | }; |
877 | |
878 | uint8_t media = r->req.cmd.buf[1]; |
879 | uint8_t layer = r->req.cmd.buf[6]; |
880 | uint8_t format = r->req.cmd.buf[7]; |
881 | int size = -1; |
882 | |
883 | if (s->qdev.type != TYPE_ROM) { |
884 | return -1; |
885 | } |
886 | if (media != 0) { |
887 | scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); |
888 | return -1; |
889 | } |
890 | |
891 | if (format != 0xff) { |
892 | if (!blk_is_available(s->qdev.conf.blk)) { |
893 | scsi_check_condition(r, SENSE_CODE(NO_MEDIUM)); |
894 | return -1; |
895 | } |
896 | if (media_is_cd(s)) { |
897 | scsi_check_condition(r, SENSE_CODE(INCOMPATIBLE_FORMAT)); |
898 | return -1; |
899 | } |
900 | if (format >= ARRAY_SIZE(rds_caps_size)) { |
901 | return -1; |
902 | } |
903 | size = rds_caps_size[format]; |
904 | memset(outbuf, 0, size); |
905 | } |
906 | |
907 | switch (format) { |
908 | case 0x00: { |
909 | /* Physical format information */ |
910 | uint64_t nb_sectors; |
911 | if (layer != 0) { |
912 | goto fail; |
913 | } |
914 | blk_get_geometry(s->qdev.conf.blk, &nb_sectors); |
915 | |
916 | outbuf[4] = 1; /* DVD-ROM, part version 1 */ |
917 | outbuf[5] = 0xf; /* 120mm disc, minimum rate unspecified */ |
918 | outbuf[6] = 1; /* one layer, read-only (per MMC-2 spec) */ |
919 | outbuf[7] = 0; /* default densities */ |
920 | |
921 | stl_be_p(&outbuf[12], (nb_sectors >> 2) - 1); /* end sector */ |
922 | stl_be_p(&outbuf[16], (nb_sectors >> 2) - 1); /* l0 end sector */ |
923 | break; |
924 | } |
925 | |
926 | case 0x01: /* DVD copyright information, all zeros */ |
927 | break; |
928 | |
929 | case 0x03: /* BCA information - invalid field for no BCA info */ |
930 | return -1; |
931 | |
932 | case 0x04: /* DVD disc manufacturing information, all zeros */ |
933 | break; |
934 | |
935 | case 0xff: { /* List capabilities */ |
936 | int i; |
937 | size = 4; |
938 | for (i = 0; i < ARRAY_SIZE(rds_caps_size); i++) { |
939 | if (!rds_caps_size[i]) { |
940 | continue; |
941 | } |
942 | outbuf[size] = i; |
943 | outbuf[size + 1] = 0x40; /* Not writable, readable */ |
944 | stw_be_p(&outbuf[size + 2], rds_caps_size[i]); |
945 | size += 4; |
946 | } |
947 | break; |
948 | } |
949 | |
950 | default: |
951 | return -1; |
952 | } |
953 | |
954 | /* Size of buffer, not including 2 byte size field */ |
955 | stw_be_p(outbuf, size - 2); |
956 | return size; |
957 | |
958 | fail: |
959 | return -1; |
960 | } |
961 | |
962 | static int scsi_event_status_media(SCSIDiskState *s, uint8_t *outbuf) |
963 | { |
964 | uint8_t event_code, media_status; |
965 | |
966 | media_status = 0; |
967 | if (s->tray_open) { |
968 | media_status = MS_TRAY_OPEN; |
969 | } else if (blk_is_inserted(s->qdev.conf.blk)) { |
970 | media_status = MS_MEDIA_PRESENT; |
971 | } |
972 | |
973 | /* Event notification descriptor */ |
974 | event_code = MEC_NO_CHANGE; |
975 | if (media_status != MS_TRAY_OPEN) { |
976 | if (s->media_event) { |
977 | event_code = MEC_NEW_MEDIA; |
978 | s->media_event = false; |
979 | } else if (s->eject_request) { |
980 | event_code = MEC_EJECT_REQUESTED; |
981 | s->eject_request = false; |
982 | } |
983 | } |
984 | |
985 | outbuf[0] = event_code; |
986 | outbuf[1] = media_status; |
987 | |
988 | /* These fields are reserved, just clear them. */ |
989 | outbuf[2] = 0; |
990 | outbuf[3] = 0; |
991 | return 4; |
992 | } |
993 | |
994 | static int scsi_get_event_status_notification(SCSIDiskState *s, SCSIDiskReq *r, |
995 | uint8_t *outbuf) |
996 | { |
997 | int size; |
998 | uint8_t *buf = r->req.cmd.buf; |
999 | uint8_t notification_class_request = buf[4]; |
1000 | if (s->qdev.type != TYPE_ROM) { |
1001 | return -1; |
1002 | } |
1003 | if ((buf[1] & 1) == 0) { |
1004 | /* asynchronous */ |
1005 | return -1; |
1006 | } |
1007 | |
1008 | size = 4; |
1009 | outbuf[0] = outbuf[1] = 0; |
1010 | outbuf[3] = 1 << GESN_MEDIA; /* supported events */ |
1011 | if (notification_class_request & (1 << GESN_MEDIA)) { |
1012 | outbuf[2] = GESN_MEDIA; |
1013 | size += scsi_event_status_media(s, &outbuf[size]); |
1014 | } else { |
1015 | outbuf[2] = 0x80; |
1016 | } |
1017 | stw_be_p(outbuf, size - 4); |
1018 | return size; |
1019 | } |
1020 | |
1021 | static int scsi_get_configuration(SCSIDiskState *s, uint8_t *outbuf) |
1022 | { |
1023 | int current; |
1024 | |
1025 | if (s->qdev.type != TYPE_ROM) { |
1026 | return -1; |
1027 | } |
1028 | |
1029 | if (media_is_dvd(s)) { |
1030 | current = MMC_PROFILE_DVD_ROM; |
1031 | } else if (media_is_cd(s)) { |
1032 | current = MMC_PROFILE_CD_ROM; |
1033 | } else { |
1034 | current = MMC_PROFILE_NONE; |
1035 | } |
1036 | |
1037 | memset(outbuf, 0, 40); |
1038 | stl_be_p(&outbuf[0], 36); /* Bytes after the data length field */ |
1039 | stw_be_p(&outbuf[6], current); |
1040 | /* outbuf[8] - outbuf[19]: Feature 0 - Profile list */ |
1041 | outbuf[10] = 0x03; /* persistent, current */ |
1042 | outbuf[11] = 8; /* two profiles */ |
1043 | stw_be_p(&outbuf[12], MMC_PROFILE_DVD_ROM); |
1044 | outbuf[14] = (current == MMC_PROFILE_DVD_ROM); |
1045 | stw_be_p(&outbuf[16], MMC_PROFILE_CD_ROM); |
1046 | outbuf[18] = (current == MMC_PROFILE_CD_ROM); |
1047 | /* outbuf[20] - outbuf[31]: Feature 1 - Core feature */ |
1048 | stw_be_p(&outbuf[20], 1); |
1049 | outbuf[22] = 0x08 | 0x03; /* version 2, persistent, current */ |
1050 | outbuf[23] = 8; |
1051 | stl_be_p(&outbuf[24], 1); /* SCSI */ |
1052 | outbuf[28] = 1; /* DBE = 1, mandatory */ |
1053 | /* outbuf[32] - outbuf[39]: Feature 3 - Removable media feature */ |
1054 | stw_be_p(&outbuf[32], 3); |
1055 | outbuf[34] = 0x08 | 0x03; /* version 2, persistent, current */ |
1056 | outbuf[35] = 4; |
1057 | outbuf[36] = 0x39; /* tray, load=1, eject=1, unlocked at powerup, lock=1 */ |
1058 | /* TODO: Random readable, CD read, DVD read, drive serial number, |
1059 | power management */ |
1060 | return 40; |
1061 | } |
1062 | |
1063 | static int scsi_emulate_mechanism_status(SCSIDiskState *s, uint8_t *outbuf) |
1064 | { |
1065 | if (s->qdev.type != TYPE_ROM) { |
1066 | return -1; |
1067 | } |
1068 | memset(outbuf, 0, 8); |
1069 | outbuf[5] = 1; /* CD-ROM */ |
1070 | return 8; |
1071 | } |
1072 | |
1073 | static int mode_sense_page(SCSIDiskState *s, int page, uint8_t **p_outbuf, |
1074 | int page_control) |
1075 | { |
1076 | static const int mode_sense_valid[0x3f] = { |
1077 | [MODE_PAGE_HD_GEOMETRY] = (1 << TYPE_DISK), |
1078 | [MODE_PAGE_FLEXIBLE_DISK_GEOMETRY] = (1 << TYPE_DISK), |
1079 | [MODE_PAGE_CACHING] = (1 << TYPE_DISK) | (1 << TYPE_ROM), |
1080 | [MODE_PAGE_R_W_ERROR] = (1 << TYPE_DISK) | (1 << TYPE_ROM), |
1081 | [MODE_PAGE_AUDIO_CTL] = (1 << TYPE_ROM), |
1082 | [MODE_PAGE_CAPABILITIES] = (1 << TYPE_ROM), |
1083 | }; |
1084 | |
1085 | uint8_t *p = *p_outbuf + 2; |
1086 | int length; |
1087 | |
1088 | if ((mode_sense_valid[page] & (1 << s->qdev.type)) == 0) { |
1089 | return -1; |
1090 | } |
1091 | |
1092 | /* |
1093 | * If Changeable Values are requested, a mask denoting those mode parameters |
1094 | * that are changeable shall be returned. As we currently don't support |
1095 | * parameter changes via MODE_SELECT all bits are returned set to zero. |
1096 | * The buffer was already menset to zero by the caller of this function. |
1097 | * |
1098 | * The offsets here are off by two compared to the descriptions in the |
1099 | * SCSI specs, because those include a 2-byte header. This is unfortunate, |
1100 | * but it is done so that offsets are consistent within our implementation |
1101 | * of MODE SENSE and MODE SELECT. MODE SELECT has to deal with both |
1102 | * 2-byte and 4-byte headers. |
1103 | */ |
1104 | switch (page) { |
1105 | case MODE_PAGE_HD_GEOMETRY: |
1106 | length = 0x16; |
1107 | if (page_control == 1) { /* Changeable Values */ |
1108 | break; |
1109 | } |
1110 | /* if a geometry hint is available, use it */ |
1111 | p[0] = (s->qdev.conf.cyls >> 16) & 0xff; |
1112 | p[1] = (s->qdev.conf.cyls >> 8) & 0xff; |
1113 | p[2] = s->qdev.conf.cyls & 0xff; |
1114 | p[3] = s->qdev.conf.heads & 0xff; |
1115 | /* Write precomp start cylinder, disabled */ |
1116 | p[4] = (s->qdev.conf.cyls >> 16) & 0xff; |
1117 | p[5] = (s->qdev.conf.cyls >> 8) & 0xff; |
1118 | p[6] = s->qdev.conf.cyls & 0xff; |
1119 | /* Reduced current start cylinder, disabled */ |
1120 | p[7] = (s->qdev.conf.cyls >> 16) & 0xff; |
1121 | p[8] = (s->qdev.conf.cyls >> 8) & 0xff; |
1122 | p[9] = s->qdev.conf.cyls & 0xff; |
1123 | /* Device step rate [ns], 200ns */ |
1124 | p[10] = 0; |
1125 | p[11] = 200; |
1126 | /* Landing zone cylinder */ |
1127 | p[12] = 0xff; |
1128 | p[13] = 0xff; |
1129 | p[14] = 0xff; |
1130 | /* Medium rotation rate [rpm], 5400 rpm */ |
1131 | p[18] = (5400 >> 8) & 0xff; |
1132 | p[19] = 5400 & 0xff; |
1133 | break; |
1134 | |
1135 | case MODE_PAGE_FLEXIBLE_DISK_GEOMETRY: |
1136 | length = 0x1e; |
1137 | if (page_control == 1) { /* Changeable Values */ |
1138 | break; |
1139 | } |
1140 | /* Transfer rate [kbit/s], 5Mbit/s */ |
1141 | p[0] = 5000 >> 8; |
1142 | p[1] = 5000 & 0xff; |
1143 | /* if a geometry hint is available, use it */ |
1144 | p[2] = s->qdev.conf.heads & 0xff; |
1145 | p[3] = s->qdev.conf.secs & 0xff; |
1146 | p[4] = s->qdev.blocksize >> 8; |
1147 | p[6] = (s->qdev.conf.cyls >> 8) & 0xff; |
1148 | p[7] = s->qdev.conf.cyls & 0xff; |
1149 | /* Write precomp start cylinder, disabled */ |
1150 | p[8] = (s->qdev.conf.cyls >> 8) & 0xff; |
1151 | p[9] = s->qdev.conf.cyls & 0xff; |
1152 | /* Reduced current start cylinder, disabled */ |
1153 | p[10] = (s->qdev.conf.cyls >> 8) & 0xff; |
1154 | p[11] = s->qdev.conf.cyls & 0xff; |
1155 | /* Device step rate [100us], 100us */ |
1156 | p[12] = 0; |
1157 | p[13] = 1; |
1158 | /* Device step pulse width [us], 1us */ |
1159 | p[14] = 1; |
1160 | /* Device head settle delay [100us], 100us */ |
1161 | p[15] = 0; |
1162 | p[16] = 1; |
1163 | /* Motor on delay [0.1s], 0.1s */ |
1164 | p[17] = 1; |
1165 | /* Motor off delay [0.1s], 0.1s */ |
1166 | p[18] = 1; |
1167 | /* Medium rotation rate [rpm], 5400 rpm */ |
1168 | p[26] = (5400 >> 8) & 0xff; |
1169 | p[27] = 5400 & 0xff; |
1170 | break; |
1171 | |
1172 | case MODE_PAGE_CACHING: |
1173 | length = 0x12; |
1174 | if (page_control == 1 || /* Changeable Values */ |
1175 | blk_enable_write_cache(s->qdev.conf.blk)) { |
1176 | p[0] = 4; /* WCE */ |
1177 | } |
1178 | break; |
1179 | |
1180 | case MODE_PAGE_R_W_ERROR: |
1181 | length = 10; |
1182 | if (page_control == 1) { /* Changeable Values */ |
1183 | break; |
1184 | } |
1185 | p[0] = 0x80; /* Automatic Write Reallocation Enabled */ |
1186 | if (s->qdev.type == TYPE_ROM) { |
1187 | p[1] = 0x20; /* Read Retry Count */ |
1188 | } |
1189 | break; |
1190 | |
1191 | case MODE_PAGE_AUDIO_CTL: |
1192 | length = 14; |
1193 | break; |
1194 | |
1195 | case MODE_PAGE_CAPABILITIES: |
1196 | length = 0x14; |
1197 | if (page_control == 1) { /* Changeable Values */ |
1198 | break; |
1199 | } |
1200 | |
1201 | p[0] = 0x3b; /* CD-R & CD-RW read */ |
1202 | p[1] = 0; /* Writing not supported */ |
1203 | p[2] = 0x7f; /* Audio, composite, digital out, |
1204 | mode 2 form 1&2, multi session */ |
1205 | p[3] = 0xff; /* CD DA, DA accurate, RW supported, |
1206 | RW corrected, C2 errors, ISRC, |
1207 | UPC, Bar code */ |
1208 | p[4] = 0x2d | (s->tray_locked ? 2 : 0); |
1209 | /* Locking supported, jumper present, eject, tray */ |
1210 | p[5] = 0; /* no volume & mute control, no |
1211 | changer */ |
1212 | p[6] = (50 * 176) >> 8; /* 50x read speed */ |
1213 | p[7] = (50 * 176) & 0xff; |
1214 | p[8] = 2 >> 8; /* Two volume levels */ |
1215 | p[9] = 2 & 0xff; |
1216 | p[10] = 2048 >> 8; /* 2M buffer */ |
1217 | p[11] = 2048 & 0xff; |
1218 | p[12] = (16 * 176) >> 8; /* 16x read speed current */ |
1219 | p[13] = (16 * 176) & 0xff; |
1220 | p[16] = (16 * 176) >> 8; /* 16x write speed */ |
1221 | p[17] = (16 * 176) & 0xff; |
1222 | p[18] = (16 * 176) >> 8; /* 16x write speed current */ |
1223 | p[19] = (16 * 176) & 0xff; |
1224 | break; |
1225 | |
1226 | default: |
1227 | return -1; |
1228 | } |
1229 | |
1230 | assert(length < 256); |
1231 | (*p_outbuf)[0] = page; |
1232 | (*p_outbuf)[1] = length; |
1233 | *p_outbuf += length + 2; |
1234 | return length + 2; |
1235 | } |
1236 | |
1237 | static int scsi_disk_emulate_mode_sense(SCSIDiskReq *r, uint8_t *outbuf) |
1238 | { |
1239 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
1240 | uint64_t nb_sectors; |
1241 | bool dbd; |
1242 | int page, buflen, ret, page_control; |
1243 | uint8_t *p; |
1244 | uint8_t dev_specific_param; |
1245 | |
1246 | dbd = (r->req.cmd.buf[1] & 0x8) != 0; |
1247 | page = r->req.cmd.buf[2] & 0x3f; |
1248 | page_control = (r->req.cmd.buf[2] & 0xc0) >> 6; |
1249 | |
1250 | trace_scsi_disk_emulate_mode_sense((r->req.cmd.buf[0] == MODE_SENSE) ? 6 : |
1251 | 10, page, r->req.cmd.xfer, page_control); |
1252 | memset(outbuf, 0, r->req.cmd.xfer); |
1253 | p = outbuf; |
1254 | |
1255 | if (s->qdev.type == TYPE_DISK) { |
1256 | dev_specific_param = s->features & (1 << SCSI_DISK_F_DPOFUA) ? 0x10 : 0; |
1257 | if (blk_is_read_only(s->qdev.conf.blk)) { |
1258 | dev_specific_param |= 0x80; /* Readonly. */ |
1259 | } |
1260 | } else { |
1261 | /* MMC prescribes that CD/DVD drives have no block descriptors, |
1262 | * and defines no device-specific parameter. */ |
1263 | dev_specific_param = 0x00; |
1264 | dbd = true; |
1265 | } |
1266 | |
1267 | if (r->req.cmd.buf[0] == MODE_SENSE) { |
1268 | p[1] = 0; /* Default media type. */ |
1269 | p[2] = dev_specific_param; |
1270 | p[3] = 0; /* Block descriptor length. */ |
1271 | p += 4; |
1272 | } else { /* MODE_SENSE_10 */ |
1273 | p[2] = 0; /* Default media type. */ |
1274 | p[3] = dev_specific_param; |
1275 | p[6] = p[7] = 0; /* Block descriptor length. */ |
1276 | p += 8; |
1277 | } |
1278 | |
1279 | blk_get_geometry(s->qdev.conf.blk, &nb_sectors); |
1280 | if (!dbd && nb_sectors) { |
1281 | if (r->req.cmd.buf[0] == MODE_SENSE) { |
1282 | outbuf[3] = 8; /* Block descriptor length */ |
1283 | } else { /* MODE_SENSE_10 */ |
1284 | outbuf[7] = 8; /* Block descriptor length */ |
1285 | } |
1286 | nb_sectors /= (s->qdev.blocksize / 512); |
1287 | if (nb_sectors > 0xffffff) { |
1288 | nb_sectors = 0; |
1289 | } |
1290 | p[0] = 0; /* media density code */ |
1291 | p[1] = (nb_sectors >> 16) & 0xff; |
1292 | p[2] = (nb_sectors >> 8) & 0xff; |
1293 | p[3] = nb_sectors & 0xff; |
1294 | p[4] = 0; /* reserved */ |
1295 | p[5] = 0; /* bytes 5-7 are the sector size in bytes */ |
1296 | p[6] = s->qdev.blocksize >> 8; |
1297 | p[7] = 0; |
1298 | p += 8; |
1299 | } |
1300 | |
1301 | if (page_control == 3) { |
1302 | /* Saved Values */ |
1303 | scsi_check_condition(r, SENSE_CODE(SAVING_PARAMS_NOT_SUPPORTED)); |
1304 | return -1; |
1305 | } |
1306 | |
1307 | if (page == 0x3f) { |
1308 | for (page = 0; page <= 0x3e; page++) { |
1309 | mode_sense_page(s, page, &p, page_control); |
1310 | } |
1311 | } else { |
1312 | ret = mode_sense_page(s, page, &p, page_control); |
1313 | if (ret == -1) { |
1314 | return -1; |
1315 | } |
1316 | } |
1317 | |
1318 | buflen = p - outbuf; |
1319 | /* |
1320 | * The mode data length field specifies the length in bytes of the |
1321 | * following data that is available to be transferred. The mode data |
1322 | * length does not include itself. |
1323 | */ |
1324 | if (r->req.cmd.buf[0] == MODE_SENSE) { |
1325 | outbuf[0] = buflen - 1; |
1326 | } else { /* MODE_SENSE_10 */ |
1327 | outbuf[0] = ((buflen - 2) >> 8) & 0xff; |
1328 | outbuf[1] = (buflen - 2) & 0xff; |
1329 | } |
1330 | return buflen; |
1331 | } |
1332 | |
1333 | static int scsi_disk_emulate_read_toc(SCSIRequest *req, uint8_t *outbuf) |
1334 | { |
1335 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); |
1336 | int start_track, format, msf, toclen; |
1337 | uint64_t nb_sectors; |
1338 | |
1339 | msf = req->cmd.buf[1] & 2; |
1340 | format = req->cmd.buf[2] & 0xf; |
1341 | start_track = req->cmd.buf[6]; |
1342 | blk_get_geometry(s->qdev.conf.blk, &nb_sectors); |
1343 | trace_scsi_disk_emulate_read_toc(start_track, format, msf >> 1); |
1344 | nb_sectors /= s->qdev.blocksize / 512; |
1345 | switch (format) { |
1346 | case 0: |
1347 | toclen = cdrom_read_toc(nb_sectors, outbuf, msf, start_track); |
1348 | break; |
1349 | case 1: |
1350 | /* multi session : only a single session defined */ |
1351 | toclen = 12; |
1352 | memset(outbuf, 0, 12); |
1353 | outbuf[1] = 0x0a; |
1354 | outbuf[2] = 0x01; |
1355 | outbuf[3] = 0x01; |
1356 | break; |
1357 | case 2: |
1358 | toclen = cdrom_read_toc_raw(nb_sectors, outbuf, msf, start_track); |
1359 | break; |
1360 | default: |
1361 | return -1; |
1362 | } |
1363 | return toclen; |
1364 | } |
1365 | |
1366 | static int scsi_disk_emulate_start_stop(SCSIDiskReq *r) |
1367 | { |
1368 | SCSIRequest *req = &r->req; |
1369 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); |
1370 | bool start = req->cmd.buf[4] & 1; |
1371 | bool loej = req->cmd.buf[4] & 2; /* load on start, eject on !start */ |
1372 | int pwrcnd = req->cmd.buf[4] & 0xf0; |
1373 | |
1374 | if (pwrcnd) { |
1375 | /* eject/load only happens for power condition == 0 */ |
1376 | return 0; |
1377 | } |
1378 | |
1379 | if ((s->features & (1 << SCSI_DISK_F_REMOVABLE)) && loej) { |
1380 | if (!start && !s->tray_open && s->tray_locked) { |
1381 | scsi_check_condition(r, |
1382 | blk_is_inserted(s->qdev.conf.blk) |
1383 | ? SENSE_CODE(ILLEGAL_REQ_REMOVAL_PREVENTED) |
1384 | : SENSE_CODE(NOT_READY_REMOVAL_PREVENTED)); |
1385 | return -1; |
1386 | } |
1387 | |
1388 | if (s->tray_open != !start) { |
1389 | blk_eject(s->qdev.conf.blk, !start); |
1390 | s->tray_open = !start; |
1391 | } |
1392 | } |
1393 | return 0; |
1394 | } |
1395 | |
1396 | static void scsi_disk_emulate_read_data(SCSIRequest *req) |
1397 | { |
1398 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
1399 | int buflen = r->iov.iov_len; |
1400 | |
1401 | if (buflen) { |
1402 | trace_scsi_disk_emulate_read_data(buflen); |
1403 | r->iov.iov_len = 0; |
1404 | r->started = true; |
1405 | scsi_req_data(&r->req, buflen); |
1406 | return; |
1407 | } |
1408 | |
1409 | /* This also clears the sense buffer for REQUEST SENSE. */ |
1410 | scsi_req_complete(&r->req, GOOD); |
1411 | } |
1412 | |
1413 | static int scsi_disk_check_mode_select(SCSIDiskState *s, int page, |
1414 | uint8_t *inbuf, int inlen) |
1415 | { |
1416 | uint8_t mode_current[SCSI_MAX_MODE_LEN]; |
1417 | uint8_t mode_changeable[SCSI_MAX_MODE_LEN]; |
1418 | uint8_t *p; |
1419 | int len, expected_len, changeable_len, i; |
1420 | |
1421 | /* The input buffer does not include the page header, so it is |
1422 | * off by 2 bytes. |
1423 | */ |
1424 | expected_len = inlen + 2; |
1425 | if (expected_len > SCSI_MAX_MODE_LEN) { |
1426 | return -1; |
1427 | } |
1428 | |
1429 | p = mode_current; |
1430 | memset(mode_current, 0, inlen + 2); |
1431 | len = mode_sense_page(s, page, &p, 0); |
1432 | if (len < 0 || len != expected_len) { |
1433 | return -1; |
1434 | } |
1435 | |
1436 | p = mode_changeable; |
1437 | memset(mode_changeable, 0, inlen + 2); |
1438 | changeable_len = mode_sense_page(s, page, &p, 1); |
1439 | assert(changeable_len == len); |
1440 | |
1441 | /* Check that unchangeable bits are the same as what MODE SENSE |
1442 | * would return. |
1443 | */ |
1444 | for (i = 2; i < len; i++) { |
1445 | if (((mode_current[i] ^ inbuf[i - 2]) & ~mode_changeable[i]) != 0) { |
1446 | return -1; |
1447 | } |
1448 | } |
1449 | return 0; |
1450 | } |
1451 | |
1452 | static void scsi_disk_apply_mode_select(SCSIDiskState *s, int page, uint8_t *p) |
1453 | { |
1454 | switch (page) { |
1455 | case MODE_PAGE_CACHING: |
1456 | blk_set_enable_write_cache(s->qdev.conf.blk, (p[0] & 4) != 0); |
1457 | break; |
1458 | |
1459 | default: |
1460 | break; |
1461 | } |
1462 | } |
1463 | |
1464 | static int mode_select_pages(SCSIDiskReq *r, uint8_t *p, int len, bool change) |
1465 | { |
1466 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
1467 | |
1468 | while (len > 0) { |
1469 | int page, subpage, page_len; |
1470 | |
1471 | /* Parse both possible formats for the mode page headers. */ |
1472 | page = p[0] & 0x3f; |
1473 | if (p[0] & 0x40) { |
1474 | if (len < 4) { |
1475 | goto invalid_param_len; |
1476 | } |
1477 | subpage = p[1]; |
1478 | page_len = lduw_be_p(&p[2]); |
1479 | p += 4; |
1480 | len -= 4; |
1481 | } else { |
1482 | if (len < 2) { |
1483 | goto invalid_param_len; |
1484 | } |
1485 | subpage = 0; |
1486 | page_len = p[1]; |
1487 | p += 2; |
1488 | len -= 2; |
1489 | } |
1490 | |
1491 | if (subpage) { |
1492 | goto invalid_param; |
1493 | } |
1494 | if (page_len > len) { |
1495 | goto invalid_param_len; |
1496 | } |
1497 | |
1498 | if (!change) { |
1499 | if (scsi_disk_check_mode_select(s, page, p, page_len) < 0) { |
1500 | goto invalid_param; |
1501 | } |
1502 | } else { |
1503 | scsi_disk_apply_mode_select(s, page, p); |
1504 | } |
1505 | |
1506 | p += page_len; |
1507 | len -= page_len; |
1508 | } |
1509 | return 0; |
1510 | |
1511 | invalid_param: |
1512 | scsi_check_condition(r, SENSE_CODE(INVALID_PARAM)); |
1513 | return -1; |
1514 | |
1515 | invalid_param_len: |
1516 | scsi_check_condition(r, SENSE_CODE(INVALID_PARAM_LEN)); |
1517 | return -1; |
1518 | } |
1519 | |
1520 | static void scsi_disk_emulate_mode_select(SCSIDiskReq *r, uint8_t *inbuf) |
1521 | { |
1522 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
1523 | uint8_t *p = inbuf; |
1524 | int cmd = r->req.cmd.buf[0]; |
1525 | int len = r->req.cmd.xfer; |
1526 | int hdr_len = (cmd == MODE_SELECT ? 4 : 8); |
1527 | int bd_len; |
1528 | int pass; |
1529 | |
1530 | /* We only support PF=1, SP=0. */ |
1531 | if ((r->req.cmd.buf[1] & 0x11) != 0x10) { |
1532 | goto invalid_field; |
1533 | } |
1534 | |
1535 | if (len < hdr_len) { |
1536 | goto invalid_param_len; |
1537 | } |
1538 | |
1539 | bd_len = (cmd == MODE_SELECT ? p[3] : lduw_be_p(&p[6])); |
1540 | len -= hdr_len; |
1541 | p += hdr_len; |
1542 | if (len < bd_len) { |
1543 | goto invalid_param_len; |
1544 | } |
1545 | if (bd_len != 0 && bd_len != 8) { |
1546 | goto invalid_param; |
1547 | } |
1548 | |
1549 | len -= bd_len; |
1550 | p += bd_len; |
1551 | |
1552 | /* Ensure no change is made if there is an error! */ |
1553 | for (pass = 0; pass < 2; pass++) { |
1554 | if (mode_select_pages(r, p, len, pass == 1) < 0) { |
1555 | assert(pass == 0); |
1556 | return; |
1557 | } |
1558 | } |
1559 | if (!blk_enable_write_cache(s->qdev.conf.blk)) { |
1560 | /* The request is used as the AIO opaque value, so add a ref. */ |
1561 | scsi_req_ref(&r->req); |
1562 | block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0, |
1563 | BLOCK_ACCT_FLUSH); |
1564 | r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_aio_complete, r); |
1565 | return; |
1566 | } |
1567 | |
1568 | scsi_req_complete(&r->req, GOOD); |
1569 | return; |
1570 | |
1571 | invalid_param: |
1572 | scsi_check_condition(r, SENSE_CODE(INVALID_PARAM)); |
1573 | return; |
1574 | |
1575 | invalid_param_len: |
1576 | scsi_check_condition(r, SENSE_CODE(INVALID_PARAM_LEN)); |
1577 | return; |
1578 | |
1579 | invalid_field: |
1580 | scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); |
1581 | } |
1582 | |
1583 | static inline bool check_lba_range(SCSIDiskState *s, |
1584 | uint64_t sector_num, uint32_t nb_sectors) |
1585 | { |
1586 | /* |
1587 | * The first line tests that no overflow happens when computing the last |
1588 | * sector. The second line tests that the last accessed sector is in |
1589 | * range. |
1590 | * |
1591 | * Careful, the computations should not underflow for nb_sectors == 0, |
1592 | * and a 0-block read to the first LBA beyond the end of device is |
1593 | * valid. |
1594 | */ |
1595 | return (sector_num <= sector_num + nb_sectors && |
1596 | sector_num + nb_sectors <= s->qdev.max_lba + 1); |
1597 | } |
1598 | |
1599 | typedef struct UnmapCBData { |
1600 | SCSIDiskReq *r; |
1601 | uint8_t *inbuf; |
1602 | int count; |
1603 | } UnmapCBData; |
1604 | |
1605 | static void scsi_unmap_complete(void *opaque, int ret); |
1606 | |
1607 | static void scsi_unmap_complete_noio(UnmapCBData *data, int ret) |
1608 | { |
1609 | SCSIDiskReq *r = data->r; |
1610 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
1611 | uint64_t sector_num; |
1612 | uint32_t nb_sectors; |
1613 | |
1614 | assert(r->req.aiocb == NULL); |
1615 | if (scsi_disk_req_check_error(r, ret, false)) { |
1616 | goto done; |
1617 | } |
1618 | |
1619 | if (data->count > 0) { |
1620 | sector_num = ldq_be_p(&data->inbuf[0]); |
1621 | nb_sectors = ldl_be_p(&data->inbuf[8]) & 0xffffffffULL; |
1622 | if (!check_lba_range(s, sector_num, nb_sectors)) { |
1623 | scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE)); |
1624 | goto done; |
1625 | } |
1626 | |
1627 | r->req.aiocb = blk_aio_pdiscard(s->qdev.conf.blk, |
1628 | sector_num * s->qdev.blocksize, |
1629 | nb_sectors * s->qdev.blocksize, |
1630 | scsi_unmap_complete, data); |
1631 | data->count--; |
1632 | data->inbuf += 16; |
1633 | return; |
1634 | } |
1635 | |
1636 | scsi_req_complete(&r->req, GOOD); |
1637 | |
1638 | done: |
1639 | scsi_req_unref(&r->req); |
1640 | g_free(data); |
1641 | } |
1642 | |
1643 | static void scsi_unmap_complete(void *opaque, int ret) |
1644 | { |
1645 | UnmapCBData *data = opaque; |
1646 | SCSIDiskReq *r = data->r; |
1647 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
1648 | |
1649 | assert(r->req.aiocb != NULL); |
1650 | r->req.aiocb = NULL; |
1651 | |
1652 | aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk)); |
1653 | scsi_unmap_complete_noio(data, ret); |
1654 | aio_context_release(blk_get_aio_context(s->qdev.conf.blk)); |
1655 | } |
1656 | |
1657 | static void scsi_disk_emulate_unmap(SCSIDiskReq *r, uint8_t *inbuf) |
1658 | { |
1659 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
1660 | uint8_t *p = inbuf; |
1661 | int len = r->req.cmd.xfer; |
1662 | UnmapCBData *data; |
1663 | |
1664 | /* Reject ANCHOR=1. */ |
1665 | if (r->req.cmd.buf[1] & 0x1) { |
1666 | goto invalid_field; |
1667 | } |
1668 | |
1669 | if (len < 8) { |
1670 | goto invalid_param_len; |
1671 | } |
1672 | if (len < lduw_be_p(&p[0]) + 2) { |
1673 | goto invalid_param_len; |
1674 | } |
1675 | if (len < lduw_be_p(&p[2]) + 8) { |
1676 | goto invalid_param_len; |
1677 | } |
1678 | if (lduw_be_p(&p[2]) & 15) { |
1679 | goto invalid_param_len; |
1680 | } |
1681 | |
1682 | if (blk_is_read_only(s->qdev.conf.blk)) { |
1683 | scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED)); |
1684 | return; |
1685 | } |
1686 | |
1687 | data = g_new0(UnmapCBData, 1); |
1688 | data->r = r; |
1689 | data->inbuf = &p[8]; |
1690 | data->count = lduw_be_p(&p[2]) >> 4; |
1691 | |
1692 | /* The matching unref is in scsi_unmap_complete, before data is freed. */ |
1693 | scsi_req_ref(&r->req); |
1694 | scsi_unmap_complete_noio(data, 0); |
1695 | return; |
1696 | |
1697 | invalid_param_len: |
1698 | scsi_check_condition(r, SENSE_CODE(INVALID_PARAM_LEN)); |
1699 | return; |
1700 | |
1701 | invalid_field: |
1702 | scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); |
1703 | } |
1704 | |
1705 | typedef struct WriteSameCBData { |
1706 | SCSIDiskReq *r; |
1707 | int64_t sector; |
1708 | int nb_sectors; |
1709 | QEMUIOVector qiov; |
1710 | struct iovec iov; |
1711 | } WriteSameCBData; |
1712 | |
1713 | static void scsi_write_same_complete(void *opaque, int ret) |
1714 | { |
1715 | WriteSameCBData *data = opaque; |
1716 | SCSIDiskReq *r = data->r; |
1717 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
1718 | |
1719 | assert(r->req.aiocb != NULL); |
1720 | r->req.aiocb = NULL; |
1721 | aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk)); |
1722 | if (scsi_disk_req_check_error(r, ret, true)) { |
1723 | goto done; |
1724 | } |
1725 | |
1726 | block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct); |
1727 | |
1728 | data->nb_sectors -= data->iov.iov_len / 512; |
1729 | data->sector += data->iov.iov_len / 512; |
1730 | data->iov.iov_len = MIN(data->nb_sectors * 512, data->iov.iov_len); |
1731 | if (data->iov.iov_len) { |
1732 | block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, |
1733 | data->iov.iov_len, BLOCK_ACCT_WRITE); |
1734 | /* Reinitialize qiov, to handle unaligned WRITE SAME request |
1735 | * where final qiov may need smaller size */ |
1736 | qemu_iovec_init_external(&data->qiov, &data->iov, 1); |
1737 | r->req.aiocb = blk_aio_pwritev(s->qdev.conf.blk, |
1738 | data->sector << BDRV_SECTOR_BITS, |
1739 | &data->qiov, 0, |
1740 | scsi_write_same_complete, data); |
1741 | aio_context_release(blk_get_aio_context(s->qdev.conf.blk)); |
1742 | return; |
1743 | } |
1744 | |
1745 | scsi_req_complete(&r->req, GOOD); |
1746 | |
1747 | done: |
1748 | scsi_req_unref(&r->req); |
1749 | qemu_vfree(data->iov.iov_base); |
1750 | g_free(data); |
1751 | aio_context_release(blk_get_aio_context(s->qdev.conf.blk)); |
1752 | } |
1753 | |
1754 | static void scsi_disk_emulate_write_same(SCSIDiskReq *r, uint8_t *inbuf) |
1755 | { |
1756 | SCSIRequest *req = &r->req; |
1757 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); |
1758 | uint32_t nb_sectors = scsi_data_cdb_xfer(r->req.cmd.buf); |
1759 | WriteSameCBData *data; |
1760 | uint8_t *buf; |
1761 | int i; |
1762 | |
1763 | /* Fail if PBDATA=1 or LBDATA=1 or ANCHOR=1. */ |
1764 | if (nb_sectors == 0 || (req->cmd.buf[1] & 0x16)) { |
1765 | scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); |
1766 | return; |
1767 | } |
1768 | |
1769 | if (blk_is_read_only(s->qdev.conf.blk)) { |
1770 | scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED)); |
1771 | return; |
1772 | } |
1773 | if (!check_lba_range(s, r->req.cmd.lba, nb_sectors)) { |
1774 | scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE)); |
1775 | return; |
1776 | } |
1777 | |
1778 | if ((req->cmd.buf[1] & 0x1) || buffer_is_zero(inbuf, s->qdev.blocksize)) { |
1779 | int flags = (req->cmd.buf[1] & 0x8) ? BDRV_REQ_MAY_UNMAP : 0; |
1780 | |
1781 | /* The request is used as the AIO opaque value, so add a ref. */ |
1782 | scsi_req_ref(&r->req); |
1783 | block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, |
1784 | nb_sectors * s->qdev.blocksize, |
1785 | BLOCK_ACCT_WRITE); |
1786 | r->req.aiocb = blk_aio_pwrite_zeroes(s->qdev.conf.blk, |
1787 | r->req.cmd.lba * s->qdev.blocksize, |
1788 | nb_sectors * s->qdev.blocksize, |
1789 | flags, scsi_aio_complete, r); |
1790 | return; |
1791 | } |
1792 | |
1793 | data = g_new0(WriteSameCBData, 1); |
1794 | data->r = r; |
1795 | data->sector = r->req.cmd.lba * (s->qdev.blocksize / 512); |
1796 | data->nb_sectors = nb_sectors * (s->qdev.blocksize / 512); |
1797 | data->iov.iov_len = MIN(data->nb_sectors * 512, SCSI_WRITE_SAME_MAX); |
1798 | data->iov.iov_base = buf = blk_blockalign(s->qdev.conf.blk, |
1799 | data->iov.iov_len); |
1800 | qemu_iovec_init_external(&data->qiov, &data->iov, 1); |
1801 | |
1802 | for (i = 0; i < data->iov.iov_len; i += s->qdev.blocksize) { |
1803 | memcpy(&buf[i], inbuf, s->qdev.blocksize); |
1804 | } |
1805 | |
1806 | scsi_req_ref(&r->req); |
1807 | block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, |
1808 | data->iov.iov_len, BLOCK_ACCT_WRITE); |
1809 | r->req.aiocb = blk_aio_pwritev(s->qdev.conf.blk, |
1810 | data->sector << BDRV_SECTOR_BITS, |
1811 | &data->qiov, 0, |
1812 | scsi_write_same_complete, data); |
1813 | } |
1814 | |
1815 | static void scsi_disk_emulate_write_data(SCSIRequest *req) |
1816 | { |
1817 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
1818 | |
1819 | if (r->iov.iov_len) { |
1820 | int buflen = r->iov.iov_len; |
1821 | trace_scsi_disk_emulate_write_data(buflen); |
1822 | r->iov.iov_len = 0; |
1823 | scsi_req_data(&r->req, buflen); |
1824 | return; |
1825 | } |
1826 | |
1827 | switch (req->cmd.buf[0]) { |
1828 | case MODE_SELECT: |
1829 | case MODE_SELECT_10: |
1830 | /* This also clears the sense buffer for REQUEST SENSE. */ |
1831 | scsi_disk_emulate_mode_select(r, r->iov.iov_base); |
1832 | break; |
1833 | |
1834 | case UNMAP: |
1835 | scsi_disk_emulate_unmap(r, r->iov.iov_base); |
1836 | break; |
1837 | |
1838 | case VERIFY_10: |
1839 | case VERIFY_12: |
1840 | case VERIFY_16: |
1841 | if (r->req.status == -1) { |
1842 | scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); |
1843 | } |
1844 | break; |
1845 | |
1846 | case WRITE_SAME_10: |
1847 | case WRITE_SAME_16: |
1848 | scsi_disk_emulate_write_same(r, r->iov.iov_base); |
1849 | break; |
1850 | |
1851 | default: |
1852 | abort(); |
1853 | } |
1854 | } |
1855 | |
1856 | static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf) |
1857 | { |
1858 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
1859 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); |
1860 | uint64_t nb_sectors; |
1861 | uint8_t *outbuf; |
1862 | int buflen; |
1863 | |
1864 | switch (req->cmd.buf[0]) { |
1865 | case INQUIRY: |
1866 | case MODE_SENSE: |
1867 | case MODE_SENSE_10: |
1868 | case RESERVE: |
1869 | case RESERVE_10: |
1870 | case RELEASE: |
1871 | case RELEASE_10: |
1872 | case START_STOP: |
1873 | case ALLOW_MEDIUM_REMOVAL: |
1874 | case GET_CONFIGURATION: |
1875 | case GET_EVENT_STATUS_NOTIFICATION: |
1876 | case MECHANISM_STATUS: |
1877 | case REQUEST_SENSE: |
1878 | break; |
1879 | |
1880 | default: |
1881 | if (!blk_is_available(s->qdev.conf.blk)) { |
1882 | scsi_check_condition(r, SENSE_CODE(NO_MEDIUM)); |
1883 | return 0; |
1884 | } |
1885 | break; |
1886 | } |
1887 | |
1888 | /* |
1889 | * FIXME: we shouldn't return anything bigger than 4k, but the code |
1890 | * requires the buffer to be as big as req->cmd.xfer in several |
1891 | * places. So, do not allow CDBs with a very large ALLOCATION |
1892 | * LENGTH. The real fix would be to modify scsi_read_data and |
1893 | * dma_buf_read, so that they return data beyond the buflen |
1894 | * as all zeros. |
1895 | */ |
1896 | if (req->cmd.xfer > 65536) { |
1897 | goto illegal_request; |
1898 | } |
1899 | r->buflen = MAX(4096, req->cmd.xfer); |
1900 | |
1901 | if (!r->iov.iov_base) { |
1902 | r->iov.iov_base = blk_blockalign(s->qdev.conf.blk, r->buflen); |
1903 | } |
1904 | |
1905 | buflen = req->cmd.xfer; |
1906 | outbuf = r->iov.iov_base; |
1907 | memset(outbuf, 0, r->buflen); |
1908 | switch (req->cmd.buf[0]) { |
1909 | case TEST_UNIT_READY: |
1910 | assert(blk_is_available(s->qdev.conf.blk)); |
1911 | break; |
1912 | case INQUIRY: |
1913 | buflen = scsi_disk_emulate_inquiry(req, outbuf); |
1914 | if (buflen < 0) { |
1915 | goto illegal_request; |
1916 | } |
1917 | break; |
1918 | case MODE_SENSE: |
1919 | case MODE_SENSE_10: |
1920 | buflen = scsi_disk_emulate_mode_sense(r, outbuf); |
1921 | if (buflen < 0) { |
1922 | goto illegal_request; |
1923 | } |
1924 | break; |
1925 | case READ_TOC: |
1926 | buflen = scsi_disk_emulate_read_toc(req, outbuf); |
1927 | if (buflen < 0) { |
1928 | goto illegal_request; |
1929 | } |
1930 | break; |
1931 | case RESERVE: |
1932 | if (req->cmd.buf[1] & 1) { |
1933 | goto illegal_request; |
1934 | } |
1935 | break; |
1936 | case RESERVE_10: |
1937 | if (req->cmd.buf[1] & 3) { |
1938 | goto illegal_request; |
1939 | } |
1940 | break; |
1941 | case RELEASE: |
1942 | if (req->cmd.buf[1] & 1) { |
1943 | goto illegal_request; |
1944 | } |
1945 | break; |
1946 | case RELEASE_10: |
1947 | if (req->cmd.buf[1] & 3) { |
1948 | goto illegal_request; |
1949 | } |
1950 | break; |
1951 | case START_STOP: |
1952 | if (scsi_disk_emulate_start_stop(r) < 0) { |
1953 | return 0; |
1954 | } |
1955 | break; |
1956 | case ALLOW_MEDIUM_REMOVAL: |
1957 | s->tray_locked = req->cmd.buf[4] & 1; |
1958 | blk_lock_medium(s->qdev.conf.blk, req->cmd.buf[4] & 1); |
1959 | break; |
1960 | case READ_CAPACITY_10: |
1961 | /* The normal LEN field for this command is zero. */ |
1962 | memset(outbuf, 0, 8); |
1963 | blk_get_geometry(s->qdev.conf.blk, &nb_sectors); |
1964 | if (!nb_sectors) { |
1965 | scsi_check_condition(r, SENSE_CODE(LUN_NOT_READY)); |
1966 | return 0; |
1967 | } |
1968 | if ((req->cmd.buf[8] & 1) == 0 && req->cmd.lba) { |
1969 | goto illegal_request; |
1970 | } |
1971 | nb_sectors /= s->qdev.blocksize / 512; |
1972 | /* Returned value is the address of the last sector. */ |
1973 | nb_sectors--; |
1974 | /* Remember the new size for read/write sanity checking. */ |
1975 | s->qdev.max_lba = nb_sectors; |
1976 | /* Clip to 2TB, instead of returning capacity modulo 2TB. */ |
1977 | if (nb_sectors > UINT32_MAX) { |
1978 | nb_sectors = UINT32_MAX; |
1979 | } |
1980 | outbuf[0] = (nb_sectors >> 24) & 0xff; |
1981 | outbuf[1] = (nb_sectors >> 16) & 0xff; |
1982 | outbuf[2] = (nb_sectors >> 8) & 0xff; |
1983 | outbuf[3] = nb_sectors & 0xff; |
1984 | outbuf[4] = 0; |
1985 | outbuf[5] = 0; |
1986 | outbuf[6] = s->qdev.blocksize >> 8; |
1987 | outbuf[7] = 0; |
1988 | break; |
1989 | case REQUEST_SENSE: |
1990 | /* Just return "NO SENSE". */ |
1991 | buflen = scsi_convert_sense(NULL, 0, outbuf, r->buflen, |
1992 | (req->cmd.buf[1] & 1) == 0); |
1993 | if (buflen < 0) { |
1994 | goto illegal_request; |
1995 | } |
1996 | break; |
1997 | case MECHANISM_STATUS: |
1998 | buflen = scsi_emulate_mechanism_status(s, outbuf); |
1999 | if (buflen < 0) { |
2000 | goto illegal_request; |
2001 | } |
2002 | break; |
2003 | case GET_CONFIGURATION: |
2004 | buflen = scsi_get_configuration(s, outbuf); |
2005 | if (buflen < 0) { |
2006 | goto illegal_request; |
2007 | } |
2008 | break; |
2009 | case GET_EVENT_STATUS_NOTIFICATION: |
2010 | buflen = scsi_get_event_status_notification(s, r, outbuf); |
2011 | if (buflen < 0) { |
2012 | goto illegal_request; |
2013 | } |
2014 | break; |
2015 | case READ_DISC_INFORMATION: |
2016 | buflen = scsi_read_disc_information(s, r, outbuf); |
2017 | if (buflen < 0) { |
2018 | goto illegal_request; |
2019 | } |
2020 | break; |
2021 | case READ_DVD_STRUCTURE: |
2022 | buflen = scsi_read_dvd_structure(s, r, outbuf); |
2023 | if (buflen < 0) { |
2024 | goto illegal_request; |
2025 | } |
2026 | break; |
2027 | case SERVICE_ACTION_IN_16: |
2028 | /* Service Action In subcommands. */ |
2029 | if ((req->cmd.buf[1] & 31) == SAI_READ_CAPACITY_16) { |
2030 | trace_scsi_disk_emulate_command_SAI_16(); |
2031 | memset(outbuf, 0, req->cmd.xfer); |
2032 | blk_get_geometry(s->qdev.conf.blk, &nb_sectors); |
2033 | if (!nb_sectors) { |
2034 | scsi_check_condition(r, SENSE_CODE(LUN_NOT_READY)); |
2035 | return 0; |
2036 | } |
2037 | if ((req->cmd.buf[14] & 1) == 0 && req->cmd.lba) { |
2038 | goto illegal_request; |
2039 | } |
2040 | nb_sectors /= s->qdev.blocksize / 512; |
2041 | /* Returned value is the address of the last sector. */ |
2042 | nb_sectors--; |
2043 | /* Remember the new size for read/write sanity checking. */ |
2044 | s->qdev.max_lba = nb_sectors; |
2045 | outbuf[0] = (nb_sectors >> 56) & 0xff; |
2046 | outbuf[1] = (nb_sectors >> 48) & 0xff; |
2047 | outbuf[2] = (nb_sectors >> 40) & 0xff; |
2048 | outbuf[3] = (nb_sectors >> 32) & 0xff; |
2049 | outbuf[4] = (nb_sectors >> 24) & 0xff; |
2050 | outbuf[5] = (nb_sectors >> 16) & 0xff; |
2051 | outbuf[6] = (nb_sectors >> 8) & 0xff; |
2052 | outbuf[7] = nb_sectors & 0xff; |
2053 | outbuf[8] = 0; |
2054 | outbuf[9] = 0; |
2055 | outbuf[10] = s->qdev.blocksize >> 8; |
2056 | outbuf[11] = 0; |
2057 | outbuf[12] = 0; |
2058 | outbuf[13] = get_physical_block_exp(&s->qdev.conf); |
2059 | |
2060 | /* set TPE bit if the format supports discard */ |
2061 | if (s->qdev.conf.discard_granularity) { |
2062 | outbuf[14] = 0x80; |
2063 | } |
2064 | |
2065 | /* Protection, exponent and lowest lba field left blank. */ |
2066 | break; |
2067 | } |
2068 | trace_scsi_disk_emulate_command_SAI_unsupported(); |
2069 | goto illegal_request; |
2070 | case SYNCHRONIZE_CACHE: |
2071 | /* The request is used as the AIO opaque value, so add a ref. */ |
2072 | scsi_req_ref(&r->req); |
2073 | block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0, |
2074 | BLOCK_ACCT_FLUSH); |
2075 | r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_aio_complete, r); |
2076 | return 0; |
2077 | case SEEK_10: |
2078 | trace_scsi_disk_emulate_command_SEEK_10(r->req.cmd.lba); |
2079 | if (r->req.cmd.lba > s->qdev.max_lba) { |
2080 | goto illegal_lba; |
2081 | } |
2082 | break; |
2083 | case MODE_SELECT: |
2084 | trace_scsi_disk_emulate_command_MODE_SELECT(r->req.cmd.xfer); |
2085 | break; |
2086 | case MODE_SELECT_10: |
2087 | trace_scsi_disk_emulate_command_MODE_SELECT_10(r->req.cmd.xfer); |
2088 | break; |
2089 | case UNMAP: |
2090 | trace_scsi_disk_emulate_command_UNMAP(r->req.cmd.xfer); |
2091 | break; |
2092 | case VERIFY_10: |
2093 | case VERIFY_12: |
2094 | case VERIFY_16: |
2095 | trace_scsi_disk_emulate_command_VERIFY((req->cmd.buf[1] >> 1) & 3); |
2096 | if (req->cmd.buf[1] & 6) { |
2097 | goto illegal_request; |
2098 | } |
2099 | break; |
2100 | case WRITE_SAME_10: |
2101 | case WRITE_SAME_16: |
2102 | trace_scsi_disk_emulate_command_WRITE_SAME( |
2103 | req->cmd.buf[0] == WRITE_SAME_10 ? 10 : 16, r->req.cmd.xfer); |
2104 | break; |
2105 | default: |
2106 | trace_scsi_disk_emulate_command_UNKNOWN(buf[0], |
2107 | scsi_command_name(buf[0])); |
2108 | scsi_check_condition(r, SENSE_CODE(INVALID_OPCODE)); |
2109 | return 0; |
2110 | } |
2111 | assert(!r->req.aiocb); |
2112 | r->iov.iov_len = MIN(r->buflen, req->cmd.xfer); |
2113 | if (r->iov.iov_len == 0) { |
2114 | scsi_req_complete(&r->req, GOOD); |
2115 | } |
2116 | if (r->req.cmd.mode == SCSI_XFER_TO_DEV) { |
2117 | assert(r->iov.iov_len == req->cmd.xfer); |
2118 | return -r->iov.iov_len; |
2119 | } else { |
2120 | return r->iov.iov_len; |
2121 | } |
2122 | |
2123 | illegal_request: |
2124 | if (r->req.status == -1) { |
2125 | scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); |
2126 | } |
2127 | return 0; |
2128 | |
2129 | illegal_lba: |
2130 | scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE)); |
2131 | return 0; |
2132 | } |
2133 | |
2134 | /* Execute a scsi command. Returns the length of the data expected by the |
2135 | command. This will be Positive for data transfers from the device |
2136 | (eg. disk reads), negative for transfers to the device (eg. disk writes), |
2137 | and zero if the command does not transfer any data. */ |
2138 | |
2139 | static int32_t scsi_disk_dma_command(SCSIRequest *req, uint8_t *buf) |
2140 | { |
2141 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
2142 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); |
2143 | SCSIDiskClass *sdc = (SCSIDiskClass *) object_get_class(OBJECT(s)); |
2144 | uint32_t len; |
2145 | uint8_t command; |
2146 | |
2147 | command = buf[0]; |
2148 | |
2149 | if (!blk_is_available(s->qdev.conf.blk)) { |
2150 | scsi_check_condition(r, SENSE_CODE(NO_MEDIUM)); |
2151 | return 0; |
2152 | } |
2153 | |
2154 | len = scsi_data_cdb_xfer(r->req.cmd.buf); |
2155 | switch (command) { |
2156 | case READ_6: |
2157 | case READ_10: |
2158 | case READ_12: |
2159 | case READ_16: |
2160 | trace_scsi_disk_dma_command_READ(r->req.cmd.lba, len); |
2161 | /* Protection information is not supported. For SCSI versions 2 and |
2162 | * older (as determined by snooping the guest's INQUIRY commands), |
2163 | * there is no RD/WR/VRPROTECT, so skip this check in these versions. |
2164 | */ |
2165 | if (s->qdev.scsi_version > 2 && (r->req.cmd.buf[1] & 0xe0)) { |
2166 | goto illegal_request; |
2167 | } |
2168 | if (!check_lba_range(s, r->req.cmd.lba, len)) { |
2169 | goto illegal_lba; |
2170 | } |
2171 | r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512); |
2172 | r->sector_count = len * (s->qdev.blocksize / 512); |
2173 | break; |
2174 | case WRITE_6: |
2175 | case WRITE_10: |
2176 | case WRITE_12: |
2177 | case WRITE_16: |
2178 | case WRITE_VERIFY_10: |
2179 | case WRITE_VERIFY_12: |
2180 | case WRITE_VERIFY_16: |
2181 | if (blk_is_read_only(s->qdev.conf.blk)) { |
2182 | scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED)); |
2183 | return 0; |
2184 | } |
2185 | trace_scsi_disk_dma_command_WRITE( |
2186 | (command & 0xe) == 0xe ? "And Verify " : "" , |
2187 | r->req.cmd.lba, len); |
2188 | /* fall through */ |
2189 | case VERIFY_10: |
2190 | case VERIFY_12: |
2191 | case VERIFY_16: |
2192 | /* We get here only for BYTCHK == 0x01 and only for scsi-block. |
2193 | * As far as DMA is concerned, we can treat it the same as a write; |
2194 | * scsi_block_do_sgio will send VERIFY commands. |
2195 | */ |
2196 | if (s->qdev.scsi_version > 2 && (r->req.cmd.buf[1] & 0xe0)) { |
2197 | goto illegal_request; |
2198 | } |
2199 | if (!check_lba_range(s, r->req.cmd.lba, len)) { |
2200 | goto illegal_lba; |
2201 | } |
2202 | r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512); |
2203 | r->sector_count = len * (s->qdev.blocksize / 512); |
2204 | break; |
2205 | default: |
2206 | abort(); |
2207 | illegal_request: |
2208 | scsi_check_condition(r, SENSE_CODE(INVALID_FIELD)); |
2209 | return 0; |
2210 | illegal_lba: |
2211 | scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE)); |
2212 | return 0; |
2213 | } |
2214 | r->need_fua_emulation = sdc->need_fua_emulation(&r->req.cmd); |
2215 | if (r->sector_count == 0) { |
2216 | scsi_req_complete(&r->req, GOOD); |
2217 | } |
2218 | assert(r->iov.iov_len == 0); |
2219 | if (r->req.cmd.mode == SCSI_XFER_TO_DEV) { |
2220 | return -r->sector_count * 512; |
2221 | } else { |
2222 | return r->sector_count * 512; |
2223 | } |
2224 | } |
2225 | |
2226 | static void scsi_disk_reset(DeviceState *dev) |
2227 | { |
2228 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev.qdev, dev); |
2229 | uint64_t nb_sectors; |
2230 | |
2231 | scsi_device_purge_requests(&s->qdev, SENSE_CODE(RESET)); |
2232 | |
2233 | blk_get_geometry(s->qdev.conf.blk, &nb_sectors); |
2234 | nb_sectors /= s->qdev.blocksize / 512; |
2235 | if (nb_sectors) { |
2236 | nb_sectors--; |
2237 | } |
2238 | s->qdev.max_lba = nb_sectors; |
2239 | /* reset tray statuses */ |
2240 | s->tray_locked = 0; |
2241 | s->tray_open = 0; |
2242 | |
2243 | s->qdev.scsi_version = s->qdev.default_scsi_version; |
2244 | } |
2245 | |
2246 | static void scsi_disk_resize_cb(void *opaque) |
2247 | { |
2248 | SCSIDiskState *s = opaque; |
2249 | |
2250 | /* SPC lists this sense code as available only for |
2251 | * direct-access devices. |
2252 | */ |
2253 | if (s->qdev.type == TYPE_DISK) { |
2254 | scsi_device_report_change(&s->qdev, SENSE_CODE(CAPACITY_CHANGED)); |
2255 | } |
2256 | } |
2257 | |
2258 | static void scsi_cd_change_media_cb(void *opaque, bool load, Error **errp) |
2259 | { |
2260 | SCSIDiskState *s = opaque; |
2261 | |
2262 | /* |
2263 | * When a CD gets changed, we have to report an ejected state and |
2264 | * then a loaded state to guests so that they detect tray |
2265 | * open/close and media change events. Guests that do not use |
2266 | * GET_EVENT_STATUS_NOTIFICATION to detect such tray open/close |
2267 | * states rely on this behavior. |
2268 | * |
2269 | * media_changed governs the state machine used for unit attention |
2270 | * report. media_event is used by GET EVENT STATUS NOTIFICATION. |
2271 | */ |
2272 | s->media_changed = load; |
2273 | s->tray_open = !load; |
2274 | scsi_device_set_ua(&s->qdev, SENSE_CODE(UNIT_ATTENTION_NO_MEDIUM)); |
2275 | s->media_event = true; |
2276 | s->eject_request = false; |
2277 | } |
2278 | |
2279 | static void scsi_cd_eject_request_cb(void *opaque, bool force) |
2280 | { |
2281 | SCSIDiskState *s = opaque; |
2282 | |
2283 | s->eject_request = true; |
2284 | if (force) { |
2285 | s->tray_locked = false; |
2286 | } |
2287 | } |
2288 | |
2289 | static bool scsi_cd_is_tray_open(void *opaque) |
2290 | { |
2291 | return ((SCSIDiskState *)opaque)->tray_open; |
2292 | } |
2293 | |
2294 | static bool scsi_cd_is_medium_locked(void *opaque) |
2295 | { |
2296 | return ((SCSIDiskState *)opaque)->tray_locked; |
2297 | } |
2298 | |
2299 | static const BlockDevOps scsi_disk_removable_block_ops = { |
2300 | .change_media_cb = scsi_cd_change_media_cb, |
2301 | .eject_request_cb = scsi_cd_eject_request_cb, |
2302 | .is_tray_open = scsi_cd_is_tray_open, |
2303 | .is_medium_locked = scsi_cd_is_medium_locked, |
2304 | |
2305 | .resize_cb = scsi_disk_resize_cb, |
2306 | }; |
2307 | |
2308 | static const BlockDevOps scsi_disk_block_ops = { |
2309 | .resize_cb = scsi_disk_resize_cb, |
2310 | }; |
2311 | |
2312 | static void scsi_disk_unit_attention_reported(SCSIDevice *dev) |
2313 | { |
2314 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); |
2315 | if (s->media_changed) { |
2316 | s->media_changed = false; |
2317 | scsi_device_set_ua(&s->qdev, SENSE_CODE(MEDIUM_CHANGED)); |
2318 | } |
2319 | } |
2320 | |
2321 | static void scsi_realize(SCSIDevice *dev, Error **errp) |
2322 | { |
2323 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); |
2324 | bool read_only; |
2325 | |
2326 | if (!s->qdev.conf.blk) { |
2327 | error_setg(errp, "drive property not set" ); |
2328 | return; |
2329 | } |
2330 | |
2331 | if (!(s->features & (1 << SCSI_DISK_F_REMOVABLE)) && |
2332 | !blk_is_inserted(s->qdev.conf.blk)) { |
2333 | error_setg(errp, "Device needs media, but drive is empty" ); |
2334 | return; |
2335 | } |
2336 | |
2337 | blkconf_blocksizes(&s->qdev.conf); |
2338 | |
2339 | if (s->qdev.conf.logical_block_size > |
2340 | s->qdev.conf.physical_block_size) { |
2341 | error_setg(errp, |
2342 | "logical_block_size > physical_block_size not supported" ); |
2343 | return; |
2344 | } |
2345 | |
2346 | if (blk_get_aio_context(s->qdev.conf.blk) != qemu_get_aio_context() && |
2347 | !s->qdev.hba_supports_iothread) |
2348 | { |
2349 | error_setg(errp, "HBA does not support iothreads" ); |
2350 | return; |
2351 | } |
2352 | |
2353 | if (dev->type == TYPE_DISK) { |
2354 | if (!blkconf_geometry(&dev->conf, NULL, 65535, 255, 255, errp)) { |
2355 | return; |
2356 | } |
2357 | } |
2358 | |
2359 | read_only = blk_is_read_only(s->qdev.conf.blk); |
2360 | if (dev->type == TYPE_ROM) { |
2361 | read_only = true; |
2362 | } |
2363 | |
2364 | if (!blkconf_apply_backend_options(&dev->conf, read_only, |
2365 | dev->type == TYPE_DISK, errp)) { |
2366 | return; |
2367 | } |
2368 | |
2369 | if (s->qdev.conf.discard_granularity == -1) { |
2370 | s->qdev.conf.discard_granularity = |
2371 | MAX(s->qdev.conf.logical_block_size, DEFAULT_DISCARD_GRANULARITY); |
2372 | } |
2373 | |
2374 | if (!s->version) { |
2375 | s->version = g_strdup(qemu_hw_version()); |
2376 | } |
2377 | if (!s->vendor) { |
2378 | s->vendor = g_strdup("QEMU" ); |
2379 | } |
2380 | if (!s->device_id) { |
2381 | if (s->serial) { |
2382 | s->device_id = g_strdup_printf("%.20s" , s->serial); |
2383 | } else { |
2384 | const char *str = blk_name(s->qdev.conf.blk); |
2385 | if (str && *str) { |
2386 | s->device_id = g_strdup(str); |
2387 | } |
2388 | } |
2389 | } |
2390 | |
2391 | if (blk_is_sg(s->qdev.conf.blk)) { |
2392 | error_setg(errp, "unwanted /dev/sg*" ); |
2393 | return; |
2394 | } |
2395 | |
2396 | if ((s->features & (1 << SCSI_DISK_F_REMOVABLE)) && |
2397 | !(s->features & (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS))) { |
2398 | blk_set_dev_ops(s->qdev.conf.blk, &scsi_disk_removable_block_ops, s); |
2399 | } else { |
2400 | blk_set_dev_ops(s->qdev.conf.blk, &scsi_disk_block_ops, s); |
2401 | } |
2402 | blk_set_guest_block_size(s->qdev.conf.blk, s->qdev.blocksize); |
2403 | |
2404 | blk_iostatus_enable(s->qdev.conf.blk); |
2405 | } |
2406 | |
2407 | static void scsi_hd_realize(SCSIDevice *dev, Error **errp) |
2408 | { |
2409 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); |
2410 | AioContext *ctx = NULL; |
2411 | /* can happen for devices without drive. The error message for missing |
2412 | * backend will be issued in scsi_realize |
2413 | */ |
2414 | if (s->qdev.conf.blk) { |
2415 | ctx = blk_get_aio_context(s->qdev.conf.blk); |
2416 | aio_context_acquire(ctx); |
2417 | blkconf_blocksizes(&s->qdev.conf); |
2418 | } |
2419 | s->qdev.blocksize = s->qdev.conf.logical_block_size; |
2420 | s->qdev.type = TYPE_DISK; |
2421 | if (!s->product) { |
2422 | s->product = g_strdup("QEMU HARDDISK" ); |
2423 | } |
2424 | scsi_realize(&s->qdev, errp); |
2425 | if (ctx) { |
2426 | aio_context_release(ctx); |
2427 | } |
2428 | } |
2429 | |
2430 | static void scsi_cd_realize(SCSIDevice *dev, Error **errp) |
2431 | { |
2432 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); |
2433 | AioContext *ctx; |
2434 | int ret; |
2435 | |
2436 | if (!dev->conf.blk) { |
2437 | /* Anonymous BlockBackend for an empty drive. As we put it into |
2438 | * dev->conf, qdev takes care of detaching on unplug. */ |
2439 | dev->conf.blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL); |
2440 | ret = blk_attach_dev(dev->conf.blk, &dev->qdev); |
2441 | assert(ret == 0); |
2442 | } |
2443 | |
2444 | ctx = blk_get_aio_context(dev->conf.blk); |
2445 | aio_context_acquire(ctx); |
2446 | s->qdev.blocksize = 2048; |
2447 | s->qdev.type = TYPE_ROM; |
2448 | s->features |= 1 << SCSI_DISK_F_REMOVABLE; |
2449 | if (!s->product) { |
2450 | s->product = g_strdup("QEMU CD-ROM" ); |
2451 | } |
2452 | scsi_realize(&s->qdev, errp); |
2453 | aio_context_release(ctx); |
2454 | } |
2455 | |
2456 | static void scsi_disk_realize(SCSIDevice *dev, Error **errp) |
2457 | { |
2458 | DriveInfo *dinfo; |
2459 | Error *local_err = NULL; |
2460 | |
2461 | if (!dev->conf.blk) { |
2462 | scsi_realize(dev, &local_err); |
2463 | assert(local_err); |
2464 | error_propagate(errp, local_err); |
2465 | return; |
2466 | } |
2467 | |
2468 | dinfo = blk_legacy_dinfo(dev->conf.blk); |
2469 | if (dinfo && dinfo->media_cd) { |
2470 | scsi_cd_realize(dev, errp); |
2471 | } else { |
2472 | scsi_hd_realize(dev, errp); |
2473 | } |
2474 | } |
2475 | |
2476 | static const SCSIReqOps scsi_disk_emulate_reqops = { |
2477 | .size = sizeof(SCSIDiskReq), |
2478 | .free_req = scsi_free_request, |
2479 | .send_command = scsi_disk_emulate_command, |
2480 | .read_data = scsi_disk_emulate_read_data, |
2481 | .write_data = scsi_disk_emulate_write_data, |
2482 | .get_buf = scsi_get_buf, |
2483 | }; |
2484 | |
2485 | static const SCSIReqOps scsi_disk_dma_reqops = { |
2486 | .size = sizeof(SCSIDiskReq), |
2487 | .free_req = scsi_free_request, |
2488 | .send_command = scsi_disk_dma_command, |
2489 | .read_data = scsi_read_data, |
2490 | .write_data = scsi_write_data, |
2491 | .get_buf = scsi_get_buf, |
2492 | .load_request = scsi_disk_load_request, |
2493 | .save_request = scsi_disk_save_request, |
2494 | }; |
2495 | |
2496 | static const SCSIReqOps *const scsi_disk_reqops_dispatch[256] = { |
2497 | [TEST_UNIT_READY] = &scsi_disk_emulate_reqops, |
2498 | [INQUIRY] = &scsi_disk_emulate_reqops, |
2499 | [MODE_SENSE] = &scsi_disk_emulate_reqops, |
2500 | [MODE_SENSE_10] = &scsi_disk_emulate_reqops, |
2501 | [START_STOP] = &scsi_disk_emulate_reqops, |
2502 | [ALLOW_MEDIUM_REMOVAL] = &scsi_disk_emulate_reqops, |
2503 | [READ_CAPACITY_10] = &scsi_disk_emulate_reqops, |
2504 | [READ_TOC] = &scsi_disk_emulate_reqops, |
2505 | [READ_DVD_STRUCTURE] = &scsi_disk_emulate_reqops, |
2506 | [READ_DISC_INFORMATION] = &scsi_disk_emulate_reqops, |
2507 | [GET_CONFIGURATION] = &scsi_disk_emulate_reqops, |
2508 | [GET_EVENT_STATUS_NOTIFICATION] = &scsi_disk_emulate_reqops, |
2509 | [MECHANISM_STATUS] = &scsi_disk_emulate_reqops, |
2510 | [SERVICE_ACTION_IN_16] = &scsi_disk_emulate_reqops, |
2511 | [REQUEST_SENSE] = &scsi_disk_emulate_reqops, |
2512 | [SYNCHRONIZE_CACHE] = &scsi_disk_emulate_reqops, |
2513 | [SEEK_10] = &scsi_disk_emulate_reqops, |
2514 | [MODE_SELECT] = &scsi_disk_emulate_reqops, |
2515 | [MODE_SELECT_10] = &scsi_disk_emulate_reqops, |
2516 | [UNMAP] = &scsi_disk_emulate_reqops, |
2517 | [WRITE_SAME_10] = &scsi_disk_emulate_reqops, |
2518 | [WRITE_SAME_16] = &scsi_disk_emulate_reqops, |
2519 | [VERIFY_10] = &scsi_disk_emulate_reqops, |
2520 | [VERIFY_12] = &scsi_disk_emulate_reqops, |
2521 | [VERIFY_16] = &scsi_disk_emulate_reqops, |
2522 | |
2523 | [READ_6] = &scsi_disk_dma_reqops, |
2524 | [READ_10] = &scsi_disk_dma_reqops, |
2525 | [READ_12] = &scsi_disk_dma_reqops, |
2526 | [READ_16] = &scsi_disk_dma_reqops, |
2527 | [WRITE_6] = &scsi_disk_dma_reqops, |
2528 | [WRITE_10] = &scsi_disk_dma_reqops, |
2529 | [WRITE_12] = &scsi_disk_dma_reqops, |
2530 | [WRITE_16] = &scsi_disk_dma_reqops, |
2531 | [WRITE_VERIFY_10] = &scsi_disk_dma_reqops, |
2532 | [WRITE_VERIFY_12] = &scsi_disk_dma_reqops, |
2533 | [WRITE_VERIFY_16] = &scsi_disk_dma_reqops, |
2534 | }; |
2535 | |
2536 | static void scsi_disk_new_request_dump(uint32_t lun, uint32_t tag, uint8_t *buf) |
2537 | { |
2538 | int i; |
2539 | int len = scsi_cdb_length(buf); |
2540 | char *line_buffer, *p; |
2541 | |
2542 | line_buffer = g_malloc(len * 5 + 1); |
2543 | |
2544 | for (i = 0, p = line_buffer; i < len; i++) { |
2545 | p += sprintf(p, " 0x%02x" , buf[i]); |
2546 | } |
2547 | trace_scsi_disk_new_request(lun, tag, line_buffer); |
2548 | |
2549 | g_free(line_buffer); |
2550 | } |
2551 | |
2552 | static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t lun, |
2553 | uint8_t *buf, void *hba_private) |
2554 | { |
2555 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d); |
2556 | SCSIRequest *req; |
2557 | const SCSIReqOps *ops; |
2558 | uint8_t command; |
2559 | |
2560 | command = buf[0]; |
2561 | ops = scsi_disk_reqops_dispatch[command]; |
2562 | if (!ops) { |
2563 | ops = &scsi_disk_emulate_reqops; |
2564 | } |
2565 | req = scsi_req_alloc(ops, &s->qdev, tag, lun, hba_private); |
2566 | |
2567 | if (trace_event_get_state_backends(TRACE_SCSI_DISK_NEW_REQUEST)) { |
2568 | scsi_disk_new_request_dump(lun, tag, buf); |
2569 | } |
2570 | |
2571 | return req; |
2572 | } |
2573 | |
2574 | #ifdef __linux__ |
2575 | static int get_device_type(SCSIDiskState *s) |
2576 | { |
2577 | uint8_t cmd[16]; |
2578 | uint8_t buf[36]; |
2579 | int ret; |
2580 | |
2581 | memset(cmd, 0, sizeof(cmd)); |
2582 | memset(buf, 0, sizeof(buf)); |
2583 | cmd[0] = INQUIRY; |
2584 | cmd[4] = sizeof(buf); |
2585 | |
2586 | ret = scsi_SG_IO_FROM_DEV(s->qdev.conf.blk, cmd, sizeof(cmd), |
2587 | buf, sizeof(buf)); |
2588 | if (ret < 0) { |
2589 | return -1; |
2590 | } |
2591 | s->qdev.type = buf[0]; |
2592 | if (buf[1] & 0x80) { |
2593 | s->features |= 1 << SCSI_DISK_F_REMOVABLE; |
2594 | } |
2595 | return 0; |
2596 | } |
2597 | |
2598 | static void scsi_block_realize(SCSIDevice *dev, Error **errp) |
2599 | { |
2600 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); |
2601 | AioContext *ctx; |
2602 | int sg_version; |
2603 | int rc; |
2604 | |
2605 | if (!s->qdev.conf.blk) { |
2606 | error_setg(errp, "drive property not set" ); |
2607 | return; |
2608 | } |
2609 | |
2610 | if (s->rotation_rate) { |
2611 | error_report_once("rotation_rate is specified for scsi-block but is " |
2612 | "not implemented. This option is deprecated and will " |
2613 | "be removed in a future version" ); |
2614 | } |
2615 | |
2616 | ctx = blk_get_aio_context(s->qdev.conf.blk); |
2617 | aio_context_acquire(ctx); |
2618 | |
2619 | /* check we are using a driver managing SG_IO (version 3 and after) */ |
2620 | rc = blk_ioctl(s->qdev.conf.blk, SG_GET_VERSION_NUM, &sg_version); |
2621 | if (rc < 0) { |
2622 | error_setg_errno(errp, -rc, "cannot get SG_IO version number" ); |
2623 | if (rc != -EPERM) { |
2624 | error_append_hint(errp, "Is this a SCSI device?\n" ); |
2625 | } |
2626 | goto out; |
2627 | } |
2628 | if (sg_version < 30000) { |
2629 | error_setg(errp, "scsi generic interface too old" ); |
2630 | goto out; |
2631 | } |
2632 | |
2633 | /* get device type from INQUIRY data */ |
2634 | rc = get_device_type(s); |
2635 | if (rc < 0) { |
2636 | error_setg(errp, "INQUIRY failed" ); |
2637 | goto out; |
2638 | } |
2639 | |
2640 | /* Make a guess for the block size, we'll fix it when the guest sends. |
2641 | * READ CAPACITY. If they don't, they likely would assume these sizes |
2642 | * anyway. (TODO: check in /sys). |
2643 | */ |
2644 | if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM) { |
2645 | s->qdev.blocksize = 2048; |
2646 | } else { |
2647 | s->qdev.blocksize = 512; |
2648 | } |
2649 | |
2650 | /* Makes the scsi-block device not removable by using HMP and QMP eject |
2651 | * command. |
2652 | */ |
2653 | s->features |= (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS); |
2654 | |
2655 | scsi_realize(&s->qdev, errp); |
2656 | scsi_generic_read_device_inquiry(&s->qdev); |
2657 | |
2658 | out: |
2659 | aio_context_release(ctx); |
2660 | } |
2661 | |
2662 | typedef struct SCSIBlockReq { |
2663 | SCSIDiskReq req; |
2664 | sg_io_hdr_t ; |
2665 | |
2666 | /* Selected bytes of the original CDB, copied into our own CDB. */ |
2667 | uint8_t cmd, cdb1, group_number; |
2668 | |
2669 | /* CDB passed to SG_IO. */ |
2670 | uint8_t cdb[16]; |
2671 | } SCSIBlockReq; |
2672 | |
2673 | static BlockAIOCB *scsi_block_do_sgio(SCSIBlockReq *req, |
2674 | int64_t offset, QEMUIOVector *iov, |
2675 | int direction, |
2676 | BlockCompletionFunc *cb, void *opaque) |
2677 | { |
2678 | sg_io_hdr_t * = &req->io_header; |
2679 | SCSIDiskReq *r = &req->req; |
2680 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
2681 | int nb_logical_blocks; |
2682 | uint64_t lba; |
2683 | BlockAIOCB *aiocb; |
2684 | |
2685 | /* This is not supported yet. It can only happen if the guest does |
2686 | * reads and writes that are not aligned to one logical sectors |
2687 | * _and_ cover multiple MemoryRegions. |
2688 | */ |
2689 | assert(offset % s->qdev.blocksize == 0); |
2690 | assert(iov->size % s->qdev.blocksize == 0); |
2691 | |
2692 | io_header->interface_id = 'S'; |
2693 | |
2694 | /* The data transfer comes from the QEMUIOVector. */ |
2695 | io_header->dxfer_direction = direction; |
2696 | io_header->dxfer_len = iov->size; |
2697 | io_header->dxferp = (void *)iov->iov; |
2698 | io_header->iovec_count = iov->niov; |
2699 | assert(io_header->iovec_count == iov->niov); /* no overflow! */ |
2700 | |
2701 | /* Build a new CDB with the LBA and length patched in, in case |
2702 | * DMA helpers split the transfer in multiple segments. Do not |
2703 | * build a CDB smaller than what the guest wanted, and only build |
2704 | * a larger one if strictly necessary. |
2705 | */ |
2706 | io_header->cmdp = req->cdb; |
2707 | lba = offset / s->qdev.blocksize; |
2708 | nb_logical_blocks = io_header->dxfer_len / s->qdev.blocksize; |
2709 | |
2710 | if ((req->cmd >> 5) == 0 && lba <= 0x1ffff) { |
2711 | /* 6-byte CDB */ |
2712 | stl_be_p(&req->cdb[0], lba | (req->cmd << 24)); |
2713 | req->cdb[4] = nb_logical_blocks; |
2714 | req->cdb[5] = 0; |
2715 | io_header->cmd_len = 6; |
2716 | } else if ((req->cmd >> 5) <= 1 && lba <= 0xffffffffULL) { |
2717 | /* 10-byte CDB */ |
2718 | req->cdb[0] = (req->cmd & 0x1f) | 0x20; |
2719 | req->cdb[1] = req->cdb1; |
2720 | stl_be_p(&req->cdb[2], lba); |
2721 | req->cdb[6] = req->group_number; |
2722 | stw_be_p(&req->cdb[7], nb_logical_blocks); |
2723 | req->cdb[9] = 0; |
2724 | io_header->cmd_len = 10; |
2725 | } else if ((req->cmd >> 5) != 4 && lba <= 0xffffffffULL) { |
2726 | /* 12-byte CDB */ |
2727 | req->cdb[0] = (req->cmd & 0x1f) | 0xA0; |
2728 | req->cdb[1] = req->cdb1; |
2729 | stl_be_p(&req->cdb[2], lba); |
2730 | stl_be_p(&req->cdb[6], nb_logical_blocks); |
2731 | req->cdb[10] = req->group_number; |
2732 | req->cdb[11] = 0; |
2733 | io_header->cmd_len = 12; |
2734 | } else { |
2735 | /* 16-byte CDB */ |
2736 | req->cdb[0] = (req->cmd & 0x1f) | 0x80; |
2737 | req->cdb[1] = req->cdb1; |
2738 | stq_be_p(&req->cdb[2], lba); |
2739 | stl_be_p(&req->cdb[10], nb_logical_blocks); |
2740 | req->cdb[14] = req->group_number; |
2741 | req->cdb[15] = 0; |
2742 | io_header->cmd_len = 16; |
2743 | } |
2744 | |
2745 | /* The rest is as in scsi-generic.c. */ |
2746 | io_header->mx_sb_len = sizeof(r->req.sense); |
2747 | io_header->sbp = r->req.sense; |
2748 | io_header->timeout = UINT_MAX; |
2749 | io_header->usr_ptr = r; |
2750 | io_header->flags |= SG_FLAG_DIRECT_IO; |
2751 | |
2752 | aiocb = blk_aio_ioctl(s->qdev.conf.blk, SG_IO, io_header, cb, opaque); |
2753 | assert(aiocb != NULL); |
2754 | return aiocb; |
2755 | } |
2756 | |
2757 | static bool scsi_block_no_fua(SCSICommand *cmd) |
2758 | { |
2759 | return false; |
2760 | } |
2761 | |
2762 | static BlockAIOCB *scsi_block_dma_readv(int64_t offset, |
2763 | QEMUIOVector *iov, |
2764 | BlockCompletionFunc *cb, void *cb_opaque, |
2765 | void *opaque) |
2766 | { |
2767 | SCSIBlockReq *r = opaque; |
2768 | return scsi_block_do_sgio(r, offset, iov, |
2769 | SG_DXFER_FROM_DEV, cb, cb_opaque); |
2770 | } |
2771 | |
2772 | static BlockAIOCB *scsi_block_dma_writev(int64_t offset, |
2773 | QEMUIOVector *iov, |
2774 | BlockCompletionFunc *cb, void *cb_opaque, |
2775 | void *opaque) |
2776 | { |
2777 | SCSIBlockReq *r = opaque; |
2778 | return scsi_block_do_sgio(r, offset, iov, |
2779 | SG_DXFER_TO_DEV, cb, cb_opaque); |
2780 | } |
2781 | |
2782 | static bool scsi_block_is_passthrough(SCSIDiskState *s, uint8_t *buf) |
2783 | { |
2784 | switch (buf[0]) { |
2785 | case VERIFY_10: |
2786 | case VERIFY_12: |
2787 | case VERIFY_16: |
2788 | /* Check if BYTCHK == 0x01 (data-out buffer contains data |
2789 | * for the number of logical blocks specified in the length |
2790 | * field). For other modes, do not use scatter/gather operation. |
2791 | */ |
2792 | if ((buf[1] & 6) == 2) { |
2793 | return false; |
2794 | } |
2795 | break; |
2796 | |
2797 | case READ_6: |
2798 | case READ_10: |
2799 | case READ_12: |
2800 | case READ_16: |
2801 | case WRITE_6: |
2802 | case WRITE_10: |
2803 | case WRITE_12: |
2804 | case WRITE_16: |
2805 | case WRITE_VERIFY_10: |
2806 | case WRITE_VERIFY_12: |
2807 | case WRITE_VERIFY_16: |
2808 | /* MMC writing cannot be done via DMA helpers, because it sometimes |
2809 | * involves writing beyond the maximum LBA or to negative LBA (lead-in). |
2810 | * We might use scsi_block_dma_reqops as long as no writing commands are |
2811 | * seen, but performance usually isn't paramount on optical media. So, |
2812 | * just make scsi-block operate the same as scsi-generic for them. |
2813 | */ |
2814 | if (s->qdev.type != TYPE_ROM) { |
2815 | return false; |
2816 | } |
2817 | break; |
2818 | |
2819 | default: |
2820 | break; |
2821 | } |
2822 | |
2823 | return true; |
2824 | } |
2825 | |
2826 | |
2827 | static int32_t scsi_block_dma_command(SCSIRequest *req, uint8_t *buf) |
2828 | { |
2829 | SCSIBlockReq *r = (SCSIBlockReq *)req; |
2830 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev); |
2831 | |
2832 | r->cmd = req->cmd.buf[0]; |
2833 | switch (r->cmd >> 5) { |
2834 | case 0: |
2835 | /* 6-byte CDB. */ |
2836 | r->cdb1 = r->group_number = 0; |
2837 | break; |
2838 | case 1: |
2839 | /* 10-byte CDB. */ |
2840 | r->cdb1 = req->cmd.buf[1]; |
2841 | r->group_number = req->cmd.buf[6]; |
2842 | break; |
2843 | case 4: |
2844 | /* 12-byte CDB. */ |
2845 | r->cdb1 = req->cmd.buf[1]; |
2846 | r->group_number = req->cmd.buf[10]; |
2847 | break; |
2848 | case 5: |
2849 | /* 16-byte CDB. */ |
2850 | r->cdb1 = req->cmd.buf[1]; |
2851 | r->group_number = req->cmd.buf[14]; |
2852 | break; |
2853 | default: |
2854 | abort(); |
2855 | } |
2856 | |
2857 | /* Protection information is not supported. For SCSI versions 2 and |
2858 | * older (as determined by snooping the guest's INQUIRY commands), |
2859 | * there is no RD/WR/VRPROTECT, so skip this check in these versions. |
2860 | */ |
2861 | if (s->qdev.scsi_version > 2 && (req->cmd.buf[1] & 0xe0)) { |
2862 | scsi_check_condition(&r->req, SENSE_CODE(INVALID_FIELD)); |
2863 | return 0; |
2864 | } |
2865 | |
2866 | r->req.status = &r->io_header.status; |
2867 | return scsi_disk_dma_command(req, buf); |
2868 | } |
2869 | |
2870 | static const SCSIReqOps scsi_block_dma_reqops = { |
2871 | .size = sizeof(SCSIBlockReq), |
2872 | .free_req = scsi_free_request, |
2873 | .send_command = scsi_block_dma_command, |
2874 | .read_data = scsi_read_data, |
2875 | .write_data = scsi_write_data, |
2876 | .get_buf = scsi_get_buf, |
2877 | .load_request = scsi_disk_load_request, |
2878 | .save_request = scsi_disk_save_request, |
2879 | }; |
2880 | |
2881 | static SCSIRequest *scsi_block_new_request(SCSIDevice *d, uint32_t tag, |
2882 | uint32_t lun, uint8_t *buf, |
2883 | void *hba_private) |
2884 | { |
2885 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d); |
2886 | |
2887 | if (scsi_block_is_passthrough(s, buf)) { |
2888 | return scsi_req_alloc(&scsi_generic_req_ops, &s->qdev, tag, lun, |
2889 | hba_private); |
2890 | } else { |
2891 | return scsi_req_alloc(&scsi_block_dma_reqops, &s->qdev, tag, lun, |
2892 | hba_private); |
2893 | } |
2894 | } |
2895 | |
2896 | static int scsi_block_parse_cdb(SCSIDevice *d, SCSICommand *cmd, |
2897 | uint8_t *buf, void *hba_private) |
2898 | { |
2899 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d); |
2900 | |
2901 | if (scsi_block_is_passthrough(s, buf)) { |
2902 | return scsi_bus_parse_cdb(&s->qdev, cmd, buf, hba_private); |
2903 | } else { |
2904 | return scsi_req_parse_cdb(&s->qdev, cmd, buf); |
2905 | } |
2906 | } |
2907 | |
2908 | static void scsi_block_update_sense(SCSIRequest *req) |
2909 | { |
2910 | SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req); |
2911 | SCSIBlockReq *br = DO_UPCAST(SCSIBlockReq, req, r); |
2912 | r->req.sense_len = MIN(br->io_header.sb_len_wr, sizeof(r->req.sense)); |
2913 | } |
2914 | #endif |
2915 | |
2916 | static |
2917 | BlockAIOCB *scsi_dma_readv(int64_t offset, QEMUIOVector *iov, |
2918 | BlockCompletionFunc *cb, void *cb_opaque, |
2919 | void *opaque) |
2920 | { |
2921 | SCSIDiskReq *r = opaque; |
2922 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
2923 | return blk_aio_preadv(s->qdev.conf.blk, offset, iov, 0, cb, cb_opaque); |
2924 | } |
2925 | |
2926 | static |
2927 | BlockAIOCB *scsi_dma_writev(int64_t offset, QEMUIOVector *iov, |
2928 | BlockCompletionFunc *cb, void *cb_opaque, |
2929 | void *opaque) |
2930 | { |
2931 | SCSIDiskReq *r = opaque; |
2932 | SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); |
2933 | return blk_aio_pwritev(s->qdev.conf.blk, offset, iov, 0, cb, cb_opaque); |
2934 | } |
2935 | |
2936 | static void scsi_disk_base_class_initfn(ObjectClass *klass, void *data) |
2937 | { |
2938 | DeviceClass *dc = DEVICE_CLASS(klass); |
2939 | SCSIDiskClass *sdc = SCSI_DISK_BASE_CLASS(klass); |
2940 | |
2941 | dc->fw_name = "disk" ; |
2942 | dc->reset = scsi_disk_reset; |
2943 | sdc->dma_readv = scsi_dma_readv; |
2944 | sdc->dma_writev = scsi_dma_writev; |
2945 | sdc->need_fua_emulation = scsi_is_cmd_fua; |
2946 | } |
2947 | |
2948 | static const TypeInfo scsi_disk_base_info = { |
2949 | .name = TYPE_SCSI_DISK_BASE, |
2950 | .parent = TYPE_SCSI_DEVICE, |
2951 | .class_init = scsi_disk_base_class_initfn, |
2952 | .instance_size = sizeof(SCSIDiskState), |
2953 | .class_size = sizeof(SCSIDiskClass), |
2954 | .abstract = true, |
2955 | }; |
2956 | |
2957 | #define DEFINE_SCSI_DISK_PROPERTIES() \ |
2958 | DEFINE_PROP_DRIVE_IOTHREAD("drive", SCSIDiskState, qdev.conf.blk), \ |
2959 | DEFINE_BLOCK_PROPERTIES_BASE(SCSIDiskState, qdev.conf), \ |
2960 | DEFINE_BLOCK_ERROR_PROPERTIES(SCSIDiskState, qdev.conf), \ |
2961 | DEFINE_PROP_STRING("ver", SCSIDiskState, version), \ |
2962 | DEFINE_PROP_STRING("serial", SCSIDiskState, serial), \ |
2963 | DEFINE_PROP_STRING("vendor", SCSIDiskState, vendor), \ |
2964 | DEFINE_PROP_STRING("product", SCSIDiskState, product), \ |
2965 | DEFINE_PROP_STRING("device_id", SCSIDiskState, device_id) |
2966 | |
2967 | |
2968 | static Property scsi_hd_properties[] = { |
2969 | DEFINE_SCSI_DISK_PROPERTIES(), |
2970 | DEFINE_PROP_BIT("removable" , SCSIDiskState, features, |
2971 | SCSI_DISK_F_REMOVABLE, false), |
2972 | DEFINE_PROP_BIT("dpofua" , SCSIDiskState, features, |
2973 | SCSI_DISK_F_DPOFUA, false), |
2974 | DEFINE_PROP_UINT64("wwn" , SCSIDiskState, qdev.wwn, 0), |
2975 | DEFINE_PROP_UINT64("port_wwn" , SCSIDiskState, qdev.port_wwn, 0), |
2976 | DEFINE_PROP_UINT16("port_index" , SCSIDiskState, port_index, 0), |
2977 | DEFINE_PROP_UINT64("max_unmap_size" , SCSIDiskState, max_unmap_size, |
2978 | DEFAULT_MAX_UNMAP_SIZE), |
2979 | DEFINE_PROP_UINT64("max_io_size" , SCSIDiskState, max_io_size, |
2980 | DEFAULT_MAX_IO_SIZE), |
2981 | DEFINE_PROP_UINT16("rotation_rate" , SCSIDiskState, rotation_rate, 0), |
2982 | DEFINE_PROP_INT32("scsi_version" , SCSIDiskState, qdev.default_scsi_version, |
2983 | 5), |
2984 | DEFINE_BLOCK_CHS_PROPERTIES(SCSIDiskState, qdev.conf), |
2985 | DEFINE_PROP_END_OF_LIST(), |
2986 | }; |
2987 | |
2988 | static const VMStateDescription vmstate_scsi_disk_state = { |
2989 | .name = "scsi-disk" , |
2990 | .version_id = 1, |
2991 | .minimum_version_id = 1, |
2992 | .fields = (VMStateField[]) { |
2993 | VMSTATE_SCSI_DEVICE(qdev, SCSIDiskState), |
2994 | VMSTATE_BOOL(media_changed, SCSIDiskState), |
2995 | VMSTATE_BOOL(media_event, SCSIDiskState), |
2996 | VMSTATE_BOOL(eject_request, SCSIDiskState), |
2997 | VMSTATE_BOOL(tray_open, SCSIDiskState), |
2998 | VMSTATE_BOOL(tray_locked, SCSIDiskState), |
2999 | VMSTATE_END_OF_LIST() |
3000 | } |
3001 | }; |
3002 | |
3003 | static void scsi_hd_class_initfn(ObjectClass *klass, void *data) |
3004 | { |
3005 | DeviceClass *dc = DEVICE_CLASS(klass); |
3006 | SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass); |
3007 | |
3008 | sc->realize = scsi_hd_realize; |
3009 | sc->alloc_req = scsi_new_request; |
3010 | sc->unit_attention_reported = scsi_disk_unit_attention_reported; |
3011 | dc->desc = "virtual SCSI disk" ; |
3012 | dc->props = scsi_hd_properties; |
3013 | dc->vmsd = &vmstate_scsi_disk_state; |
3014 | } |
3015 | |
3016 | static const TypeInfo scsi_hd_info = { |
3017 | .name = "scsi-hd" , |
3018 | .parent = TYPE_SCSI_DISK_BASE, |
3019 | .class_init = scsi_hd_class_initfn, |
3020 | }; |
3021 | |
3022 | static Property scsi_cd_properties[] = { |
3023 | DEFINE_SCSI_DISK_PROPERTIES(), |
3024 | DEFINE_PROP_UINT64("wwn" , SCSIDiskState, qdev.wwn, 0), |
3025 | DEFINE_PROP_UINT64("port_wwn" , SCSIDiskState, qdev.port_wwn, 0), |
3026 | DEFINE_PROP_UINT16("port_index" , SCSIDiskState, port_index, 0), |
3027 | DEFINE_PROP_UINT64("max_io_size" , SCSIDiskState, max_io_size, |
3028 | DEFAULT_MAX_IO_SIZE), |
3029 | DEFINE_PROP_INT32("scsi_version" , SCSIDiskState, qdev.default_scsi_version, |
3030 | 5), |
3031 | DEFINE_PROP_END_OF_LIST(), |
3032 | }; |
3033 | |
3034 | static void scsi_cd_class_initfn(ObjectClass *klass, void *data) |
3035 | { |
3036 | DeviceClass *dc = DEVICE_CLASS(klass); |
3037 | SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass); |
3038 | |
3039 | sc->realize = scsi_cd_realize; |
3040 | sc->alloc_req = scsi_new_request; |
3041 | sc->unit_attention_reported = scsi_disk_unit_attention_reported; |
3042 | dc->desc = "virtual SCSI CD-ROM" ; |
3043 | dc->props = scsi_cd_properties; |
3044 | dc->vmsd = &vmstate_scsi_disk_state; |
3045 | } |
3046 | |
3047 | static const TypeInfo scsi_cd_info = { |
3048 | .name = "scsi-cd" , |
3049 | .parent = TYPE_SCSI_DISK_BASE, |
3050 | .class_init = scsi_cd_class_initfn, |
3051 | }; |
3052 | |
3053 | #ifdef __linux__ |
3054 | static Property scsi_block_properties[] = { |
3055 | DEFINE_BLOCK_ERROR_PROPERTIES(SCSIDiskState, qdev.conf), \ |
3056 | DEFINE_PROP_DRIVE("drive" , SCSIDiskState, qdev.conf.blk), |
3057 | DEFINE_PROP_BOOL("share-rw" , SCSIDiskState, qdev.conf.share_rw, false), |
3058 | DEFINE_PROP_UINT16("rotation_rate" , SCSIDiskState, rotation_rate, 0), |
3059 | DEFINE_PROP_UINT64("max_unmap_size" , SCSIDiskState, max_unmap_size, |
3060 | DEFAULT_MAX_UNMAP_SIZE), |
3061 | DEFINE_PROP_UINT64("max_io_size" , SCSIDiskState, max_io_size, |
3062 | DEFAULT_MAX_IO_SIZE), |
3063 | DEFINE_PROP_INT32("scsi_version" , SCSIDiskState, qdev.default_scsi_version, |
3064 | -1), |
3065 | DEFINE_PROP_END_OF_LIST(), |
3066 | }; |
3067 | |
3068 | static void scsi_block_class_initfn(ObjectClass *klass, void *data) |
3069 | { |
3070 | DeviceClass *dc = DEVICE_CLASS(klass); |
3071 | SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass); |
3072 | SCSIDiskClass *sdc = SCSI_DISK_BASE_CLASS(klass); |
3073 | |
3074 | sc->realize = scsi_block_realize; |
3075 | sc->alloc_req = scsi_block_new_request; |
3076 | sc->parse_cdb = scsi_block_parse_cdb; |
3077 | sdc->dma_readv = scsi_block_dma_readv; |
3078 | sdc->dma_writev = scsi_block_dma_writev; |
3079 | sdc->update_sense = scsi_block_update_sense; |
3080 | sdc->need_fua_emulation = scsi_block_no_fua; |
3081 | dc->desc = "SCSI block device passthrough" ; |
3082 | dc->props = scsi_block_properties; |
3083 | dc->vmsd = &vmstate_scsi_disk_state; |
3084 | } |
3085 | |
3086 | static const TypeInfo scsi_block_info = { |
3087 | .name = "scsi-block" , |
3088 | .parent = TYPE_SCSI_DISK_BASE, |
3089 | .class_init = scsi_block_class_initfn, |
3090 | }; |
3091 | #endif |
3092 | |
3093 | static Property scsi_disk_properties[] = { |
3094 | DEFINE_SCSI_DISK_PROPERTIES(), |
3095 | DEFINE_PROP_BIT("removable" , SCSIDiskState, features, |
3096 | SCSI_DISK_F_REMOVABLE, false), |
3097 | DEFINE_PROP_BIT("dpofua" , SCSIDiskState, features, |
3098 | SCSI_DISK_F_DPOFUA, false), |
3099 | DEFINE_PROP_UINT64("wwn" , SCSIDiskState, qdev.wwn, 0), |
3100 | DEFINE_PROP_UINT64("port_wwn" , SCSIDiskState, qdev.port_wwn, 0), |
3101 | DEFINE_PROP_UINT16("port_index" , SCSIDiskState, port_index, 0), |
3102 | DEFINE_PROP_UINT64("max_unmap_size" , SCSIDiskState, max_unmap_size, |
3103 | DEFAULT_MAX_UNMAP_SIZE), |
3104 | DEFINE_PROP_UINT64("max_io_size" , SCSIDiskState, max_io_size, |
3105 | DEFAULT_MAX_IO_SIZE), |
3106 | DEFINE_PROP_INT32("scsi_version" , SCSIDiskState, qdev.default_scsi_version, |
3107 | 5), |
3108 | DEFINE_PROP_END_OF_LIST(), |
3109 | }; |
3110 | |
3111 | static void scsi_disk_class_initfn(ObjectClass *klass, void *data) |
3112 | { |
3113 | DeviceClass *dc = DEVICE_CLASS(klass); |
3114 | SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass); |
3115 | |
3116 | sc->realize = scsi_disk_realize; |
3117 | sc->alloc_req = scsi_new_request; |
3118 | sc->unit_attention_reported = scsi_disk_unit_attention_reported; |
3119 | dc->fw_name = "disk" ; |
3120 | dc->desc = "virtual SCSI disk or CD-ROM (legacy)" ; |
3121 | dc->reset = scsi_disk_reset; |
3122 | dc->props = scsi_disk_properties; |
3123 | dc->vmsd = &vmstate_scsi_disk_state; |
3124 | } |
3125 | |
3126 | static const TypeInfo scsi_disk_info = { |
3127 | .name = "scsi-disk" , |
3128 | .parent = TYPE_SCSI_DISK_BASE, |
3129 | .class_init = scsi_disk_class_initfn, |
3130 | }; |
3131 | |
3132 | static void scsi_disk_register_types(void) |
3133 | { |
3134 | type_register_static(&scsi_disk_base_info); |
3135 | type_register_static(&scsi_hd_info); |
3136 | type_register_static(&scsi_cd_info); |
3137 | #ifdef __linux__ |
3138 | type_register_static(&scsi_block_info); |
3139 | #endif |
3140 | type_register_static(&scsi_disk_info); |
3141 | } |
3142 | |
3143 | type_init(scsi_disk_register_types) |
3144 | |