1 | /* |
2 | * Virtio Block Device |
3 | * |
4 | * Copyright IBM, Corp. 2007 |
5 | * |
6 | * Authors: |
7 | * Anthony Liguori <aliguori@us.ibm.com> |
8 | * |
9 | * This work is licensed under the terms of the GNU GPL, version 2. See |
10 | * the COPYING file in the top-level directory. |
11 | * |
12 | */ |
13 | |
14 | #include "qemu/osdep.h" |
15 | #include "qapi/error.h" |
16 | #include "qemu/iov.h" |
17 | #include "qemu/module.h" |
18 | #include "qemu/error-report.h" |
19 | #include "trace.h" |
20 | #include "hw/block/block.h" |
21 | #include "hw/qdev-properties.h" |
22 | #include "sysemu/blockdev.h" |
23 | #include "sysemu/sysemu.h" |
24 | #include "sysemu/runstate.h" |
25 | #include "hw/virtio/virtio-blk.h" |
26 | #include "dataplane/virtio-blk.h" |
27 | #include "scsi/constants.h" |
28 | #ifdef __linux__ |
29 | # include <scsi/sg.h> |
30 | #endif |
31 | #include "hw/virtio/virtio-bus.h" |
32 | #include "migration/qemu-file-types.h" |
33 | #include "hw/virtio/virtio-access.h" |
34 | |
35 | /* Config size before the discard support (hide associated config fields) */ |
36 | #define VIRTIO_BLK_CFG_SIZE offsetof(struct virtio_blk_config, \ |
37 | max_discard_sectors) |
38 | /* |
39 | * Starting from the discard feature, we can use this array to properly |
40 | * set the config size depending on the features enabled. |
41 | */ |
42 | static VirtIOFeature feature_sizes[] = { |
43 | {.flags = 1ULL << VIRTIO_BLK_F_DISCARD, |
44 | .end = virtio_endof(struct virtio_blk_config, discard_sector_alignment)}, |
45 | {.flags = 1ULL << VIRTIO_BLK_F_WRITE_ZEROES, |
46 | .end = virtio_endof(struct virtio_blk_config, write_zeroes_may_unmap)}, |
47 | {} |
48 | }; |
49 | |
50 | static void virtio_blk_set_config_size(VirtIOBlock *s, uint64_t host_features) |
51 | { |
52 | s->config_size = MAX(VIRTIO_BLK_CFG_SIZE, |
53 | virtio_feature_get_config_size(feature_sizes, host_features)); |
54 | |
55 | assert(s->config_size <= sizeof(struct virtio_blk_config)); |
56 | } |
57 | |
58 | static void virtio_blk_init_request(VirtIOBlock *s, VirtQueue *vq, |
59 | VirtIOBlockReq *req) |
60 | { |
61 | req->dev = s; |
62 | req->vq = vq; |
63 | req->qiov.size = 0; |
64 | req->in_len = 0; |
65 | req->next = NULL; |
66 | req->mr_next = NULL; |
67 | } |
68 | |
69 | static void virtio_blk_free_request(VirtIOBlockReq *req) |
70 | { |
71 | g_free(req); |
72 | } |
73 | |
74 | static void virtio_blk_req_complete(VirtIOBlockReq *req, unsigned char status) |
75 | { |
76 | VirtIOBlock *s = req->dev; |
77 | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
78 | |
79 | trace_virtio_blk_req_complete(vdev, req, status); |
80 | |
81 | stb_p(&req->in->status, status); |
82 | virtqueue_push(req->vq, &req->elem, req->in_len); |
83 | if (s->dataplane_started && !s->dataplane_disabled) { |
84 | virtio_blk_data_plane_notify(s->dataplane, req->vq); |
85 | } else { |
86 | virtio_notify(vdev, req->vq); |
87 | } |
88 | } |
89 | |
90 | static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error, |
91 | bool is_read, bool acct_failed) |
92 | { |
93 | VirtIOBlock *s = req->dev; |
94 | BlockErrorAction action = blk_get_error_action(s->blk, is_read, error); |
95 | |
96 | if (action == BLOCK_ERROR_ACTION_STOP) { |
97 | /* Break the link as the next request is going to be parsed from the |
98 | * ring again. Otherwise we may end up doing a double completion! */ |
99 | req->mr_next = NULL; |
100 | req->next = s->rq; |
101 | s->rq = req; |
102 | } else if (action == BLOCK_ERROR_ACTION_REPORT) { |
103 | virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR); |
104 | if (acct_failed) { |
105 | block_acct_failed(blk_get_stats(s->blk), &req->acct); |
106 | } |
107 | virtio_blk_free_request(req); |
108 | } |
109 | |
110 | blk_error_action(s->blk, action, is_read, error); |
111 | return action != BLOCK_ERROR_ACTION_IGNORE; |
112 | } |
113 | |
114 | static void virtio_blk_rw_complete(void *opaque, int ret) |
115 | { |
116 | VirtIOBlockReq *next = opaque; |
117 | VirtIOBlock *s = next->dev; |
118 | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
119 | |
120 | aio_context_acquire(blk_get_aio_context(s->conf.conf.blk)); |
121 | while (next) { |
122 | VirtIOBlockReq *req = next; |
123 | next = req->mr_next; |
124 | trace_virtio_blk_rw_complete(vdev, req, ret); |
125 | |
126 | if (req->qiov.nalloc != -1) { |
127 | /* If nalloc is != -1 req->qiov is a local copy of the original |
128 | * external iovec. It was allocated in submit_requests to be |
129 | * able to merge requests. */ |
130 | qemu_iovec_destroy(&req->qiov); |
131 | } |
132 | |
133 | if (ret) { |
134 | int p = virtio_ldl_p(VIRTIO_DEVICE(s), &req->out.type); |
135 | bool is_read = !(p & VIRTIO_BLK_T_OUT); |
136 | /* Note that memory may be dirtied on read failure. If the |
137 | * virtio request is not completed here, as is the case for |
138 | * BLOCK_ERROR_ACTION_STOP, the memory may not be copied |
139 | * correctly during live migration. While this is ugly, |
140 | * it is acceptable because the device is free to write to |
141 | * the memory until the request is completed (which will |
142 | * happen on the other side of the migration). |
143 | */ |
144 | if (virtio_blk_handle_rw_error(req, -ret, is_read, true)) { |
145 | continue; |
146 | } |
147 | } |
148 | |
149 | virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); |
150 | block_acct_done(blk_get_stats(s->blk), &req->acct); |
151 | virtio_blk_free_request(req); |
152 | } |
153 | aio_context_release(blk_get_aio_context(s->conf.conf.blk)); |
154 | } |
155 | |
156 | static void virtio_blk_flush_complete(void *opaque, int ret) |
157 | { |
158 | VirtIOBlockReq *req = opaque; |
159 | VirtIOBlock *s = req->dev; |
160 | |
161 | aio_context_acquire(blk_get_aio_context(s->conf.conf.blk)); |
162 | if (ret) { |
163 | if (virtio_blk_handle_rw_error(req, -ret, 0, true)) { |
164 | goto out; |
165 | } |
166 | } |
167 | |
168 | virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); |
169 | block_acct_done(blk_get_stats(s->blk), &req->acct); |
170 | virtio_blk_free_request(req); |
171 | |
172 | out: |
173 | aio_context_release(blk_get_aio_context(s->conf.conf.blk)); |
174 | } |
175 | |
176 | static void virtio_blk_discard_write_zeroes_complete(void *opaque, int ret) |
177 | { |
178 | VirtIOBlockReq *req = opaque; |
179 | VirtIOBlock *s = req->dev; |
180 | bool is_write_zeroes = (virtio_ldl_p(VIRTIO_DEVICE(s), &req->out.type) & |
181 | ~VIRTIO_BLK_T_BARRIER) == VIRTIO_BLK_T_WRITE_ZEROES; |
182 | |
183 | aio_context_acquire(blk_get_aio_context(s->conf.conf.blk)); |
184 | if (ret) { |
185 | if (virtio_blk_handle_rw_error(req, -ret, false, is_write_zeroes)) { |
186 | goto out; |
187 | } |
188 | } |
189 | |
190 | virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); |
191 | if (is_write_zeroes) { |
192 | block_acct_done(blk_get_stats(s->blk), &req->acct); |
193 | } |
194 | virtio_blk_free_request(req); |
195 | |
196 | out: |
197 | aio_context_release(blk_get_aio_context(s->conf.conf.blk)); |
198 | } |
199 | |
200 | #ifdef __linux__ |
201 | |
202 | typedef struct { |
203 | VirtIOBlockReq *req; |
204 | struct sg_io_hdr hdr; |
205 | } VirtIOBlockIoctlReq; |
206 | |
207 | static void virtio_blk_ioctl_complete(void *opaque, int status) |
208 | { |
209 | VirtIOBlockIoctlReq *ioctl_req = opaque; |
210 | VirtIOBlockReq *req = ioctl_req->req; |
211 | VirtIOBlock *s = req->dev; |
212 | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
213 | struct virtio_scsi_inhdr *scsi; |
214 | struct sg_io_hdr *hdr; |
215 | |
216 | scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base; |
217 | |
218 | if (status) { |
219 | status = VIRTIO_BLK_S_UNSUPP; |
220 | virtio_stl_p(vdev, &scsi->errors, 255); |
221 | goto out; |
222 | } |
223 | |
224 | hdr = &ioctl_req->hdr; |
225 | /* |
226 | * From SCSI-Generic-HOWTO: "Some lower level drivers (e.g. ide-scsi) |
227 | * clear the masked_status field [hence status gets cleared too, see |
228 | * block/scsi_ioctl.c] even when a CHECK_CONDITION or COMMAND_TERMINATED |
229 | * status has occurred. However they do set DRIVER_SENSE in driver_status |
230 | * field. Also a (sb_len_wr > 0) indicates there is a sense buffer. |
231 | */ |
232 | if (hdr->status == 0 && hdr->sb_len_wr > 0) { |
233 | hdr->status = CHECK_CONDITION; |
234 | } |
235 | |
236 | virtio_stl_p(vdev, &scsi->errors, |
237 | hdr->status | (hdr->msg_status << 8) | |
238 | (hdr->host_status << 16) | (hdr->driver_status << 24)); |
239 | virtio_stl_p(vdev, &scsi->residual, hdr->resid); |
240 | virtio_stl_p(vdev, &scsi->sense_len, hdr->sb_len_wr); |
241 | virtio_stl_p(vdev, &scsi->data_len, hdr->dxfer_len); |
242 | |
243 | out: |
244 | aio_context_acquire(blk_get_aio_context(s->conf.conf.blk)); |
245 | virtio_blk_req_complete(req, status); |
246 | virtio_blk_free_request(req); |
247 | aio_context_release(blk_get_aio_context(s->conf.conf.blk)); |
248 | g_free(ioctl_req); |
249 | } |
250 | |
251 | #endif |
252 | |
253 | static VirtIOBlockReq *virtio_blk_get_request(VirtIOBlock *s, VirtQueue *vq) |
254 | { |
255 | VirtIOBlockReq *req = virtqueue_pop(vq, sizeof(VirtIOBlockReq)); |
256 | |
257 | if (req) { |
258 | virtio_blk_init_request(s, vq, req); |
259 | } |
260 | return req; |
261 | } |
262 | |
263 | static int virtio_blk_handle_scsi_req(VirtIOBlockReq *req) |
264 | { |
265 | int status = VIRTIO_BLK_S_OK; |
266 | struct virtio_scsi_inhdr *scsi = NULL; |
267 | VirtIOBlock *blk = req->dev; |
268 | VirtIODevice *vdev = VIRTIO_DEVICE(blk); |
269 | VirtQueueElement *elem = &req->elem; |
270 | |
271 | #ifdef __linux__ |
272 | int i; |
273 | VirtIOBlockIoctlReq *ioctl_req; |
274 | BlockAIOCB *acb; |
275 | #endif |
276 | |
277 | /* |
278 | * We require at least one output segment each for the virtio_blk_outhdr |
279 | * and the SCSI command block. |
280 | * |
281 | * We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr |
282 | * and the sense buffer pointer in the input segments. |
283 | */ |
284 | if (elem->out_num < 2 || elem->in_num < 3) { |
285 | status = VIRTIO_BLK_S_IOERR; |
286 | goto fail; |
287 | } |
288 | |
289 | /* |
290 | * The scsi inhdr is placed in the second-to-last input segment, just |
291 | * before the regular inhdr. |
292 | */ |
293 | scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base; |
294 | |
295 | if (!virtio_has_feature(blk->host_features, VIRTIO_BLK_F_SCSI)) { |
296 | status = VIRTIO_BLK_S_UNSUPP; |
297 | goto fail; |
298 | } |
299 | |
300 | /* |
301 | * No support for bidirection commands yet. |
302 | */ |
303 | if (elem->out_num > 2 && elem->in_num > 3) { |
304 | status = VIRTIO_BLK_S_UNSUPP; |
305 | goto fail; |
306 | } |
307 | |
308 | #ifdef __linux__ |
309 | ioctl_req = g_new0(VirtIOBlockIoctlReq, 1); |
310 | ioctl_req->req = req; |
311 | ioctl_req->hdr.interface_id = 'S'; |
312 | ioctl_req->hdr.cmd_len = elem->out_sg[1].iov_len; |
313 | ioctl_req->hdr.cmdp = elem->out_sg[1].iov_base; |
314 | ioctl_req->hdr.dxfer_len = 0; |
315 | |
316 | if (elem->out_num > 2) { |
317 | /* |
318 | * If there are more than the minimally required 2 output segments |
319 | * there is write payload starting from the third iovec. |
320 | */ |
321 | ioctl_req->hdr.dxfer_direction = SG_DXFER_TO_DEV; |
322 | ioctl_req->hdr.iovec_count = elem->out_num - 2; |
323 | |
324 | for (i = 0; i < ioctl_req->hdr.iovec_count; i++) { |
325 | ioctl_req->hdr.dxfer_len += elem->out_sg[i + 2].iov_len; |
326 | } |
327 | |
328 | ioctl_req->hdr.dxferp = elem->out_sg + 2; |
329 | |
330 | } else if (elem->in_num > 3) { |
331 | /* |
332 | * If we have more than 3 input segments the guest wants to actually |
333 | * read data. |
334 | */ |
335 | ioctl_req->hdr.dxfer_direction = SG_DXFER_FROM_DEV; |
336 | ioctl_req->hdr.iovec_count = elem->in_num - 3; |
337 | for (i = 0; i < ioctl_req->hdr.iovec_count; i++) { |
338 | ioctl_req->hdr.dxfer_len += elem->in_sg[i].iov_len; |
339 | } |
340 | |
341 | ioctl_req->hdr.dxferp = elem->in_sg; |
342 | } else { |
343 | /* |
344 | * Some SCSI commands don't actually transfer any data. |
345 | */ |
346 | ioctl_req->hdr.dxfer_direction = SG_DXFER_NONE; |
347 | } |
348 | |
349 | ioctl_req->hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base; |
350 | ioctl_req->hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len; |
351 | |
352 | acb = blk_aio_ioctl(blk->blk, SG_IO, &ioctl_req->hdr, |
353 | virtio_blk_ioctl_complete, ioctl_req); |
354 | if (!acb) { |
355 | g_free(ioctl_req); |
356 | status = VIRTIO_BLK_S_UNSUPP; |
357 | goto fail; |
358 | } |
359 | return -EINPROGRESS; |
360 | #else |
361 | abort(); |
362 | #endif |
363 | |
364 | fail: |
365 | /* Just put anything nonzero so that the ioctl fails in the guest. */ |
366 | if (scsi) { |
367 | virtio_stl_p(vdev, &scsi->errors, 255); |
368 | } |
369 | return status; |
370 | } |
371 | |
372 | static void virtio_blk_handle_scsi(VirtIOBlockReq *req) |
373 | { |
374 | int status; |
375 | |
376 | status = virtio_blk_handle_scsi_req(req); |
377 | if (status != -EINPROGRESS) { |
378 | virtio_blk_req_complete(req, status); |
379 | virtio_blk_free_request(req); |
380 | } |
381 | } |
382 | |
383 | static inline void submit_requests(BlockBackend *blk, MultiReqBuffer *mrb, |
384 | int start, int num_reqs, int niov) |
385 | { |
386 | QEMUIOVector *qiov = &mrb->reqs[start]->qiov; |
387 | int64_t sector_num = mrb->reqs[start]->sector_num; |
388 | bool is_write = mrb->is_write; |
389 | |
390 | if (num_reqs > 1) { |
391 | int i; |
392 | struct iovec *tmp_iov = qiov->iov; |
393 | int tmp_niov = qiov->niov; |
394 | |
395 | /* mrb->reqs[start]->qiov was initialized from external so we can't |
396 | * modify it here. We need to initialize it locally and then add the |
397 | * external iovecs. */ |
398 | qemu_iovec_init(qiov, niov); |
399 | |
400 | for (i = 0; i < tmp_niov; i++) { |
401 | qemu_iovec_add(qiov, tmp_iov[i].iov_base, tmp_iov[i].iov_len); |
402 | } |
403 | |
404 | for (i = start + 1; i < start + num_reqs; i++) { |
405 | qemu_iovec_concat(qiov, &mrb->reqs[i]->qiov, 0, |
406 | mrb->reqs[i]->qiov.size); |
407 | mrb->reqs[i - 1]->mr_next = mrb->reqs[i]; |
408 | } |
409 | |
410 | trace_virtio_blk_submit_multireq(VIRTIO_DEVICE(mrb->reqs[start]->dev), |
411 | mrb, start, num_reqs, |
412 | sector_num << BDRV_SECTOR_BITS, |
413 | qiov->size, is_write); |
414 | block_acct_merge_done(blk_get_stats(blk), |
415 | is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ, |
416 | num_reqs - 1); |
417 | } |
418 | |
419 | if (is_write) { |
420 | blk_aio_pwritev(blk, sector_num << BDRV_SECTOR_BITS, qiov, 0, |
421 | virtio_blk_rw_complete, mrb->reqs[start]); |
422 | } else { |
423 | blk_aio_preadv(blk, sector_num << BDRV_SECTOR_BITS, qiov, 0, |
424 | virtio_blk_rw_complete, mrb->reqs[start]); |
425 | } |
426 | } |
427 | |
428 | static int multireq_compare(const void *a, const void *b) |
429 | { |
430 | const VirtIOBlockReq *req1 = *(VirtIOBlockReq **)a, |
431 | *req2 = *(VirtIOBlockReq **)b; |
432 | |
433 | /* |
434 | * Note that we can't simply subtract sector_num1 from sector_num2 |
435 | * here as that could overflow the return value. |
436 | */ |
437 | if (req1->sector_num > req2->sector_num) { |
438 | return 1; |
439 | } else if (req1->sector_num < req2->sector_num) { |
440 | return -1; |
441 | } else { |
442 | return 0; |
443 | } |
444 | } |
445 | |
446 | static void virtio_blk_submit_multireq(BlockBackend *blk, MultiReqBuffer *mrb) |
447 | { |
448 | int i = 0, start = 0, num_reqs = 0, niov = 0, nb_sectors = 0; |
449 | uint32_t max_transfer; |
450 | int64_t sector_num = 0; |
451 | |
452 | if (mrb->num_reqs == 1) { |
453 | submit_requests(blk, mrb, 0, 1, -1); |
454 | mrb->num_reqs = 0; |
455 | return; |
456 | } |
457 | |
458 | max_transfer = blk_get_max_transfer(mrb->reqs[0]->dev->blk); |
459 | |
460 | qsort(mrb->reqs, mrb->num_reqs, sizeof(*mrb->reqs), |
461 | &multireq_compare); |
462 | |
463 | for (i = 0; i < mrb->num_reqs; i++) { |
464 | VirtIOBlockReq *req = mrb->reqs[i]; |
465 | if (num_reqs > 0) { |
466 | /* |
467 | * NOTE: We cannot merge the requests in below situations: |
468 | * 1. requests are not sequential |
469 | * 2. merge would exceed maximum number of IOVs |
470 | * 3. merge would exceed maximum transfer length of backend device |
471 | */ |
472 | if (sector_num + nb_sectors != req->sector_num || |
473 | niov > blk_get_max_iov(blk) - req->qiov.niov || |
474 | req->qiov.size > max_transfer || |
475 | nb_sectors > (max_transfer - |
476 | req->qiov.size) / BDRV_SECTOR_SIZE) { |
477 | submit_requests(blk, mrb, start, num_reqs, niov); |
478 | num_reqs = 0; |
479 | } |
480 | } |
481 | |
482 | if (num_reqs == 0) { |
483 | sector_num = req->sector_num; |
484 | nb_sectors = niov = 0; |
485 | start = i; |
486 | } |
487 | |
488 | nb_sectors += req->qiov.size / BDRV_SECTOR_SIZE; |
489 | niov += req->qiov.niov; |
490 | num_reqs++; |
491 | } |
492 | |
493 | submit_requests(blk, mrb, start, num_reqs, niov); |
494 | mrb->num_reqs = 0; |
495 | } |
496 | |
497 | static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb) |
498 | { |
499 | VirtIOBlock *s = req->dev; |
500 | |
501 | block_acct_start(blk_get_stats(s->blk), &req->acct, 0, |
502 | BLOCK_ACCT_FLUSH); |
503 | |
504 | /* |
505 | * Make sure all outstanding writes are posted to the backing device. |
506 | */ |
507 | if (mrb->is_write && mrb->num_reqs > 0) { |
508 | virtio_blk_submit_multireq(s->blk, mrb); |
509 | } |
510 | blk_aio_flush(s->blk, virtio_blk_flush_complete, req); |
511 | } |
512 | |
513 | static bool virtio_blk_sect_range_ok(VirtIOBlock *dev, |
514 | uint64_t sector, size_t size) |
515 | { |
516 | uint64_t nb_sectors = size >> BDRV_SECTOR_BITS; |
517 | uint64_t total_sectors; |
518 | |
519 | if (nb_sectors > BDRV_REQUEST_MAX_SECTORS) { |
520 | return false; |
521 | } |
522 | if (sector & dev->sector_mask) { |
523 | return false; |
524 | } |
525 | if (size % dev->conf.conf.logical_block_size) { |
526 | return false; |
527 | } |
528 | blk_get_geometry(dev->blk, &total_sectors); |
529 | if (sector > total_sectors || nb_sectors > total_sectors - sector) { |
530 | return false; |
531 | } |
532 | return true; |
533 | } |
534 | |
535 | static uint8_t virtio_blk_handle_discard_write_zeroes(VirtIOBlockReq *req, |
536 | struct virtio_blk_discard_write_zeroes *dwz_hdr, bool is_write_zeroes) |
537 | { |
538 | VirtIOBlock *s = req->dev; |
539 | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
540 | uint64_t sector; |
541 | uint32_t num_sectors, flags, max_sectors; |
542 | uint8_t err_status; |
543 | int bytes; |
544 | |
545 | sector = virtio_ldq_p(vdev, &dwz_hdr->sector); |
546 | num_sectors = virtio_ldl_p(vdev, &dwz_hdr->num_sectors); |
547 | flags = virtio_ldl_p(vdev, &dwz_hdr->flags); |
548 | max_sectors = is_write_zeroes ? s->conf.max_write_zeroes_sectors : |
549 | s->conf.max_discard_sectors; |
550 | |
551 | /* |
552 | * max_sectors is at most BDRV_REQUEST_MAX_SECTORS, this check |
553 | * make us sure that "num_sectors << BDRV_SECTOR_BITS" can fit in |
554 | * the integer variable. |
555 | */ |
556 | if (unlikely(num_sectors > max_sectors)) { |
557 | err_status = VIRTIO_BLK_S_IOERR; |
558 | goto err; |
559 | } |
560 | |
561 | bytes = num_sectors << BDRV_SECTOR_BITS; |
562 | |
563 | if (unlikely(!virtio_blk_sect_range_ok(s, sector, bytes))) { |
564 | err_status = VIRTIO_BLK_S_IOERR; |
565 | goto err; |
566 | } |
567 | |
568 | /* |
569 | * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for discard |
570 | * and write zeroes commands if any unknown flag is set. |
571 | */ |
572 | if (unlikely(flags & ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) { |
573 | err_status = VIRTIO_BLK_S_UNSUPP; |
574 | goto err; |
575 | } |
576 | |
577 | if (is_write_zeroes) { /* VIRTIO_BLK_T_WRITE_ZEROES */ |
578 | int blk_aio_flags = 0; |
579 | |
580 | if (flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP) { |
581 | blk_aio_flags |= BDRV_REQ_MAY_UNMAP; |
582 | } |
583 | |
584 | block_acct_start(blk_get_stats(s->blk), &req->acct, bytes, |
585 | BLOCK_ACCT_WRITE); |
586 | |
587 | blk_aio_pwrite_zeroes(s->blk, sector << BDRV_SECTOR_BITS, |
588 | bytes, blk_aio_flags, |
589 | virtio_blk_discard_write_zeroes_complete, req); |
590 | } else { /* VIRTIO_BLK_T_DISCARD */ |
591 | /* |
592 | * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for |
593 | * discard commands if the unmap flag is set. |
594 | */ |
595 | if (unlikely(flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) { |
596 | err_status = VIRTIO_BLK_S_UNSUPP; |
597 | goto err; |
598 | } |
599 | |
600 | blk_aio_pdiscard(s->blk, sector << BDRV_SECTOR_BITS, bytes, |
601 | virtio_blk_discard_write_zeroes_complete, req); |
602 | } |
603 | |
604 | return VIRTIO_BLK_S_OK; |
605 | |
606 | err: |
607 | if (is_write_zeroes) { |
608 | block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_WRITE); |
609 | } |
610 | return err_status; |
611 | } |
612 | |
613 | static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb) |
614 | { |
615 | uint32_t type; |
616 | struct iovec *in_iov = req->elem.in_sg; |
617 | struct iovec *out_iov = req->elem.out_sg; |
618 | unsigned in_num = req->elem.in_num; |
619 | unsigned out_num = req->elem.out_num; |
620 | VirtIOBlock *s = req->dev; |
621 | VirtIODevice *vdev = VIRTIO_DEVICE(s); |
622 | |
623 | if (req->elem.out_num < 1 || req->elem.in_num < 1) { |
624 | virtio_error(vdev, "virtio-blk missing headers" ); |
625 | return -1; |
626 | } |
627 | |
628 | if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out, |
629 | sizeof(req->out)) != sizeof(req->out))) { |
630 | virtio_error(vdev, "virtio-blk request outhdr too short" ); |
631 | return -1; |
632 | } |
633 | |
634 | iov_discard_front(&out_iov, &out_num, sizeof(req->out)); |
635 | |
636 | if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) { |
637 | virtio_error(vdev, "virtio-blk request inhdr too short" ); |
638 | return -1; |
639 | } |
640 | |
641 | /* We always touch the last byte, so just see how big in_iov is. */ |
642 | req->in_len = iov_size(in_iov, in_num); |
643 | req->in = (void *)in_iov[in_num - 1].iov_base |
644 | + in_iov[in_num - 1].iov_len |
645 | - sizeof(struct virtio_blk_inhdr); |
646 | iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr)); |
647 | |
648 | type = virtio_ldl_p(vdev, &req->out.type); |
649 | |
650 | /* VIRTIO_BLK_T_OUT defines the command direction. VIRTIO_BLK_T_BARRIER |
651 | * is an optional flag. Although a guest should not send this flag if |
652 | * not negotiated we ignored it in the past. So keep ignoring it. */ |
653 | switch (type & ~(VIRTIO_BLK_T_OUT | VIRTIO_BLK_T_BARRIER)) { |
654 | case VIRTIO_BLK_T_IN: |
655 | { |
656 | bool is_write = type & VIRTIO_BLK_T_OUT; |
657 | req->sector_num = virtio_ldq_p(vdev, &req->out.sector); |
658 | |
659 | if (is_write) { |
660 | qemu_iovec_init_external(&req->qiov, out_iov, out_num); |
661 | trace_virtio_blk_handle_write(vdev, req, req->sector_num, |
662 | req->qiov.size / BDRV_SECTOR_SIZE); |
663 | } else { |
664 | qemu_iovec_init_external(&req->qiov, in_iov, in_num); |
665 | trace_virtio_blk_handle_read(vdev, req, req->sector_num, |
666 | req->qiov.size / BDRV_SECTOR_SIZE); |
667 | } |
668 | |
669 | if (!virtio_blk_sect_range_ok(s, req->sector_num, req->qiov.size)) { |
670 | virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR); |
671 | block_acct_invalid(blk_get_stats(s->blk), |
672 | is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ); |
673 | virtio_blk_free_request(req); |
674 | return 0; |
675 | } |
676 | |
677 | block_acct_start(blk_get_stats(s->blk), &req->acct, req->qiov.size, |
678 | is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ); |
679 | |
680 | /* merge would exceed maximum number of requests or IO direction |
681 | * changes */ |
682 | if (mrb->num_reqs > 0 && (mrb->num_reqs == VIRTIO_BLK_MAX_MERGE_REQS || |
683 | is_write != mrb->is_write || |
684 | !s->conf.request_merging)) { |
685 | virtio_blk_submit_multireq(s->blk, mrb); |
686 | } |
687 | |
688 | assert(mrb->num_reqs < VIRTIO_BLK_MAX_MERGE_REQS); |
689 | mrb->reqs[mrb->num_reqs++] = req; |
690 | mrb->is_write = is_write; |
691 | break; |
692 | } |
693 | case VIRTIO_BLK_T_FLUSH: |
694 | virtio_blk_handle_flush(req, mrb); |
695 | break; |
696 | case VIRTIO_BLK_T_SCSI_CMD: |
697 | virtio_blk_handle_scsi(req); |
698 | break; |
699 | case VIRTIO_BLK_T_GET_ID: |
700 | { |
701 | /* |
702 | * NB: per existing s/n string convention the string is |
703 | * terminated by '\0' only when shorter than buffer. |
704 | */ |
705 | const char *serial = s->conf.serial ? s->conf.serial : "" ; |
706 | size_t size = MIN(strlen(serial) + 1, |
707 | MIN(iov_size(in_iov, in_num), |
708 | VIRTIO_BLK_ID_BYTES)); |
709 | iov_from_buf(in_iov, in_num, 0, serial, size); |
710 | virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); |
711 | virtio_blk_free_request(req); |
712 | break; |
713 | } |
714 | /* |
715 | * VIRTIO_BLK_T_DISCARD and VIRTIO_BLK_T_WRITE_ZEROES are defined with |
716 | * VIRTIO_BLK_T_OUT flag set. We masked this flag in the switch statement, |
717 | * so we must mask it for these requests, then we will check if it is set. |
718 | */ |
719 | case VIRTIO_BLK_T_DISCARD & ~VIRTIO_BLK_T_OUT: |
720 | case VIRTIO_BLK_T_WRITE_ZEROES & ~VIRTIO_BLK_T_OUT: |
721 | { |
722 | struct virtio_blk_discard_write_zeroes dwz_hdr; |
723 | size_t out_len = iov_size(out_iov, out_num); |
724 | bool is_write_zeroes = (type & ~VIRTIO_BLK_T_BARRIER) == |
725 | VIRTIO_BLK_T_WRITE_ZEROES; |
726 | uint8_t err_status; |
727 | |
728 | /* |
729 | * Unsupported if VIRTIO_BLK_T_OUT is not set or the request contains |
730 | * more than one segment. |
731 | */ |
732 | if (unlikely(!(type & VIRTIO_BLK_T_OUT) || |
733 | out_len > sizeof(dwz_hdr))) { |
734 | virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP); |
735 | virtio_blk_free_request(req); |
736 | return 0; |
737 | } |
738 | |
739 | if (unlikely(iov_to_buf(out_iov, out_num, 0, &dwz_hdr, |
740 | sizeof(dwz_hdr)) != sizeof(dwz_hdr))) { |
741 | virtio_error(vdev, "virtio-blk discard/write_zeroes header" |
742 | " too short" ); |
743 | return -1; |
744 | } |
745 | |
746 | err_status = virtio_blk_handle_discard_write_zeroes(req, &dwz_hdr, |
747 | is_write_zeroes); |
748 | if (err_status != VIRTIO_BLK_S_OK) { |
749 | virtio_blk_req_complete(req, err_status); |
750 | virtio_blk_free_request(req); |
751 | } |
752 | |
753 | break; |
754 | } |
755 | default: |
756 | virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP); |
757 | virtio_blk_free_request(req); |
758 | } |
759 | return 0; |
760 | } |
761 | |
762 | bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq) |
763 | { |
764 | VirtIOBlockReq *req; |
765 | MultiReqBuffer mrb = {}; |
766 | bool progress = false; |
767 | |
768 | aio_context_acquire(blk_get_aio_context(s->blk)); |
769 | blk_io_plug(s->blk); |
770 | |
771 | do { |
772 | virtio_queue_set_notification(vq, 0); |
773 | |
774 | while ((req = virtio_blk_get_request(s, vq))) { |
775 | progress = true; |
776 | if (virtio_blk_handle_request(req, &mrb)) { |
777 | virtqueue_detach_element(req->vq, &req->elem, 0); |
778 | virtio_blk_free_request(req); |
779 | break; |
780 | } |
781 | } |
782 | |
783 | virtio_queue_set_notification(vq, 1); |
784 | } while (!virtio_queue_empty(vq)); |
785 | |
786 | if (mrb.num_reqs) { |
787 | virtio_blk_submit_multireq(s->blk, &mrb); |
788 | } |
789 | |
790 | blk_io_unplug(s->blk); |
791 | aio_context_release(blk_get_aio_context(s->blk)); |
792 | return progress; |
793 | } |
794 | |
795 | static void virtio_blk_handle_output_do(VirtIOBlock *s, VirtQueue *vq) |
796 | { |
797 | virtio_blk_handle_vq(s, vq); |
798 | } |
799 | |
800 | static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq) |
801 | { |
802 | VirtIOBlock *s = (VirtIOBlock *)vdev; |
803 | |
804 | if (s->dataplane) { |
805 | /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start |
806 | * dataplane here instead of waiting for .set_status(). |
807 | */ |
808 | virtio_device_start_ioeventfd(vdev); |
809 | if (!s->dataplane_disabled) { |
810 | return; |
811 | } |
812 | } |
813 | virtio_blk_handle_output_do(s, vq); |
814 | } |
815 | |
816 | static void virtio_blk_dma_restart_bh(void *opaque) |
817 | { |
818 | VirtIOBlock *s = opaque; |
819 | VirtIOBlockReq *req = s->rq; |
820 | MultiReqBuffer mrb = {}; |
821 | |
822 | qemu_bh_delete(s->bh); |
823 | s->bh = NULL; |
824 | |
825 | s->rq = NULL; |
826 | |
827 | aio_context_acquire(blk_get_aio_context(s->conf.conf.blk)); |
828 | while (req) { |
829 | VirtIOBlockReq *next = req->next; |
830 | if (virtio_blk_handle_request(req, &mrb)) { |
831 | /* Device is now broken and won't do any processing until it gets |
832 | * reset. Already queued requests will be lost: let's purge them. |
833 | */ |
834 | while (req) { |
835 | next = req->next; |
836 | virtqueue_detach_element(req->vq, &req->elem, 0); |
837 | virtio_blk_free_request(req); |
838 | req = next; |
839 | } |
840 | break; |
841 | } |
842 | req = next; |
843 | } |
844 | |
845 | if (mrb.num_reqs) { |
846 | virtio_blk_submit_multireq(s->blk, &mrb); |
847 | } |
848 | blk_dec_in_flight(s->conf.conf.blk); |
849 | aio_context_release(blk_get_aio_context(s->conf.conf.blk)); |
850 | } |
851 | |
852 | static void virtio_blk_dma_restart_cb(void *opaque, int running, |
853 | RunState state) |
854 | { |
855 | VirtIOBlock *s = opaque; |
856 | |
857 | if (!running) { |
858 | return; |
859 | } |
860 | |
861 | if (!s->bh) { |
862 | /* FIXME The data plane is not started yet, so these requests are |
863 | * processed in the main thread. */ |
864 | s->bh = aio_bh_new(blk_get_aio_context(s->conf.conf.blk), |
865 | virtio_blk_dma_restart_bh, s); |
866 | blk_inc_in_flight(s->conf.conf.blk); |
867 | qemu_bh_schedule(s->bh); |
868 | } |
869 | } |
870 | |
871 | static void virtio_blk_reset(VirtIODevice *vdev) |
872 | { |
873 | VirtIOBlock *s = VIRTIO_BLK(vdev); |
874 | AioContext *ctx; |
875 | VirtIOBlockReq *req; |
876 | |
877 | ctx = blk_get_aio_context(s->blk); |
878 | aio_context_acquire(ctx); |
879 | blk_drain(s->blk); |
880 | |
881 | /* We drop queued requests after blk_drain() because blk_drain() itself can |
882 | * produce them. */ |
883 | while (s->rq) { |
884 | req = s->rq; |
885 | s->rq = req->next; |
886 | virtqueue_detach_element(req->vq, &req->elem, 0); |
887 | virtio_blk_free_request(req); |
888 | } |
889 | |
890 | aio_context_release(ctx); |
891 | |
892 | assert(!s->dataplane_started); |
893 | blk_set_enable_write_cache(s->blk, s->original_wce); |
894 | } |
895 | |
896 | /* coalesce internal state, copy to pci i/o region 0 |
897 | */ |
898 | static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) |
899 | { |
900 | VirtIOBlock *s = VIRTIO_BLK(vdev); |
901 | BlockConf *conf = &s->conf.conf; |
902 | struct virtio_blk_config blkcfg; |
903 | uint64_t capacity; |
904 | int64_t length; |
905 | int blk_size = conf->logical_block_size; |
906 | |
907 | blk_get_geometry(s->blk, &capacity); |
908 | memset(&blkcfg, 0, sizeof(blkcfg)); |
909 | virtio_stq_p(vdev, &blkcfg.capacity, capacity); |
910 | virtio_stl_p(vdev, &blkcfg.seg_max, 128 - 2); |
911 | virtio_stw_p(vdev, &blkcfg.geometry.cylinders, conf->cyls); |
912 | virtio_stl_p(vdev, &blkcfg.blk_size, blk_size); |
913 | virtio_stw_p(vdev, &blkcfg.min_io_size, conf->min_io_size / blk_size); |
914 | virtio_stw_p(vdev, &blkcfg.opt_io_size, conf->opt_io_size / blk_size); |
915 | blkcfg.geometry.heads = conf->heads; |
916 | /* |
917 | * We must ensure that the block device capacity is a multiple of |
918 | * the logical block size. If that is not the case, let's use |
919 | * sector_mask to adopt the geometry to have a correct picture. |
920 | * For those devices where the capacity is ok for the given geometry |
921 | * we don't touch the sector value of the geometry, since some devices |
922 | * (like s390 dasd) need a specific value. Here the capacity is already |
923 | * cyls*heads*secs*blk_size and the sector value is not block size |
924 | * divided by 512 - instead it is the amount of blk_size blocks |
925 | * per track (cylinder). |
926 | */ |
927 | length = blk_getlength(s->blk); |
928 | if (length > 0 && length / conf->heads / conf->secs % blk_size) { |
929 | blkcfg.geometry.sectors = conf->secs & ~s->sector_mask; |
930 | } else { |
931 | blkcfg.geometry.sectors = conf->secs; |
932 | } |
933 | blkcfg.size_max = 0; |
934 | blkcfg.physical_block_exp = get_physical_block_exp(conf); |
935 | blkcfg.alignment_offset = 0; |
936 | blkcfg.wce = blk_enable_write_cache(s->blk); |
937 | virtio_stw_p(vdev, &blkcfg.num_queues, s->conf.num_queues); |
938 | if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD)) { |
939 | virtio_stl_p(vdev, &blkcfg.max_discard_sectors, |
940 | s->conf.max_discard_sectors); |
941 | virtio_stl_p(vdev, &blkcfg.discard_sector_alignment, |
942 | blk_size >> BDRV_SECTOR_BITS); |
943 | /* |
944 | * We support only one segment per request since multiple segments |
945 | * are not widely used and there are no userspace APIs that allow |
946 | * applications to submit multiple segments in a single call. |
947 | */ |
948 | virtio_stl_p(vdev, &blkcfg.max_discard_seg, 1); |
949 | } |
950 | if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_WRITE_ZEROES)) { |
951 | virtio_stl_p(vdev, &blkcfg.max_write_zeroes_sectors, |
952 | s->conf.max_write_zeroes_sectors); |
953 | blkcfg.write_zeroes_may_unmap = 1; |
954 | virtio_stl_p(vdev, &blkcfg.max_write_zeroes_seg, 1); |
955 | } |
956 | memcpy(config, &blkcfg, s->config_size); |
957 | } |
958 | |
959 | static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config) |
960 | { |
961 | VirtIOBlock *s = VIRTIO_BLK(vdev); |
962 | struct virtio_blk_config blkcfg; |
963 | |
964 | memcpy(&blkcfg, config, s->config_size); |
965 | |
966 | aio_context_acquire(blk_get_aio_context(s->blk)); |
967 | blk_set_enable_write_cache(s->blk, blkcfg.wce != 0); |
968 | aio_context_release(blk_get_aio_context(s->blk)); |
969 | } |
970 | |
971 | static uint64_t virtio_blk_get_features(VirtIODevice *vdev, uint64_t features, |
972 | Error **errp) |
973 | { |
974 | VirtIOBlock *s = VIRTIO_BLK(vdev); |
975 | |
976 | /* Firstly sync all virtio-blk possible supported features */ |
977 | features |= s->host_features; |
978 | |
979 | virtio_add_feature(&features, VIRTIO_BLK_F_SEG_MAX); |
980 | virtio_add_feature(&features, VIRTIO_BLK_F_GEOMETRY); |
981 | virtio_add_feature(&features, VIRTIO_BLK_F_TOPOLOGY); |
982 | virtio_add_feature(&features, VIRTIO_BLK_F_BLK_SIZE); |
983 | if (virtio_has_feature(features, VIRTIO_F_VERSION_1)) { |
984 | if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_SCSI)) { |
985 | error_setg(errp, "Please set scsi=off for virtio-blk devices in order to use virtio 1.0" ); |
986 | return 0; |
987 | } |
988 | } else { |
989 | virtio_clear_feature(&features, VIRTIO_F_ANY_LAYOUT); |
990 | virtio_add_feature(&features, VIRTIO_BLK_F_SCSI); |
991 | } |
992 | |
993 | if (blk_enable_write_cache(s->blk)) { |
994 | virtio_add_feature(&features, VIRTIO_BLK_F_WCE); |
995 | } |
996 | if (blk_is_read_only(s->blk)) { |
997 | virtio_add_feature(&features, VIRTIO_BLK_F_RO); |
998 | } |
999 | if (s->conf.num_queues > 1) { |
1000 | virtio_add_feature(&features, VIRTIO_BLK_F_MQ); |
1001 | } |
1002 | |
1003 | return features; |
1004 | } |
1005 | |
1006 | static void virtio_blk_set_status(VirtIODevice *vdev, uint8_t status) |
1007 | { |
1008 | VirtIOBlock *s = VIRTIO_BLK(vdev); |
1009 | |
1010 | if (!(status & (VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_DRIVER_OK))) { |
1011 | assert(!s->dataplane_started); |
1012 | } |
1013 | |
1014 | if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) { |
1015 | return; |
1016 | } |
1017 | |
1018 | /* A guest that supports VIRTIO_BLK_F_CONFIG_WCE must be able to send |
1019 | * cache flushes. Thus, the "auto writethrough" behavior is never |
1020 | * necessary for guests that support the VIRTIO_BLK_F_CONFIG_WCE feature. |
1021 | * Leaving it enabled would break the following sequence: |
1022 | * |
1023 | * Guest started with "-drive cache=writethrough" |
1024 | * Guest sets status to 0 |
1025 | * Guest sets DRIVER bit in status field |
1026 | * Guest reads host features (WCE=0, CONFIG_WCE=1) |
1027 | * Guest writes guest features (WCE=0, CONFIG_WCE=1) |
1028 | * Guest writes 1 to the WCE configuration field (writeback mode) |
1029 | * Guest sets DRIVER_OK bit in status field |
1030 | * |
1031 | * s->blk would erroneously be placed in writethrough mode. |
1032 | */ |
1033 | if (!virtio_vdev_has_feature(vdev, VIRTIO_BLK_F_CONFIG_WCE)) { |
1034 | aio_context_acquire(blk_get_aio_context(s->blk)); |
1035 | blk_set_enable_write_cache(s->blk, |
1036 | virtio_vdev_has_feature(vdev, |
1037 | VIRTIO_BLK_F_WCE)); |
1038 | aio_context_release(blk_get_aio_context(s->blk)); |
1039 | } |
1040 | } |
1041 | |
1042 | static void virtio_blk_save_device(VirtIODevice *vdev, QEMUFile *f) |
1043 | { |
1044 | VirtIOBlock *s = VIRTIO_BLK(vdev); |
1045 | VirtIOBlockReq *req = s->rq; |
1046 | |
1047 | while (req) { |
1048 | qemu_put_sbyte(f, 1); |
1049 | |
1050 | if (s->conf.num_queues > 1) { |
1051 | qemu_put_be32(f, virtio_get_queue_index(req->vq)); |
1052 | } |
1053 | |
1054 | qemu_put_virtqueue_element(f, &req->elem); |
1055 | req = req->next; |
1056 | } |
1057 | qemu_put_sbyte(f, 0); |
1058 | } |
1059 | |
1060 | static int virtio_blk_load_device(VirtIODevice *vdev, QEMUFile *f, |
1061 | int version_id) |
1062 | { |
1063 | VirtIOBlock *s = VIRTIO_BLK(vdev); |
1064 | |
1065 | while (qemu_get_sbyte(f)) { |
1066 | unsigned nvqs = s->conf.num_queues; |
1067 | unsigned vq_idx = 0; |
1068 | VirtIOBlockReq *req; |
1069 | |
1070 | if (nvqs > 1) { |
1071 | vq_idx = qemu_get_be32(f); |
1072 | |
1073 | if (vq_idx >= nvqs) { |
1074 | error_report("Invalid virtqueue index in request list: %#x" , |
1075 | vq_idx); |
1076 | return -EINVAL; |
1077 | } |
1078 | } |
1079 | |
1080 | req = qemu_get_virtqueue_element(vdev, f, sizeof(VirtIOBlockReq)); |
1081 | virtio_blk_init_request(s, virtio_get_queue(vdev, vq_idx), req); |
1082 | req->next = s->rq; |
1083 | s->rq = req; |
1084 | } |
1085 | |
1086 | return 0; |
1087 | } |
1088 | |
1089 | static void virtio_blk_resize(void *opaque) |
1090 | { |
1091 | VirtIODevice *vdev = VIRTIO_DEVICE(opaque); |
1092 | |
1093 | virtio_notify_config(vdev); |
1094 | } |
1095 | |
1096 | static const BlockDevOps virtio_block_ops = { |
1097 | .resize_cb = virtio_blk_resize, |
1098 | }; |
1099 | |
1100 | static void virtio_blk_device_realize(DeviceState *dev, Error **errp) |
1101 | { |
1102 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); |
1103 | VirtIOBlock *s = VIRTIO_BLK(dev); |
1104 | VirtIOBlkConf *conf = &s->conf; |
1105 | Error *err = NULL; |
1106 | unsigned i; |
1107 | |
1108 | if (!conf->conf.blk) { |
1109 | error_setg(errp, "drive property not set" ); |
1110 | return; |
1111 | } |
1112 | if (!blk_is_inserted(conf->conf.blk)) { |
1113 | error_setg(errp, "Device needs media, but drive is empty" ); |
1114 | return; |
1115 | } |
1116 | if (!conf->num_queues) { |
1117 | error_setg(errp, "num-queues property must be larger than 0" ); |
1118 | return; |
1119 | } |
1120 | if (!is_power_of_2(conf->queue_size) || |
1121 | conf->queue_size > VIRTQUEUE_MAX_SIZE) { |
1122 | error_setg(errp, "invalid queue-size property (%" PRIu16 "), " |
1123 | "must be a power of 2 (max %d)" , |
1124 | conf->queue_size, VIRTQUEUE_MAX_SIZE); |
1125 | return; |
1126 | } |
1127 | |
1128 | if (!blkconf_apply_backend_options(&conf->conf, |
1129 | blk_is_read_only(conf->conf.blk), true, |
1130 | errp)) { |
1131 | return; |
1132 | } |
1133 | s->original_wce = blk_enable_write_cache(conf->conf.blk); |
1134 | if (!blkconf_geometry(&conf->conf, NULL, 65535, 255, 255, errp)) { |
1135 | return; |
1136 | } |
1137 | |
1138 | blkconf_blocksizes(&conf->conf); |
1139 | |
1140 | if (conf->conf.logical_block_size > |
1141 | conf->conf.physical_block_size) { |
1142 | error_setg(errp, |
1143 | "logical_block_size > physical_block_size not supported" ); |
1144 | return; |
1145 | } |
1146 | |
1147 | if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD) && |
1148 | (!conf->max_discard_sectors || |
1149 | conf->max_discard_sectors > BDRV_REQUEST_MAX_SECTORS)) { |
1150 | error_setg(errp, "invalid max-discard-sectors property (%" PRIu32 ")" |
1151 | ", must be between 1 and %d" , |
1152 | conf->max_discard_sectors, (int)BDRV_REQUEST_MAX_SECTORS); |
1153 | return; |
1154 | } |
1155 | |
1156 | if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_WRITE_ZEROES) && |
1157 | (!conf->max_write_zeroes_sectors || |
1158 | conf->max_write_zeroes_sectors > BDRV_REQUEST_MAX_SECTORS)) { |
1159 | error_setg(errp, "invalid max-write-zeroes-sectors property (%" PRIu32 |
1160 | "), must be between 1 and %d" , |
1161 | conf->max_write_zeroes_sectors, |
1162 | (int)BDRV_REQUEST_MAX_SECTORS); |
1163 | return; |
1164 | } |
1165 | |
1166 | virtio_blk_set_config_size(s, s->host_features); |
1167 | |
1168 | virtio_init(vdev, "virtio-blk" , VIRTIO_ID_BLOCK, s->config_size); |
1169 | |
1170 | s->blk = conf->conf.blk; |
1171 | s->rq = NULL; |
1172 | s->sector_mask = (s->conf.conf.logical_block_size / BDRV_SECTOR_SIZE) - 1; |
1173 | |
1174 | for (i = 0; i < conf->num_queues; i++) { |
1175 | virtio_add_queue(vdev, conf->queue_size, virtio_blk_handle_output); |
1176 | } |
1177 | virtio_blk_data_plane_create(vdev, conf, &s->dataplane, &err); |
1178 | if (err != NULL) { |
1179 | error_propagate(errp, err); |
1180 | virtio_cleanup(vdev); |
1181 | return; |
1182 | } |
1183 | |
1184 | s->change = qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s); |
1185 | blk_set_dev_ops(s->blk, &virtio_block_ops, s); |
1186 | blk_set_guest_block_size(s->blk, s->conf.conf.logical_block_size); |
1187 | |
1188 | blk_iostatus_enable(s->blk); |
1189 | } |
1190 | |
1191 | static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp) |
1192 | { |
1193 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); |
1194 | VirtIOBlock *s = VIRTIO_BLK(dev); |
1195 | |
1196 | virtio_blk_data_plane_destroy(s->dataplane); |
1197 | s->dataplane = NULL; |
1198 | qemu_del_vm_change_state_handler(s->change); |
1199 | blockdev_mark_auto_del(s->blk); |
1200 | virtio_cleanup(vdev); |
1201 | } |
1202 | |
1203 | static void virtio_blk_instance_init(Object *obj) |
1204 | { |
1205 | VirtIOBlock *s = VIRTIO_BLK(obj); |
1206 | |
1207 | device_add_bootindex_property(obj, &s->conf.conf.bootindex, |
1208 | "bootindex" , "/disk@0,0" , |
1209 | DEVICE(obj), NULL); |
1210 | } |
1211 | |
1212 | static const VMStateDescription vmstate_virtio_blk = { |
1213 | .name = "virtio-blk" , |
1214 | .minimum_version_id = 2, |
1215 | .version_id = 2, |
1216 | .fields = (VMStateField[]) { |
1217 | VMSTATE_VIRTIO_DEVICE, |
1218 | VMSTATE_END_OF_LIST() |
1219 | }, |
1220 | }; |
1221 | |
1222 | static Property virtio_blk_properties[] = { |
1223 | DEFINE_BLOCK_PROPERTIES(VirtIOBlock, conf.conf), |
1224 | DEFINE_BLOCK_ERROR_PROPERTIES(VirtIOBlock, conf.conf), |
1225 | DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock, conf.conf), |
1226 | DEFINE_PROP_STRING("serial" , VirtIOBlock, conf.serial), |
1227 | DEFINE_PROP_BIT64("config-wce" , VirtIOBlock, host_features, |
1228 | VIRTIO_BLK_F_CONFIG_WCE, true), |
1229 | #ifdef __linux__ |
1230 | DEFINE_PROP_BIT64("scsi" , VirtIOBlock, host_features, |
1231 | VIRTIO_BLK_F_SCSI, false), |
1232 | #endif |
1233 | DEFINE_PROP_BIT("request-merging" , VirtIOBlock, conf.request_merging, 0, |
1234 | true), |
1235 | DEFINE_PROP_UINT16("num-queues" , VirtIOBlock, conf.num_queues, 1), |
1236 | DEFINE_PROP_UINT16("queue-size" , VirtIOBlock, conf.queue_size, 128), |
1237 | DEFINE_PROP_LINK("iothread" , VirtIOBlock, conf.iothread, TYPE_IOTHREAD, |
1238 | IOThread *), |
1239 | DEFINE_PROP_BIT64("discard" , VirtIOBlock, host_features, |
1240 | VIRTIO_BLK_F_DISCARD, true), |
1241 | DEFINE_PROP_BIT64("write-zeroes" , VirtIOBlock, host_features, |
1242 | VIRTIO_BLK_F_WRITE_ZEROES, true), |
1243 | DEFINE_PROP_UINT32("max-discard-sectors" , VirtIOBlock, |
1244 | conf.max_discard_sectors, BDRV_REQUEST_MAX_SECTORS), |
1245 | DEFINE_PROP_UINT32("max-write-zeroes-sectors" , VirtIOBlock, |
1246 | conf.max_write_zeroes_sectors, BDRV_REQUEST_MAX_SECTORS), |
1247 | DEFINE_PROP_END_OF_LIST(), |
1248 | }; |
1249 | |
1250 | static void virtio_blk_class_init(ObjectClass *klass, void *data) |
1251 | { |
1252 | DeviceClass *dc = DEVICE_CLASS(klass); |
1253 | VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); |
1254 | |
1255 | dc->props = virtio_blk_properties; |
1256 | dc->vmsd = &vmstate_virtio_blk; |
1257 | set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); |
1258 | vdc->realize = virtio_blk_device_realize; |
1259 | vdc->unrealize = virtio_blk_device_unrealize; |
1260 | vdc->get_config = virtio_blk_update_config; |
1261 | vdc->set_config = virtio_blk_set_config; |
1262 | vdc->get_features = virtio_blk_get_features; |
1263 | vdc->set_status = virtio_blk_set_status; |
1264 | vdc->reset = virtio_blk_reset; |
1265 | vdc->save = virtio_blk_save_device; |
1266 | vdc->load = virtio_blk_load_device; |
1267 | vdc->start_ioeventfd = virtio_blk_data_plane_start; |
1268 | vdc->stop_ioeventfd = virtio_blk_data_plane_stop; |
1269 | } |
1270 | |
1271 | static const TypeInfo virtio_blk_info = { |
1272 | .name = TYPE_VIRTIO_BLK, |
1273 | .parent = TYPE_VIRTIO_DEVICE, |
1274 | .instance_size = sizeof(VirtIOBlock), |
1275 | .instance_init = virtio_blk_instance_init, |
1276 | .class_init = virtio_blk_class_init, |
1277 | }; |
1278 | |
1279 | static void virtio_register_types(void) |
1280 | { |
1281 | type_register_static(&virtio_blk_info); |
1282 | } |
1283 | |
1284 | type_init(virtio_register_types) |
1285 | |