1 /* 2 * Sharing QEMU block devices via vhost-user protocal 3 * 4 * Parts of the code based on nbd/server.c. 5 * 6 * Copyright (c) Coiby Xu <coiby.xu@gmail.com>. 7 * Copyright (c) 2020 Red Hat, Inc. 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2 or 10 * later. See the COPYING file in the top-level directory. 11 */ 12 #include "qemu/osdep.h" 13 #include "block/block.h" 14 #include "subprojects/libvhost-user/libvhost-user.h" /* only for the type definitions */ 15 #include "standard-headers/linux/virtio_blk.h" 16 #include "qemu/vhost-user-server.h" 17 #include "vhost-user-blk-server.h" 18 #include "qapi/error.h" 19 #include "qom/object_interfaces.h" 20 #include "sysemu/block-backend.h" 21 #include "util/block-helpers.h" 22 23 /* 24 * Sector units are 512 bytes regardless of the 25 * virtio_blk_config->blk_size value. 26 */ 27 #define VIRTIO_BLK_SECTOR_BITS 9 28 #define VIRTIO_BLK_SECTOR_SIZE (1ull << VIRTIO_BLK_SECTOR_BITS) 29 30 enum { 31 VHOST_USER_BLK_NUM_QUEUES_DEFAULT = 1, 32 VHOST_USER_BLK_MAX_DISCARD_SECTORS = 32768, 33 VHOST_USER_BLK_MAX_WRITE_ZEROES_SECTORS = 32768, 34 }; 35 struct virtio_blk_inhdr { 36 unsigned char status; 37 }; 38 39 typedef struct VuBlkReq { 40 VuVirtqElement elem; 41 int64_t sector_num; 42 size_t size; 43 struct virtio_blk_inhdr *in; 44 struct virtio_blk_outhdr out; 45 VuServer *server; 46 struct VuVirtq *vq; 47 } VuBlkReq; 48 49 /* vhost user block device */ 50 typedef struct { 51 BlockExport export; 52 VuServer vu_server; 53 uint32_t blk_size; 54 QIOChannelSocket *sioc; 55 struct virtio_blk_config blkcfg; 56 bool writable; 57 } VuBlkExport; 58 59 static void vu_blk_req_complete(VuBlkReq *req) 60 { 61 VuDev *vu_dev = &req->server->vu_dev; 62 63 /* IO size with 1 extra status byte */ 64 vu_queue_push(vu_dev, req->vq, &req->elem, req->size + 1); 65 vu_queue_notify(vu_dev, req->vq); 66 67 free(req); 68 } 69 70 static bool vu_blk_sect_range_ok(VuBlkExport *vexp, uint64_t sector, 71 size_t size) 72 { 73 uint64_t nb_sectors; 74 uint64_t total_sectors; 75 76 if (size % VIRTIO_BLK_SECTOR_SIZE) { 77 return false; 78 } 79 80 nb_sectors = size >> VIRTIO_BLK_SECTOR_BITS; 81 82 QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != VIRTIO_BLK_SECTOR_SIZE); 83 if (nb_sectors > BDRV_REQUEST_MAX_SECTORS) { 84 return false; 85 } 86 if ((sector << VIRTIO_BLK_SECTOR_BITS) % vexp->blk_size) { 87 return false; 88 } 89 blk_get_geometry(vexp->export.blk, &total_sectors); 90 if (sector > total_sectors || nb_sectors > total_sectors - sector) { 91 return false; 92 } 93 return true; 94 } 95 96 static int coroutine_fn 97 vu_blk_discard_write_zeroes(VuBlkExport *vexp, struct iovec *iov, 98 uint32_t iovcnt, uint32_t type) 99 { 100 BlockBackend *blk = vexp->export.blk; 101 struct virtio_blk_discard_write_zeroes desc; 102 ssize_t size; 103 uint64_t sector; 104 uint32_t num_sectors; 105 uint32_t max_sectors; 106 uint32_t flags; 107 int bytes; 108 109 /* Only one desc is currently supported */ 110 if (unlikely(iov_size(iov, iovcnt) > sizeof(desc))) { 111 return VIRTIO_BLK_S_UNSUPP; 112 } 113 114 size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc)); 115 if (unlikely(size != sizeof(desc))) { 116 error_report("Invalid size %zd, expected %zu", size, sizeof(desc)); 117 return VIRTIO_BLK_S_IOERR; 118 } 119 120 sector = le64_to_cpu(desc.sector); 121 num_sectors = le32_to_cpu(desc.num_sectors); 122 flags = le32_to_cpu(desc.flags); 123 max_sectors = (type == VIRTIO_BLK_T_WRITE_ZEROES) ? 124 VHOST_USER_BLK_MAX_WRITE_ZEROES_SECTORS : 125 VHOST_USER_BLK_MAX_DISCARD_SECTORS; 126 127 /* This check ensures that 'bytes' fits in an int */ 128 if (unlikely(num_sectors > max_sectors)) { 129 return VIRTIO_BLK_S_IOERR; 130 } 131 132 bytes = num_sectors << VIRTIO_BLK_SECTOR_BITS; 133 134 if (unlikely(!vu_blk_sect_range_ok(vexp, sector, bytes))) { 135 return VIRTIO_BLK_S_IOERR; 136 } 137 138 /* 139 * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for discard 140 * and write zeroes commands if any unknown flag is set. 141 */ 142 if (unlikely(flags & ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) { 143 return VIRTIO_BLK_S_UNSUPP; 144 } 145 146 if (type == VIRTIO_BLK_T_WRITE_ZEROES) { 147 int blk_flags = 0; 148 149 if (flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP) { 150 blk_flags |= BDRV_REQ_MAY_UNMAP; 151 } 152 153 if (blk_co_pwrite_zeroes(blk, sector << VIRTIO_BLK_SECTOR_BITS, 154 bytes, blk_flags) == 0) { 155 return VIRTIO_BLK_S_OK; 156 } 157 } else if (type == VIRTIO_BLK_T_DISCARD) { 158 /* 159 * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for 160 * discard commands if the unmap flag is set. 161 */ 162 if (unlikely(flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) { 163 return VIRTIO_BLK_S_UNSUPP; 164 } 165 166 if (blk_co_pdiscard(blk, sector << VIRTIO_BLK_SECTOR_BITS, 167 bytes) == 0) { 168 return VIRTIO_BLK_S_OK; 169 } 170 } 171 172 return VIRTIO_BLK_S_IOERR; 173 } 174 175 /* Called with server refcount increased, must decrease before returning */ 176 static void coroutine_fn vu_blk_virtio_process_req(void *opaque) 177 { 178 VuBlkReq *req = opaque; 179 VuServer *server = req->server; 180 VuVirtqElement *elem = &req->elem; 181 uint32_t type; 182 183 VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server); 184 BlockBackend *blk = vexp->export.blk; 185 186 struct iovec *in_iov = elem->in_sg; 187 struct iovec *out_iov = elem->out_sg; 188 unsigned in_num = elem->in_num; 189 unsigned out_num = elem->out_num; 190 191 /* refer to hw/block/virtio_blk.c */ 192 if (elem->out_num < 1 || elem->in_num < 1) { 193 error_report("virtio-blk request missing headers"); 194 goto err; 195 } 196 197 if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out, 198 sizeof(req->out)) != sizeof(req->out))) { 199 error_report("virtio-blk request outhdr too short"); 200 goto err; 201 } 202 203 iov_discard_front(&out_iov, &out_num, sizeof(req->out)); 204 205 if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) { 206 error_report("virtio-blk request inhdr too short"); 207 goto err; 208 } 209 210 /* We always touch the last byte, so just see how big in_iov is. */ 211 req->in = (void *)in_iov[in_num - 1].iov_base 212 + in_iov[in_num - 1].iov_len 213 - sizeof(struct virtio_blk_inhdr); 214 iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr)); 215 216 type = le32_to_cpu(req->out.type); 217 switch (type & ~VIRTIO_BLK_T_BARRIER) { 218 case VIRTIO_BLK_T_IN: 219 case VIRTIO_BLK_T_OUT: { 220 QEMUIOVector qiov; 221 int64_t offset; 222 ssize_t ret = 0; 223 bool is_write = type & VIRTIO_BLK_T_OUT; 224 req->sector_num = le64_to_cpu(req->out.sector); 225 226 if (is_write && !vexp->writable) { 227 req->in->status = VIRTIO_BLK_S_IOERR; 228 break; 229 } 230 231 if (is_write) { 232 qemu_iovec_init_external(&qiov, out_iov, out_num); 233 } else { 234 qemu_iovec_init_external(&qiov, in_iov, in_num); 235 } 236 237 if (unlikely(!vu_blk_sect_range_ok(vexp, 238 req->sector_num, 239 qiov.size))) { 240 req->in->status = VIRTIO_BLK_S_IOERR; 241 break; 242 } 243 244 offset = req->sector_num << VIRTIO_BLK_SECTOR_BITS; 245 246 if (is_write) { 247 ret = blk_co_pwritev(blk, offset, qiov.size, &qiov, 0); 248 } else { 249 ret = blk_co_preadv(blk, offset, qiov.size, &qiov, 0); 250 } 251 if (ret >= 0) { 252 req->in->status = VIRTIO_BLK_S_OK; 253 } else { 254 req->in->status = VIRTIO_BLK_S_IOERR; 255 } 256 break; 257 } 258 case VIRTIO_BLK_T_FLUSH: 259 if (blk_co_flush(blk) == 0) { 260 req->in->status = VIRTIO_BLK_S_OK; 261 } else { 262 req->in->status = VIRTIO_BLK_S_IOERR; 263 } 264 break; 265 case VIRTIO_BLK_T_GET_ID: { 266 size_t size = MIN(iov_size(&elem->in_sg[0], in_num), 267 VIRTIO_BLK_ID_BYTES); 268 snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk"); 269 req->in->status = VIRTIO_BLK_S_OK; 270 req->size = elem->in_sg[0].iov_len; 271 break; 272 } 273 case VIRTIO_BLK_T_DISCARD: 274 case VIRTIO_BLK_T_WRITE_ZEROES: { 275 if (!vexp->writable) { 276 req->in->status = VIRTIO_BLK_S_IOERR; 277 break; 278 } 279 280 req->in->status = vu_blk_discard_write_zeroes(vexp, out_iov, out_num, 281 type); 282 break; 283 } 284 default: 285 req->in->status = VIRTIO_BLK_S_UNSUPP; 286 break; 287 } 288 289 vu_blk_req_complete(req); 290 vhost_user_server_unref(server); 291 return; 292 293 err: 294 free(req); 295 vhost_user_server_unref(server); 296 } 297 298 static void vu_blk_process_vq(VuDev *vu_dev, int idx) 299 { 300 VuServer *server = container_of(vu_dev, VuServer, vu_dev); 301 VuVirtq *vq = vu_get_queue(vu_dev, idx); 302 303 while (1) { 304 VuBlkReq *req; 305 306 req = vu_queue_pop(vu_dev, vq, sizeof(VuBlkReq)); 307 if (!req) { 308 break; 309 } 310 311 req->server = server; 312 req->vq = vq; 313 314 Coroutine *co = 315 qemu_coroutine_create(vu_blk_virtio_process_req, req); 316 317 vhost_user_server_ref(server); 318 qemu_coroutine_enter(co); 319 } 320 } 321 322 static void vu_blk_queue_set_started(VuDev *vu_dev, int idx, bool started) 323 { 324 VuVirtq *vq; 325 326 assert(vu_dev); 327 328 vq = vu_get_queue(vu_dev, idx); 329 vu_set_queue_handler(vu_dev, vq, started ? vu_blk_process_vq : NULL); 330 } 331 332 static uint64_t vu_blk_get_features(VuDev *dev) 333 { 334 uint64_t features; 335 VuServer *server = container_of(dev, VuServer, vu_dev); 336 VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server); 337 features = 1ull << VIRTIO_BLK_F_SIZE_MAX | 338 1ull << VIRTIO_BLK_F_SEG_MAX | 339 1ull << VIRTIO_BLK_F_TOPOLOGY | 340 1ull << VIRTIO_BLK_F_BLK_SIZE | 341 1ull << VIRTIO_BLK_F_FLUSH | 342 1ull << VIRTIO_BLK_F_DISCARD | 343 1ull << VIRTIO_BLK_F_WRITE_ZEROES | 344 1ull << VIRTIO_BLK_F_CONFIG_WCE | 345 1ull << VIRTIO_BLK_F_MQ | 346 1ull << VIRTIO_F_VERSION_1 | 347 1ull << VIRTIO_RING_F_INDIRECT_DESC | 348 1ull << VIRTIO_RING_F_EVENT_IDX | 349 1ull << VHOST_USER_F_PROTOCOL_FEATURES; 350 351 if (!vexp->writable) { 352 features |= 1ull << VIRTIO_BLK_F_RO; 353 } 354 355 return features; 356 } 357 358 static uint64_t vu_blk_get_protocol_features(VuDev *dev) 359 { 360 return 1ull << VHOST_USER_PROTOCOL_F_CONFIG; 361 } 362 363 static int 364 vu_blk_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len) 365 { 366 VuServer *server = container_of(vu_dev, VuServer, vu_dev); 367 VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server); 368 369 if (len > sizeof(struct virtio_blk_config)) { 370 return -1; 371 } 372 373 memcpy(config, &vexp->blkcfg, len); 374 return 0; 375 } 376 377 static int 378 vu_blk_set_config(VuDev *vu_dev, const uint8_t *data, 379 uint32_t offset, uint32_t size, uint32_t flags) 380 { 381 VuServer *server = container_of(vu_dev, VuServer, vu_dev); 382 VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server); 383 uint8_t wce; 384 385 /* don't support live migration */ 386 if (flags != VHOST_SET_CONFIG_TYPE_MASTER) { 387 return -EINVAL; 388 } 389 390 if (offset != offsetof(struct virtio_blk_config, wce) || 391 size != 1) { 392 return -EINVAL; 393 } 394 395 wce = *data; 396 vexp->blkcfg.wce = wce; 397 blk_set_enable_write_cache(vexp->export.blk, wce); 398 return 0; 399 } 400 401 /* 402 * When the client disconnects, it sends a VHOST_USER_NONE request 403 * and vu_process_message will simple call exit which cause the VM 404 * to exit abruptly. 405 * To avoid this issue, process VHOST_USER_NONE request ahead 406 * of vu_process_message. 407 * 408 */ 409 static int vu_blk_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply) 410 { 411 if (vmsg->request == VHOST_USER_NONE) { 412 dev->panic(dev, "disconnect"); 413 return true; 414 } 415 return false; 416 } 417 418 static const VuDevIface vu_blk_iface = { 419 .get_features = vu_blk_get_features, 420 .queue_set_started = vu_blk_queue_set_started, 421 .get_protocol_features = vu_blk_get_protocol_features, 422 .get_config = vu_blk_get_config, 423 .set_config = vu_blk_set_config, 424 .process_msg = vu_blk_process_msg, 425 }; 426 427 static void blk_aio_attached(AioContext *ctx, void *opaque) 428 { 429 VuBlkExport *vexp = opaque; 430 431 vexp->export.ctx = ctx; 432 vhost_user_server_attach_aio_context(&vexp->vu_server, ctx); 433 } 434 435 static void blk_aio_detach(void *opaque) 436 { 437 VuBlkExport *vexp = opaque; 438 439 vhost_user_server_detach_aio_context(&vexp->vu_server); 440 vexp->export.ctx = NULL; 441 } 442 443 static void 444 vu_blk_initialize_config(BlockDriverState *bs, 445 struct virtio_blk_config *config, 446 uint32_t blk_size, 447 uint16_t num_queues) 448 { 449 config->capacity = 450 cpu_to_le64(bdrv_getlength(bs) >> VIRTIO_BLK_SECTOR_BITS); 451 config->blk_size = cpu_to_le32(blk_size); 452 config->size_max = cpu_to_le32(0); 453 config->seg_max = cpu_to_le32(128 - 2); 454 config->min_io_size = cpu_to_le16(1); 455 config->opt_io_size = cpu_to_le32(1); 456 config->num_queues = cpu_to_le16(num_queues); 457 config->max_discard_sectors = 458 cpu_to_le32(VHOST_USER_BLK_MAX_DISCARD_SECTORS); 459 config->max_discard_seg = cpu_to_le32(1); 460 config->discard_sector_alignment = 461 cpu_to_le32(blk_size >> VIRTIO_BLK_SECTOR_BITS); 462 config->max_write_zeroes_sectors 463 = cpu_to_le32(VHOST_USER_BLK_MAX_WRITE_ZEROES_SECTORS); 464 config->max_write_zeroes_seg = cpu_to_le32(1); 465 } 466 467 static void vu_blk_exp_request_shutdown(BlockExport *exp) 468 { 469 VuBlkExport *vexp = container_of(exp, VuBlkExport, export); 470 471 vhost_user_server_stop(&vexp->vu_server); 472 } 473 474 static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts, 475 Error **errp) 476 { 477 VuBlkExport *vexp = container_of(exp, VuBlkExport, export); 478 BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk; 479 Error *local_err = NULL; 480 uint64_t logical_block_size; 481 uint16_t num_queues = VHOST_USER_BLK_NUM_QUEUES_DEFAULT; 482 483 vexp->writable = opts->writable; 484 vexp->blkcfg.wce = 0; 485 486 if (vu_opts->has_logical_block_size) { 487 logical_block_size = vu_opts->logical_block_size; 488 } else { 489 logical_block_size = VIRTIO_BLK_SECTOR_SIZE; 490 } 491 check_block_size(exp->id, "logical-block-size", logical_block_size, 492 &local_err); 493 if (local_err) { 494 error_propagate(errp, local_err); 495 return -EINVAL; 496 } 497 vexp->blk_size = logical_block_size; 498 blk_set_guest_block_size(exp->blk, logical_block_size); 499 500 if (vu_opts->has_num_queues) { 501 num_queues = vu_opts->num_queues; 502 } 503 if (num_queues == 0) { 504 error_setg(errp, "num-queues must be greater than 0"); 505 return -EINVAL; 506 } 507 508 vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg, 509 logical_block_size, num_queues); 510 511 blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach, 512 vexp); 513 514 if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx, 515 num_queues, &vu_blk_iface, errp)) { 516 blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, 517 blk_aio_detach, vexp); 518 return -EADDRNOTAVAIL; 519 } 520 521 return 0; 522 } 523 524 static void vu_blk_exp_delete(BlockExport *exp) 525 { 526 VuBlkExport *vexp = container_of(exp, VuBlkExport, export); 527 528 blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach, 529 vexp); 530 } 531 532 const BlockExportDriver blk_exp_vhost_user_blk = { 533 .type = BLOCK_EXPORT_TYPE_VHOST_USER_BLK, 534 .instance_size = sizeof(VuBlkExport), 535 .create = vu_blk_exp_create, 536 .delete = vu_blk_exp_delete, 537 .request_shutdown = vu_blk_exp_request_shutdown, 538 }; 539