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-common.h" 15 #include "qemu/iov.h" 16 #include "qemu/error-report.h" 17 #include "trace.h" 18 #include "hw/block/block.h" 19 #include "sysemu/block-backend.h" 20 #include "sysemu/blockdev.h" 21 #include "hw/virtio/virtio-blk.h" 22 #include "dataplane/virtio-blk.h" 23 #include "migration/migration.h" 24 #include "block/scsi.h" 25 #ifdef __linux__ 26 # include <scsi/sg.h> 27 #endif 28 #include "hw/virtio/virtio-bus.h" 29 #include "hw/virtio/virtio-access.h" 30 31 VirtIOBlockReq *virtio_blk_alloc_request(VirtIOBlock *s) 32 { 33 VirtIOBlockReq *req = g_slice_new(VirtIOBlockReq); 34 req->dev = s; 35 req->qiov.size = 0; 36 req->next = NULL; 37 return req; 38 } 39 40 void virtio_blk_free_request(VirtIOBlockReq *req) 41 { 42 if (req) { 43 g_slice_free(VirtIOBlockReq, req); 44 } 45 } 46 47 static void virtio_blk_complete_request(VirtIOBlockReq *req, 48 unsigned char status) 49 { 50 VirtIOBlock *s = req->dev; 51 VirtIODevice *vdev = VIRTIO_DEVICE(s); 52 53 trace_virtio_blk_req_complete(req, status); 54 55 stb_p(&req->in->status, status); 56 virtqueue_push(s->vq, &req->elem, req->qiov.size + sizeof(*req->in)); 57 virtio_notify(vdev, s->vq); 58 } 59 60 static void virtio_blk_req_complete(VirtIOBlockReq *req, unsigned char status) 61 { 62 req->dev->complete_request(req, status); 63 } 64 65 static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error, 66 bool is_read) 67 { 68 BlockErrorAction action = blk_get_error_action(req->dev->blk, 69 is_read, error); 70 VirtIOBlock *s = req->dev; 71 72 if (action == BLOCK_ERROR_ACTION_STOP) { 73 req->next = s->rq; 74 s->rq = req; 75 } else if (action == BLOCK_ERROR_ACTION_REPORT) { 76 virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR); 77 block_acct_done(blk_get_stats(s->blk), &req->acct); 78 virtio_blk_free_request(req); 79 } 80 81 blk_error_action(s->blk, action, is_read, error); 82 return action != BLOCK_ERROR_ACTION_IGNORE; 83 } 84 85 static void virtio_blk_rw_complete(void *opaque, int ret) 86 { 87 VirtIOBlockReq *req = opaque; 88 89 trace_virtio_blk_rw_complete(req, ret); 90 91 if (ret) { 92 int p = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type); 93 bool is_read = !(p & VIRTIO_BLK_T_OUT); 94 if (virtio_blk_handle_rw_error(req, -ret, is_read)) 95 return; 96 } 97 98 virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); 99 block_acct_done(blk_get_stats(req->dev->blk), &req->acct); 100 virtio_blk_free_request(req); 101 } 102 103 static void virtio_blk_flush_complete(void *opaque, int ret) 104 { 105 VirtIOBlockReq *req = opaque; 106 107 if (ret) { 108 if (virtio_blk_handle_rw_error(req, -ret, 0)) { 109 return; 110 } 111 } 112 113 virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); 114 block_acct_done(blk_get_stats(req->dev->blk), &req->acct); 115 virtio_blk_free_request(req); 116 } 117 118 #ifdef __linux__ 119 120 typedef struct { 121 VirtIOBlockReq *req; 122 struct sg_io_hdr hdr; 123 } VirtIOBlockIoctlReq; 124 125 static void virtio_blk_ioctl_complete(void *opaque, int status) 126 { 127 VirtIOBlockIoctlReq *ioctl_req = opaque; 128 VirtIOBlockReq *req = ioctl_req->req; 129 VirtIODevice *vdev = VIRTIO_DEVICE(req->dev); 130 struct virtio_scsi_inhdr *scsi; 131 struct sg_io_hdr *hdr; 132 133 scsi = (void *)req->elem.in_sg[req->elem.in_num - 2].iov_base; 134 135 if (status) { 136 status = VIRTIO_BLK_S_UNSUPP; 137 virtio_stl_p(vdev, &scsi->errors, 255); 138 goto out; 139 } 140 141 hdr = &ioctl_req->hdr; 142 /* 143 * From SCSI-Generic-HOWTO: "Some lower level drivers (e.g. ide-scsi) 144 * clear the masked_status field [hence status gets cleared too, see 145 * block/scsi_ioctl.c] even when a CHECK_CONDITION or COMMAND_TERMINATED 146 * status has occurred. However they do set DRIVER_SENSE in driver_status 147 * field. Also a (sb_len_wr > 0) indicates there is a sense buffer. 148 */ 149 if (hdr->status == 0 && hdr->sb_len_wr > 0) { 150 hdr->status = CHECK_CONDITION; 151 } 152 153 virtio_stl_p(vdev, &scsi->errors, 154 hdr->status | (hdr->msg_status << 8) | 155 (hdr->host_status << 16) | (hdr->driver_status << 24)); 156 virtio_stl_p(vdev, &scsi->residual, hdr->resid); 157 virtio_stl_p(vdev, &scsi->sense_len, hdr->sb_len_wr); 158 virtio_stl_p(vdev, &scsi->data_len, hdr->dxfer_len); 159 160 out: 161 virtio_blk_req_complete(req, status); 162 virtio_blk_free_request(req); 163 g_free(ioctl_req); 164 } 165 166 #endif 167 168 static VirtIOBlockReq *virtio_blk_get_request(VirtIOBlock *s) 169 { 170 VirtIOBlockReq *req = virtio_blk_alloc_request(s); 171 172 if (!virtqueue_pop(s->vq, &req->elem)) { 173 virtio_blk_free_request(req); 174 return NULL; 175 } 176 177 return req; 178 } 179 180 static int virtio_blk_handle_scsi_req(VirtIOBlockReq *req) 181 { 182 int status = VIRTIO_BLK_S_OK; 183 struct virtio_scsi_inhdr *scsi = NULL; 184 VirtIODevice *vdev = VIRTIO_DEVICE(req->dev); 185 VirtQueueElement *elem = &req->elem; 186 VirtIOBlock *blk = req->dev; 187 188 #ifdef __linux__ 189 int i; 190 VirtIOBlockIoctlReq *ioctl_req; 191 #endif 192 193 /* 194 * We require at least one output segment each for the virtio_blk_outhdr 195 * and the SCSI command block. 196 * 197 * We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr 198 * and the sense buffer pointer in the input segments. 199 */ 200 if (elem->out_num < 2 || elem->in_num < 3) { 201 status = VIRTIO_BLK_S_IOERR; 202 goto fail; 203 } 204 205 /* 206 * The scsi inhdr is placed in the second-to-last input segment, just 207 * before the regular inhdr. 208 */ 209 scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base; 210 211 if (!blk->conf.scsi) { 212 status = VIRTIO_BLK_S_UNSUPP; 213 goto fail; 214 } 215 216 /* 217 * No support for bidirection commands yet. 218 */ 219 if (elem->out_num > 2 && elem->in_num > 3) { 220 status = VIRTIO_BLK_S_UNSUPP; 221 goto fail; 222 } 223 224 #ifdef __linux__ 225 ioctl_req = g_new0(VirtIOBlockIoctlReq, 1); 226 ioctl_req->req = req; 227 ioctl_req->hdr.interface_id = 'S'; 228 ioctl_req->hdr.cmd_len = elem->out_sg[1].iov_len; 229 ioctl_req->hdr.cmdp = elem->out_sg[1].iov_base; 230 ioctl_req->hdr.dxfer_len = 0; 231 232 if (elem->out_num > 2) { 233 /* 234 * If there are more than the minimally required 2 output segments 235 * there is write payload starting from the third iovec. 236 */ 237 ioctl_req->hdr.dxfer_direction = SG_DXFER_TO_DEV; 238 ioctl_req->hdr.iovec_count = elem->out_num - 2; 239 240 for (i = 0; i < ioctl_req->hdr.iovec_count; i++) { 241 ioctl_req->hdr.dxfer_len += elem->out_sg[i + 2].iov_len; 242 } 243 244 ioctl_req->hdr.dxferp = elem->out_sg + 2; 245 246 } else if (elem->in_num > 3) { 247 /* 248 * If we have more than 3 input segments the guest wants to actually 249 * read data. 250 */ 251 ioctl_req->hdr.dxfer_direction = SG_DXFER_FROM_DEV; 252 ioctl_req->hdr.iovec_count = elem->in_num - 3; 253 for (i = 0; i < ioctl_req->hdr.iovec_count; i++) { 254 ioctl_req->hdr.dxfer_len += elem->in_sg[i].iov_len; 255 } 256 257 ioctl_req->hdr.dxferp = elem->in_sg; 258 } else { 259 /* 260 * Some SCSI commands don't actually transfer any data. 261 */ 262 ioctl_req->hdr.dxfer_direction = SG_DXFER_NONE; 263 } 264 265 ioctl_req->hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base; 266 ioctl_req->hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len; 267 268 blk_aio_ioctl(blk->blk, SG_IO, &ioctl_req->hdr, 269 virtio_blk_ioctl_complete, ioctl_req); 270 return -EINPROGRESS; 271 #else 272 abort(); 273 #endif 274 275 fail: 276 /* Just put anything nonzero so that the ioctl fails in the guest. */ 277 if (scsi) { 278 virtio_stl_p(vdev, &scsi->errors, 255); 279 } 280 return status; 281 } 282 283 static void virtio_blk_handle_scsi(VirtIOBlockReq *req) 284 { 285 int status; 286 287 status = virtio_blk_handle_scsi_req(req); 288 if (status != -EINPROGRESS) { 289 virtio_blk_req_complete(req, status); 290 virtio_blk_free_request(req); 291 } 292 } 293 294 void virtio_submit_multiwrite(BlockBackend *blk, MultiReqBuffer *mrb) 295 { 296 int i, ret; 297 298 if (!mrb->num_writes) { 299 return; 300 } 301 302 ret = blk_aio_multiwrite(blk, mrb->blkreq, mrb->num_writes); 303 if (ret != 0) { 304 for (i = 0; i < mrb->num_writes; i++) { 305 if (mrb->blkreq[i].error) { 306 virtio_blk_rw_complete(mrb->blkreq[i].opaque, -EIO); 307 } 308 } 309 } 310 311 mrb->num_writes = 0; 312 } 313 314 static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb) 315 { 316 block_acct_start(blk_get_stats(req->dev->blk), &req->acct, 0, 317 BLOCK_ACCT_FLUSH); 318 319 /* 320 * Make sure all outstanding writes are posted to the backing device. 321 */ 322 virtio_submit_multiwrite(req->dev->blk, mrb); 323 blk_aio_flush(req->dev->blk, virtio_blk_flush_complete, req); 324 } 325 326 static bool virtio_blk_sect_range_ok(VirtIOBlock *dev, 327 uint64_t sector, size_t size) 328 { 329 uint64_t nb_sectors = size >> BDRV_SECTOR_BITS; 330 uint64_t total_sectors; 331 332 if (sector & dev->sector_mask) { 333 return false; 334 } 335 if (size % dev->conf.conf.logical_block_size) { 336 return false; 337 } 338 blk_get_geometry(dev->blk, &total_sectors); 339 if (sector > total_sectors || nb_sectors > total_sectors - sector) { 340 return false; 341 } 342 return true; 343 } 344 345 static void virtio_blk_handle_write(VirtIOBlockReq *req, MultiReqBuffer *mrb) 346 { 347 BlockRequest *blkreq; 348 uint64_t sector; 349 350 sector = virtio_ldq_p(VIRTIO_DEVICE(req->dev), &req->out.sector); 351 352 trace_virtio_blk_handle_write(req, sector, req->qiov.size / 512); 353 354 if (!virtio_blk_sect_range_ok(req->dev, sector, req->qiov.size)) { 355 virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR); 356 virtio_blk_free_request(req); 357 return; 358 } 359 360 block_acct_start(blk_get_stats(req->dev->blk), &req->acct, req->qiov.size, 361 BLOCK_ACCT_WRITE); 362 363 if (mrb->num_writes == 32) { 364 virtio_submit_multiwrite(req->dev->blk, mrb); 365 } 366 367 blkreq = &mrb->blkreq[mrb->num_writes]; 368 blkreq->sector = sector; 369 blkreq->nb_sectors = req->qiov.size / BDRV_SECTOR_SIZE; 370 blkreq->qiov = &req->qiov; 371 blkreq->cb = virtio_blk_rw_complete; 372 blkreq->opaque = req; 373 blkreq->error = 0; 374 375 mrb->num_writes++; 376 } 377 378 static void virtio_blk_handle_read(VirtIOBlockReq *req) 379 { 380 uint64_t sector; 381 382 sector = virtio_ldq_p(VIRTIO_DEVICE(req->dev), &req->out.sector); 383 384 trace_virtio_blk_handle_read(req, sector, req->qiov.size / 512); 385 386 if (!virtio_blk_sect_range_ok(req->dev, sector, req->qiov.size)) { 387 virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR); 388 virtio_blk_free_request(req); 389 return; 390 } 391 392 block_acct_start(blk_get_stats(req->dev->blk), &req->acct, req->qiov.size, 393 BLOCK_ACCT_READ); 394 blk_aio_readv(req->dev->blk, sector, &req->qiov, 395 req->qiov.size / BDRV_SECTOR_SIZE, 396 virtio_blk_rw_complete, req); 397 } 398 399 void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb) 400 { 401 uint32_t type; 402 struct iovec *in_iov = req->elem.in_sg; 403 struct iovec *iov = req->elem.out_sg; 404 unsigned in_num = req->elem.in_num; 405 unsigned out_num = req->elem.out_num; 406 407 if (req->elem.out_num < 1 || req->elem.in_num < 1) { 408 error_report("virtio-blk missing headers"); 409 exit(1); 410 } 411 412 if (unlikely(iov_to_buf(iov, out_num, 0, &req->out, 413 sizeof(req->out)) != sizeof(req->out))) { 414 error_report("virtio-blk request outhdr too short"); 415 exit(1); 416 } 417 418 iov_discard_front(&iov, &out_num, sizeof(req->out)); 419 420 if (in_num < 1 || 421 in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) { 422 error_report("virtio-blk request inhdr too short"); 423 exit(1); 424 } 425 426 req->in = (void *)in_iov[in_num - 1].iov_base 427 + in_iov[in_num - 1].iov_len 428 - sizeof(struct virtio_blk_inhdr); 429 iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr)); 430 431 type = virtio_ldl_p(VIRTIO_DEVICE(req->dev), &req->out.type); 432 433 if (type & VIRTIO_BLK_T_FLUSH) { 434 virtio_blk_handle_flush(req, mrb); 435 } else if (type & VIRTIO_BLK_T_SCSI_CMD) { 436 virtio_blk_handle_scsi(req); 437 } else if (type & VIRTIO_BLK_T_GET_ID) { 438 VirtIOBlock *s = req->dev; 439 440 /* 441 * NB: per existing s/n string convention the string is 442 * terminated by '\0' only when shorter than buffer. 443 */ 444 const char *serial = s->conf.serial ? s->conf.serial : ""; 445 size_t size = MIN(strlen(serial) + 1, 446 MIN(iov_size(in_iov, in_num), 447 VIRTIO_BLK_ID_BYTES)); 448 iov_from_buf(in_iov, in_num, 0, serial, size); 449 virtio_blk_req_complete(req, VIRTIO_BLK_S_OK); 450 virtio_blk_free_request(req); 451 } else if (type & VIRTIO_BLK_T_OUT) { 452 qemu_iovec_init_external(&req->qiov, iov, out_num); 453 virtio_blk_handle_write(req, mrb); 454 } else if (type == VIRTIO_BLK_T_IN || type == VIRTIO_BLK_T_BARRIER) { 455 /* VIRTIO_BLK_T_IN is 0, so we can't just & it. */ 456 qemu_iovec_init_external(&req->qiov, in_iov, in_num); 457 virtio_blk_handle_read(req); 458 } else { 459 virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP); 460 virtio_blk_free_request(req); 461 } 462 } 463 464 static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq) 465 { 466 VirtIOBlock *s = VIRTIO_BLK(vdev); 467 VirtIOBlockReq *req; 468 MultiReqBuffer mrb = { 469 .num_writes = 0, 470 }; 471 472 /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start 473 * dataplane here instead of waiting for .set_status(). 474 */ 475 if (s->dataplane) { 476 virtio_blk_data_plane_start(s->dataplane); 477 return; 478 } 479 480 while ((req = virtio_blk_get_request(s))) { 481 virtio_blk_handle_request(req, &mrb); 482 } 483 484 virtio_submit_multiwrite(s->blk, &mrb); 485 486 /* 487 * FIXME: Want to check for completions before returning to guest mode, 488 * so cached reads and writes are reported as quickly as possible. But 489 * that should be done in the generic block layer. 490 */ 491 } 492 493 static void virtio_blk_dma_restart_bh(void *opaque) 494 { 495 VirtIOBlock *s = opaque; 496 VirtIOBlockReq *req = s->rq; 497 MultiReqBuffer mrb = { 498 .num_writes = 0, 499 }; 500 501 qemu_bh_delete(s->bh); 502 s->bh = NULL; 503 504 s->rq = NULL; 505 506 while (req) { 507 VirtIOBlockReq *next = req->next; 508 virtio_blk_handle_request(req, &mrb); 509 req = next; 510 } 511 512 virtio_submit_multiwrite(s->blk, &mrb); 513 } 514 515 static void virtio_blk_dma_restart_cb(void *opaque, int running, 516 RunState state) 517 { 518 VirtIOBlock *s = opaque; 519 520 if (!running) { 521 return; 522 } 523 524 if (!s->bh) { 525 s->bh = aio_bh_new(blk_get_aio_context(s->conf.conf.blk), 526 virtio_blk_dma_restart_bh, s); 527 qemu_bh_schedule(s->bh); 528 } 529 } 530 531 static void virtio_blk_reset(VirtIODevice *vdev) 532 { 533 VirtIOBlock *s = VIRTIO_BLK(vdev); 534 535 if (s->dataplane) { 536 virtio_blk_data_plane_stop(s->dataplane); 537 } 538 539 /* 540 * This should cancel pending requests, but can't do nicely until there 541 * are per-device request lists. 542 */ 543 blk_drain_all(); 544 blk_set_enable_write_cache(s->blk, s->original_wce); 545 } 546 547 /* coalesce internal state, copy to pci i/o region 0 548 */ 549 static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) 550 { 551 VirtIOBlock *s = VIRTIO_BLK(vdev); 552 BlockConf *conf = &s->conf.conf; 553 struct virtio_blk_config blkcfg; 554 uint64_t capacity; 555 int blk_size = conf->logical_block_size; 556 557 blk_get_geometry(s->blk, &capacity); 558 memset(&blkcfg, 0, sizeof(blkcfg)); 559 virtio_stq_p(vdev, &blkcfg.capacity, capacity); 560 virtio_stl_p(vdev, &blkcfg.seg_max, 128 - 2); 561 virtio_stw_p(vdev, &blkcfg.cylinders, conf->cyls); 562 virtio_stl_p(vdev, &blkcfg.blk_size, blk_size); 563 virtio_stw_p(vdev, &blkcfg.min_io_size, conf->min_io_size / blk_size); 564 virtio_stw_p(vdev, &blkcfg.opt_io_size, conf->opt_io_size / blk_size); 565 blkcfg.heads = conf->heads; 566 /* 567 * We must ensure that the block device capacity is a multiple of 568 * the logical block size. If that is not the case, let's use 569 * sector_mask to adopt the geometry to have a correct picture. 570 * For those devices where the capacity is ok for the given geometry 571 * we don't touch the sector value of the geometry, since some devices 572 * (like s390 dasd) need a specific value. Here the capacity is already 573 * cyls*heads*secs*blk_size and the sector value is not block size 574 * divided by 512 - instead it is the amount of blk_size blocks 575 * per track (cylinder). 576 */ 577 if (blk_getlength(s->blk) / conf->heads / conf->secs % blk_size) { 578 blkcfg.sectors = conf->secs & ~s->sector_mask; 579 } else { 580 blkcfg.sectors = conf->secs; 581 } 582 blkcfg.size_max = 0; 583 blkcfg.physical_block_exp = get_physical_block_exp(conf); 584 blkcfg.alignment_offset = 0; 585 blkcfg.wce = blk_enable_write_cache(s->blk); 586 memcpy(config, &blkcfg, sizeof(struct virtio_blk_config)); 587 } 588 589 static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config) 590 { 591 VirtIOBlock *s = VIRTIO_BLK(vdev); 592 struct virtio_blk_config blkcfg; 593 594 memcpy(&blkcfg, config, sizeof(blkcfg)); 595 596 aio_context_acquire(blk_get_aio_context(s->blk)); 597 blk_set_enable_write_cache(s->blk, blkcfg.wce != 0); 598 aio_context_release(blk_get_aio_context(s->blk)); 599 } 600 601 static uint32_t virtio_blk_get_features(VirtIODevice *vdev, uint32_t features) 602 { 603 VirtIOBlock *s = VIRTIO_BLK(vdev); 604 605 features |= (1 << VIRTIO_BLK_F_SEG_MAX); 606 features |= (1 << VIRTIO_BLK_F_GEOMETRY); 607 features |= (1 << VIRTIO_BLK_F_TOPOLOGY); 608 features |= (1 << VIRTIO_BLK_F_BLK_SIZE); 609 features |= (1 << VIRTIO_BLK_F_SCSI); 610 611 if (s->conf.config_wce) { 612 features |= (1 << VIRTIO_BLK_F_CONFIG_WCE); 613 } 614 if (blk_enable_write_cache(s->blk)) { 615 features |= (1 << VIRTIO_BLK_F_WCE); 616 } 617 if (blk_is_read_only(s->blk)) { 618 features |= 1 << VIRTIO_BLK_F_RO; 619 } 620 621 return features; 622 } 623 624 static void virtio_blk_set_status(VirtIODevice *vdev, uint8_t status) 625 { 626 VirtIOBlock *s = VIRTIO_BLK(vdev); 627 uint32_t features; 628 629 if (s->dataplane && !(status & (VIRTIO_CONFIG_S_DRIVER | 630 VIRTIO_CONFIG_S_DRIVER_OK))) { 631 virtio_blk_data_plane_stop(s->dataplane); 632 } 633 634 if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) { 635 return; 636 } 637 638 features = vdev->guest_features; 639 640 /* A guest that supports VIRTIO_BLK_F_CONFIG_WCE must be able to send 641 * cache flushes. Thus, the "auto writethrough" behavior is never 642 * necessary for guests that support the VIRTIO_BLK_F_CONFIG_WCE feature. 643 * Leaving it enabled would break the following sequence: 644 * 645 * Guest started with "-drive cache=writethrough" 646 * Guest sets status to 0 647 * Guest sets DRIVER bit in status field 648 * Guest reads host features (WCE=0, CONFIG_WCE=1) 649 * Guest writes guest features (WCE=0, CONFIG_WCE=1) 650 * Guest writes 1 to the WCE configuration field (writeback mode) 651 * Guest sets DRIVER_OK bit in status field 652 * 653 * s->blk would erroneously be placed in writethrough mode. 654 */ 655 if (!(features & (1 << VIRTIO_BLK_F_CONFIG_WCE))) { 656 aio_context_acquire(blk_get_aio_context(s->blk)); 657 blk_set_enable_write_cache(s->blk, 658 !!(features & (1 << VIRTIO_BLK_F_WCE))); 659 aio_context_release(blk_get_aio_context(s->blk)); 660 } 661 } 662 663 static void virtio_blk_save(QEMUFile *f, void *opaque) 664 { 665 VirtIODevice *vdev = VIRTIO_DEVICE(opaque); 666 667 virtio_save(vdev, f); 668 } 669 670 static void virtio_blk_save_device(VirtIODevice *vdev, QEMUFile *f) 671 { 672 VirtIOBlock *s = VIRTIO_BLK(vdev); 673 VirtIOBlockReq *req = s->rq; 674 675 while (req) { 676 qemu_put_sbyte(f, 1); 677 qemu_put_buffer(f, (unsigned char *)&req->elem, 678 sizeof(VirtQueueElement)); 679 req = req->next; 680 } 681 qemu_put_sbyte(f, 0); 682 } 683 684 static int virtio_blk_load(QEMUFile *f, void *opaque, int version_id) 685 { 686 VirtIOBlock *s = opaque; 687 VirtIODevice *vdev = VIRTIO_DEVICE(s); 688 689 if (version_id != 2) 690 return -EINVAL; 691 692 return virtio_load(vdev, f, version_id); 693 } 694 695 static int virtio_blk_load_device(VirtIODevice *vdev, QEMUFile *f, 696 int version_id) 697 { 698 VirtIOBlock *s = VIRTIO_BLK(vdev); 699 700 while (qemu_get_sbyte(f)) { 701 VirtIOBlockReq *req = virtio_blk_alloc_request(s); 702 qemu_get_buffer(f, (unsigned char *)&req->elem, 703 sizeof(VirtQueueElement)); 704 req->next = s->rq; 705 s->rq = req; 706 707 virtqueue_map_sg(req->elem.in_sg, req->elem.in_addr, 708 req->elem.in_num, 1); 709 virtqueue_map_sg(req->elem.out_sg, req->elem.out_addr, 710 req->elem.out_num, 0); 711 } 712 713 return 0; 714 } 715 716 static void virtio_blk_resize(void *opaque) 717 { 718 VirtIODevice *vdev = VIRTIO_DEVICE(opaque); 719 720 virtio_notify_config(vdev); 721 } 722 723 static const BlockDevOps virtio_block_ops = { 724 .resize_cb = virtio_blk_resize, 725 }; 726 727 /* Disable dataplane thread during live migration since it does not 728 * update the dirty memory bitmap yet. 729 */ 730 static void virtio_blk_migration_state_changed(Notifier *notifier, void *data) 731 { 732 VirtIOBlock *s = container_of(notifier, VirtIOBlock, 733 migration_state_notifier); 734 MigrationState *mig = data; 735 Error *err = NULL; 736 737 if (migration_in_setup(mig)) { 738 if (!s->dataplane) { 739 return; 740 } 741 virtio_blk_data_plane_destroy(s->dataplane); 742 s->dataplane = NULL; 743 } else if (migration_has_finished(mig) || 744 migration_has_failed(mig)) { 745 if (s->dataplane) { 746 return; 747 } 748 blk_drain_all(); /* complete in-flight non-dataplane requests */ 749 virtio_blk_data_plane_create(VIRTIO_DEVICE(s), &s->conf, 750 &s->dataplane, &err); 751 if (err != NULL) { 752 error_report("%s", error_get_pretty(err)); 753 error_free(err); 754 } 755 } 756 } 757 758 static void virtio_blk_device_realize(DeviceState *dev, Error **errp) 759 { 760 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 761 VirtIOBlock *s = VIRTIO_BLK(dev); 762 VirtIOBlkConf *conf = &s->conf; 763 Error *err = NULL; 764 static int virtio_blk_id; 765 766 if (!conf->conf.blk) { 767 error_setg(errp, "drive property not set"); 768 return; 769 } 770 if (!blk_is_inserted(conf->conf.blk)) { 771 error_setg(errp, "Device needs media, but drive is empty"); 772 return; 773 } 774 775 blkconf_serial(&conf->conf, &conf->serial); 776 s->original_wce = blk_enable_write_cache(conf->conf.blk); 777 blkconf_geometry(&conf->conf, NULL, 65535, 255, 255, &err); 778 if (err) { 779 error_propagate(errp, err); 780 return; 781 } 782 783 virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, 784 sizeof(struct virtio_blk_config)); 785 786 s->blk = conf->conf.blk; 787 s->rq = NULL; 788 s->sector_mask = (s->conf.conf.logical_block_size / BDRV_SECTOR_SIZE) - 1; 789 790 s->vq = virtio_add_queue(vdev, 128, virtio_blk_handle_output); 791 s->complete_request = virtio_blk_complete_request; 792 virtio_blk_data_plane_create(vdev, conf, &s->dataplane, &err); 793 if (err != NULL) { 794 error_propagate(errp, err); 795 virtio_cleanup(vdev); 796 return; 797 } 798 s->migration_state_notifier.notify = virtio_blk_migration_state_changed; 799 add_migration_state_change_notifier(&s->migration_state_notifier); 800 801 s->change = qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb, s); 802 register_savevm(dev, "virtio-blk", virtio_blk_id++, 2, 803 virtio_blk_save, virtio_blk_load, s); 804 blk_set_dev_ops(s->blk, &virtio_block_ops, s); 805 blk_set_guest_block_size(s->blk, s->conf.conf.logical_block_size); 806 807 blk_iostatus_enable(s->blk); 808 } 809 810 static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp) 811 { 812 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 813 VirtIOBlock *s = VIRTIO_BLK(dev); 814 815 remove_migration_state_change_notifier(&s->migration_state_notifier); 816 virtio_blk_data_plane_destroy(s->dataplane); 817 s->dataplane = NULL; 818 qemu_del_vm_change_state_handler(s->change); 819 unregister_savevm(dev, "virtio-blk", s); 820 blockdev_mark_auto_del(s->blk); 821 virtio_cleanup(vdev); 822 } 823 824 static void virtio_blk_instance_init(Object *obj) 825 { 826 VirtIOBlock *s = VIRTIO_BLK(obj); 827 828 object_property_add_link(obj, "iothread", TYPE_IOTHREAD, 829 (Object **)&s->conf.iothread, 830 qdev_prop_allow_set_link_before_realize, 831 OBJ_PROP_LINK_UNREF_ON_RELEASE, NULL); 832 device_add_bootindex_property(obj, &s->conf.conf.bootindex, 833 "bootindex", "/disk@0,0", 834 DEVICE(obj), NULL); 835 } 836 837 static Property virtio_blk_properties[] = { 838 DEFINE_BLOCK_PROPERTIES(VirtIOBlock, conf.conf), 839 DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock, conf.conf), 840 DEFINE_PROP_STRING("serial", VirtIOBlock, conf.serial), 841 DEFINE_PROP_BIT("config-wce", VirtIOBlock, conf.config_wce, 0, true), 842 #ifdef __linux__ 843 DEFINE_PROP_BIT("scsi", VirtIOBlock, conf.scsi, 0, true), 844 #endif 845 DEFINE_PROP_BIT("x-data-plane", VirtIOBlock, conf.data_plane, 0, false), 846 DEFINE_PROP_END_OF_LIST(), 847 }; 848 849 static void virtio_blk_class_init(ObjectClass *klass, void *data) 850 { 851 DeviceClass *dc = DEVICE_CLASS(klass); 852 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); 853 854 dc->props = virtio_blk_properties; 855 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 856 vdc->realize = virtio_blk_device_realize; 857 vdc->unrealize = virtio_blk_device_unrealize; 858 vdc->get_config = virtio_blk_update_config; 859 vdc->set_config = virtio_blk_set_config; 860 vdc->get_features = virtio_blk_get_features; 861 vdc->set_status = virtio_blk_set_status; 862 vdc->reset = virtio_blk_reset; 863 vdc->save = virtio_blk_save_device; 864 vdc->load = virtio_blk_load_device; 865 } 866 867 static const TypeInfo virtio_device_info = { 868 .name = TYPE_VIRTIO_BLK, 869 .parent = TYPE_VIRTIO_DEVICE, 870 .instance_size = sizeof(VirtIOBlock), 871 .instance_init = virtio_blk_instance_init, 872 .class_init = virtio_blk_class_init, 873 }; 874 875 static void virtio_register_types(void) 876 { 877 type_register_static(&virtio_device_info); 878 } 879 880 type_init(virtio_register_types) 881