1 /* 2 * vhost-user-blk sample application 3 * 4 * Copyright (c) 2017 Intel Corporation. All rights reserved. 5 * 6 * Author: 7 * Changpeng Liu <changpeng.liu@intel.com> 8 * 9 * This work is based on the "vhost-user-scsi" sample and "virtio-blk" driver 10 * implementation by: 11 * Felipe Franciosi <felipe@nutanix.com> 12 * Anthony Liguori <aliguori@us.ibm.com> 13 * 14 * This work is licensed under the terms of the GNU GPL, version 2 only. 15 * See the COPYING file in the top-level directory. 16 */ 17 18 #include "qemu/osdep.h" 19 #include "standard-headers/linux/virtio_blk.h" 20 #include "contrib/libvhost-user/libvhost-user-glib.h" 21 #include "contrib/libvhost-user/libvhost-user.h" 22 23 #if defined(__linux__) 24 #include <linux/fs.h> 25 #include <sys/ioctl.h> 26 #endif 27 28 enum { 29 VHOST_USER_BLK_MAX_QUEUES = 8, 30 }; 31 32 struct virtio_blk_inhdr { 33 unsigned char status; 34 }; 35 36 /* vhost user block device */ 37 typedef struct VubDev { 38 VugDev parent; 39 int blk_fd; 40 struct virtio_blk_config blkcfg; 41 bool enable_ro; 42 char *blk_name; 43 GMainLoop *loop; 44 } VubDev; 45 46 typedef struct VubReq { 47 VuVirtqElement *elem; 48 int64_t sector_num; 49 size_t size; 50 struct virtio_blk_inhdr *in; 51 struct virtio_blk_outhdr *out; 52 VubDev *vdev_blk; 53 struct VuVirtq *vq; 54 } VubReq; 55 56 /* refer util/iov.c */ 57 static size_t vub_iov_size(const struct iovec *iov, 58 const unsigned int iov_cnt) 59 { 60 size_t len; 61 unsigned int i; 62 63 len = 0; 64 for (i = 0; i < iov_cnt; i++) { 65 len += iov[i].iov_len; 66 } 67 return len; 68 } 69 70 static size_t vub_iov_to_buf(const struct iovec *iov, 71 const unsigned int iov_cnt, void *buf) 72 { 73 size_t len; 74 unsigned int i; 75 76 len = 0; 77 for (i = 0; i < iov_cnt; i++) { 78 memcpy(buf + len, iov[i].iov_base, iov[i].iov_len); 79 len += iov[i].iov_len; 80 } 81 return len; 82 } 83 84 static void vub_panic_cb(VuDev *vu_dev, const char *buf) 85 { 86 VugDev *gdev; 87 VubDev *vdev_blk; 88 89 assert(vu_dev); 90 91 gdev = container_of(vu_dev, VugDev, parent); 92 vdev_blk = container_of(gdev, VubDev, parent); 93 if (buf) { 94 g_warning("vu_panic: %s", buf); 95 } 96 97 g_main_loop_quit(vdev_blk->loop); 98 } 99 100 static void vub_req_complete(VubReq *req) 101 { 102 VugDev *gdev = &req->vdev_blk->parent; 103 VuDev *vu_dev = &gdev->parent; 104 105 /* IO size with 1 extra status byte */ 106 vu_queue_push(vu_dev, req->vq, req->elem, 107 req->size + 1); 108 vu_queue_notify(vu_dev, req->vq); 109 110 if (req->elem) { 111 free(req->elem); 112 } 113 114 g_free(req); 115 } 116 117 static int vub_open(const char *file_name, bool wce) 118 { 119 int fd; 120 int flags = O_RDWR; 121 122 if (!wce) { 123 flags |= O_DIRECT; 124 } 125 126 fd = open(file_name, flags); 127 if (fd < 0) { 128 fprintf(stderr, "Cannot open file %s, %s\n", file_name, 129 strerror(errno)); 130 return -1; 131 } 132 133 return fd; 134 } 135 136 static ssize_t 137 vub_readv(VubReq *req, struct iovec *iov, uint32_t iovcnt) 138 { 139 VubDev *vdev_blk = req->vdev_blk; 140 ssize_t rc; 141 142 if (!iovcnt) { 143 fprintf(stderr, "Invalid Read IOV count\n"); 144 return -1; 145 } 146 147 req->size = vub_iov_size(iov, iovcnt); 148 rc = preadv(vdev_blk->blk_fd, iov, iovcnt, req->sector_num * 512); 149 if (rc < 0) { 150 fprintf(stderr, "%s, Sector %"PRIu64", Size %lu failed with %s\n", 151 vdev_blk->blk_name, req->sector_num, req->size, 152 strerror(errno)); 153 return -1; 154 } 155 156 return rc; 157 } 158 159 static ssize_t 160 vub_writev(VubReq *req, struct iovec *iov, uint32_t iovcnt) 161 { 162 VubDev *vdev_blk = req->vdev_blk; 163 ssize_t rc; 164 165 if (!iovcnt) { 166 fprintf(stderr, "Invalid Write IOV count\n"); 167 return -1; 168 } 169 170 req->size = vub_iov_size(iov, iovcnt); 171 rc = pwritev(vdev_blk->blk_fd, iov, iovcnt, req->sector_num * 512); 172 if (rc < 0) { 173 fprintf(stderr, "%s, Sector %"PRIu64", Size %lu failed with %s\n", 174 vdev_blk->blk_name, req->sector_num, req->size, 175 strerror(errno)); 176 return -1; 177 } 178 179 return rc; 180 } 181 182 static int 183 vub_discard_write_zeroes(VubReq *req, struct iovec *iov, uint32_t iovcnt, 184 uint32_t type) 185 { 186 struct virtio_blk_discard_write_zeroes *desc; 187 ssize_t size; 188 void *buf; 189 190 size = vub_iov_size(iov, iovcnt); 191 if (size != sizeof(*desc)) { 192 fprintf(stderr, "Invalid size %ld, expect %ld\n", size, sizeof(*desc)); 193 return -1; 194 } 195 buf = g_new0(char, size); 196 vub_iov_to_buf(iov, iovcnt, buf); 197 198 #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT) 199 VubDev *vdev_blk = req->vdev_blk; 200 desc = (struct virtio_blk_discard_write_zeroes *)buf; 201 uint64_t range[2] = { le64toh(desc->sector) << 9, 202 le32toh(desc->num_sectors) << 9 }; 203 if (type == VIRTIO_BLK_T_DISCARD) { 204 if (ioctl(vdev_blk->blk_fd, BLKDISCARD, range) == 0) { 205 g_free(buf); 206 return 0; 207 } 208 } else if (type == VIRTIO_BLK_T_WRITE_ZEROES) { 209 if (ioctl(vdev_blk->blk_fd, BLKZEROOUT, range) == 0) { 210 g_free(buf); 211 return 0; 212 } 213 } 214 #endif 215 216 g_free(buf); 217 return -1; 218 } 219 220 static void 221 vub_flush(VubReq *req) 222 { 223 VubDev *vdev_blk = req->vdev_blk; 224 225 fdatasync(vdev_blk->blk_fd); 226 } 227 228 static int vub_virtio_process_req(VubDev *vdev_blk, 229 VuVirtq *vq) 230 { 231 VugDev *gdev = &vdev_blk->parent; 232 VuDev *vu_dev = &gdev->parent; 233 VuVirtqElement *elem; 234 uint32_t type; 235 unsigned in_num; 236 unsigned out_num; 237 VubReq *req; 238 239 elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) + sizeof(VubReq)); 240 if (!elem) { 241 return -1; 242 } 243 244 /* refer to hw/block/virtio_blk.c */ 245 if (elem->out_num < 1 || elem->in_num < 1) { 246 fprintf(stderr, "virtio-blk request missing headers\n"); 247 free(elem); 248 return -1; 249 } 250 251 req = g_new0(VubReq, 1); 252 req->vdev_blk = vdev_blk; 253 req->vq = vq; 254 req->elem = elem; 255 256 in_num = elem->in_num; 257 out_num = elem->out_num; 258 259 /* don't support VIRTIO_F_ANY_LAYOUT and virtio 1.0 only */ 260 if (elem->out_sg[0].iov_len < sizeof(struct virtio_blk_outhdr)) { 261 fprintf(stderr, "Invalid outhdr size\n"); 262 goto err; 263 } 264 req->out = (struct virtio_blk_outhdr *)elem->out_sg[0].iov_base; 265 out_num--; 266 267 if (elem->in_sg[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) { 268 fprintf(stderr, "Invalid inhdr size\n"); 269 goto err; 270 } 271 req->in = (struct virtio_blk_inhdr *)elem->in_sg[in_num - 1].iov_base; 272 in_num--; 273 274 type = le32toh(req->out->type); 275 switch (type & ~VIRTIO_BLK_T_BARRIER) { 276 case VIRTIO_BLK_T_IN: 277 case VIRTIO_BLK_T_OUT: { 278 ssize_t ret = 0; 279 bool is_write = type & VIRTIO_BLK_T_OUT; 280 req->sector_num = le64toh(req->out->sector); 281 if (is_write) { 282 ret = vub_writev(req, &elem->out_sg[1], out_num); 283 } else { 284 ret = vub_readv(req, &elem->in_sg[0], in_num); 285 } 286 if (ret >= 0) { 287 req->in->status = VIRTIO_BLK_S_OK; 288 } else { 289 req->in->status = VIRTIO_BLK_S_IOERR; 290 } 291 vub_req_complete(req); 292 break; 293 } 294 case VIRTIO_BLK_T_FLUSH: 295 vub_flush(req); 296 req->in->status = VIRTIO_BLK_S_OK; 297 vub_req_complete(req); 298 break; 299 case VIRTIO_BLK_T_GET_ID: { 300 size_t size = MIN(vub_iov_size(&elem->in_sg[0], in_num), 301 VIRTIO_BLK_ID_BYTES); 302 snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk"); 303 req->in->status = VIRTIO_BLK_S_OK; 304 req->size = elem->in_sg[0].iov_len; 305 vub_req_complete(req); 306 break; 307 } 308 case VIRTIO_BLK_T_DISCARD: 309 case VIRTIO_BLK_T_WRITE_ZEROES: { 310 int rc; 311 rc = vub_discard_write_zeroes(req, &elem->out_sg[1], out_num, type); 312 if (rc == 0) { 313 req->in->status = VIRTIO_BLK_S_OK; 314 } else { 315 req->in->status = VIRTIO_BLK_S_IOERR; 316 } 317 vub_req_complete(req); 318 break; 319 } 320 default: 321 req->in->status = VIRTIO_BLK_S_UNSUPP; 322 vub_req_complete(req); 323 break; 324 } 325 326 return 0; 327 328 err: 329 free(elem); 330 g_free(req); 331 return -1; 332 } 333 334 static void vub_process_vq(VuDev *vu_dev, int idx) 335 { 336 VugDev *gdev; 337 VubDev *vdev_blk; 338 VuVirtq *vq; 339 int ret; 340 341 gdev = container_of(vu_dev, VugDev, parent); 342 vdev_blk = container_of(gdev, VubDev, parent); 343 assert(vdev_blk); 344 345 vq = vu_get_queue(vu_dev, idx); 346 assert(vq); 347 348 while (1) { 349 ret = vub_virtio_process_req(vdev_blk, vq); 350 if (ret) { 351 break; 352 } 353 } 354 } 355 356 static void vub_queue_set_started(VuDev *vu_dev, int idx, bool started) 357 { 358 VuVirtq *vq; 359 360 assert(vu_dev); 361 362 vq = vu_get_queue(vu_dev, idx); 363 vu_set_queue_handler(vu_dev, vq, started ? vub_process_vq : NULL); 364 } 365 366 static uint64_t 367 vub_get_features(VuDev *dev) 368 { 369 uint64_t features; 370 VugDev *gdev; 371 VubDev *vdev_blk; 372 373 gdev = container_of(dev, VugDev, parent); 374 vdev_blk = container_of(gdev, VubDev, parent); 375 376 features = 1ull << VIRTIO_BLK_F_SIZE_MAX | 377 1ull << VIRTIO_BLK_F_SEG_MAX | 378 1ull << VIRTIO_BLK_F_TOPOLOGY | 379 1ull << VIRTIO_BLK_F_BLK_SIZE | 380 1ull << VIRTIO_BLK_F_FLUSH | 381 #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT) 382 1ull << VIRTIO_BLK_F_DISCARD | 383 1ull << VIRTIO_BLK_F_WRITE_ZEROES | 384 #endif 385 1ull << VIRTIO_BLK_F_CONFIG_WCE | 386 1ull << VIRTIO_F_VERSION_1 | 387 1ull << VHOST_USER_F_PROTOCOL_FEATURES; 388 389 if (vdev_blk->enable_ro) { 390 features |= 1ull << VIRTIO_BLK_F_RO; 391 } 392 393 return features; 394 } 395 396 static uint64_t 397 vub_get_protocol_features(VuDev *dev) 398 { 399 return 1ull << VHOST_USER_PROTOCOL_F_CONFIG | 400 1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD; 401 } 402 403 static int 404 vub_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len) 405 { 406 VugDev *gdev; 407 VubDev *vdev_blk; 408 409 gdev = container_of(vu_dev, VugDev, parent); 410 vdev_blk = container_of(gdev, VubDev, parent); 411 memcpy(config, &vdev_blk->blkcfg, len); 412 413 return 0; 414 } 415 416 static int 417 vub_set_config(VuDev *vu_dev, const uint8_t *data, 418 uint32_t offset, uint32_t size, uint32_t flags) 419 { 420 VugDev *gdev; 421 VubDev *vdev_blk; 422 uint8_t wce; 423 int fd; 424 425 /* don't support live migration */ 426 if (flags != VHOST_SET_CONFIG_TYPE_MASTER) { 427 return -1; 428 } 429 430 gdev = container_of(vu_dev, VugDev, parent); 431 vdev_blk = container_of(gdev, VubDev, parent); 432 433 if (offset != offsetof(struct virtio_blk_config, wce) || 434 size != 1) { 435 return -1; 436 } 437 438 wce = *data; 439 if (wce == vdev_blk->blkcfg.wce) { 440 /* Do nothing as same with old configuration */ 441 return 0; 442 } 443 444 vdev_blk->blkcfg.wce = wce; 445 fprintf(stdout, "Write Cache Policy Changed\n"); 446 if (vdev_blk->blk_fd >= 0) { 447 close(vdev_blk->blk_fd); 448 vdev_blk->blk_fd = -1; 449 } 450 451 fd = vub_open(vdev_blk->blk_name, wce); 452 if (fd < 0) { 453 fprintf(stderr, "Error to open block device %s\n", vdev_blk->blk_name); 454 vdev_blk->blk_fd = -1; 455 return -1; 456 } 457 vdev_blk->blk_fd = fd; 458 459 return 0; 460 } 461 462 static const VuDevIface vub_iface = { 463 .get_features = vub_get_features, 464 .queue_set_started = vub_queue_set_started, 465 .get_protocol_features = vub_get_protocol_features, 466 .get_config = vub_get_config, 467 .set_config = vub_set_config, 468 }; 469 470 static int unix_sock_new(char *unix_fn) 471 { 472 int sock; 473 struct sockaddr_un un; 474 size_t len; 475 476 assert(unix_fn); 477 478 sock = socket(AF_UNIX, SOCK_STREAM, 0); 479 if (sock <= 0) { 480 perror("socket"); 481 return -1; 482 } 483 484 un.sun_family = AF_UNIX; 485 (void)snprintf(un.sun_path, sizeof(un.sun_path), "%s", unix_fn); 486 len = sizeof(un.sun_family) + strlen(un.sun_path); 487 488 (void)unlink(unix_fn); 489 if (bind(sock, (struct sockaddr *)&un, len) < 0) { 490 perror("bind"); 491 goto fail; 492 } 493 494 if (listen(sock, 1) < 0) { 495 perror("listen"); 496 goto fail; 497 } 498 499 return sock; 500 501 fail: 502 (void)close(sock); 503 504 return -1; 505 } 506 507 static void vub_free(struct VubDev *vdev_blk) 508 { 509 if (!vdev_blk) { 510 return; 511 } 512 513 g_main_loop_unref(vdev_blk->loop); 514 if (vdev_blk->blk_fd >= 0) { 515 close(vdev_blk->blk_fd); 516 } 517 g_free(vdev_blk); 518 } 519 520 static uint32_t 521 vub_get_blocksize(int fd) 522 { 523 uint32_t blocksize = 512; 524 525 #if defined(__linux__) && defined(BLKSSZGET) 526 if (ioctl(fd, BLKSSZGET, &blocksize) == 0) { 527 return blocksize; 528 } 529 #endif 530 531 return blocksize; 532 } 533 534 static void 535 vub_initialize_config(int fd, struct virtio_blk_config *config) 536 { 537 off64_t capacity; 538 539 capacity = lseek64(fd, 0, SEEK_END); 540 config->capacity = capacity >> 9; 541 config->blk_size = vub_get_blocksize(fd); 542 config->size_max = 65536; 543 config->seg_max = 128 - 2; 544 config->min_io_size = 1; 545 config->opt_io_size = 1; 546 config->num_queues = 1; 547 #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT) 548 config->max_discard_sectors = 32768; 549 config->max_discard_seg = 1; 550 config->discard_sector_alignment = config->blk_size >> 9; 551 config->max_write_zeroes_sectors = 32768; 552 config->max_write_zeroes_seg = 1; 553 #endif 554 } 555 556 static VubDev * 557 vub_new(char *blk_file) 558 { 559 VubDev *vdev_blk; 560 561 vdev_blk = g_new0(VubDev, 1); 562 vdev_blk->loop = g_main_loop_new(NULL, FALSE); 563 vdev_blk->blk_fd = vub_open(blk_file, 0); 564 if (vdev_blk->blk_fd < 0) { 565 fprintf(stderr, "Error to open block device %s\n", blk_file); 566 vub_free(vdev_blk); 567 return NULL; 568 } 569 vdev_blk->enable_ro = false; 570 vdev_blk->blkcfg.wce = 0; 571 vdev_blk->blk_name = blk_file; 572 573 /* fill virtio_blk_config with block parameters */ 574 vub_initialize_config(vdev_blk->blk_fd, &vdev_blk->blkcfg); 575 576 return vdev_blk; 577 } 578 579 static int opt_fdnum = -1; 580 static char *opt_socket_path; 581 static char *opt_blk_file; 582 static gboolean opt_print_caps; 583 static gboolean opt_read_only; 584 585 static GOptionEntry entries[] = { 586 { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &opt_print_caps, 587 "Print capabilities", NULL }, 588 { "fd", 'f', 0, G_OPTION_ARG_INT, &opt_fdnum, 589 "Use inherited fd socket", "FDNUM" }, 590 { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &opt_socket_path, 591 "Use UNIX socket path", "PATH" }, 592 {"blk-file", 'b', 0, G_OPTION_ARG_FILENAME, &opt_blk_file, 593 "block device or file path", "PATH"}, 594 { "read-only", 'r', 0, G_OPTION_ARG_NONE, &opt_read_only, 595 "Enable read-only", NULL } 596 }; 597 598 int main(int argc, char **argv) 599 { 600 int lsock = -1, csock = -1; 601 VubDev *vdev_blk = NULL; 602 GError *error = NULL; 603 GOptionContext *context; 604 605 context = g_option_context_new(NULL); 606 g_option_context_add_main_entries(context, entries, NULL); 607 if (!g_option_context_parse(context, &argc, &argv, &error)) { 608 g_printerr("Option parsing failed: %s\n", error->message); 609 exit(EXIT_FAILURE); 610 } 611 if (opt_print_caps) { 612 g_print("{\n"); 613 g_print(" \"type\": \"block\",\n"); 614 g_print(" \"features\": [\n"); 615 g_print(" \"read-only\",\n"); 616 g_print(" \"blk-file\"\n"); 617 g_print(" ]\n"); 618 g_print("}\n"); 619 exit(EXIT_SUCCESS); 620 } 621 622 if (!opt_blk_file) { 623 g_print("%s\n", g_option_context_get_help(context, true, NULL)); 624 exit(EXIT_FAILURE); 625 } 626 627 if (opt_socket_path) { 628 lsock = unix_sock_new(opt_socket_path); 629 if (lsock < 0) { 630 exit(EXIT_FAILURE); 631 } 632 } else if (opt_fdnum < 0) { 633 g_print("%s\n", g_option_context_get_help(context, true, NULL)); 634 exit(EXIT_FAILURE); 635 } else { 636 lsock = opt_fdnum; 637 } 638 639 csock = accept(lsock, NULL, NULL); 640 if (csock < 0) { 641 g_printerr("Accept error %s\n", strerror(errno)); 642 exit(EXIT_FAILURE); 643 } 644 645 vdev_blk = vub_new(opt_blk_file); 646 if (!vdev_blk) { 647 exit(EXIT_FAILURE); 648 } 649 if (opt_read_only) { 650 vdev_blk->enable_ro = true; 651 } 652 653 if (!vug_init(&vdev_blk->parent, VHOST_USER_BLK_MAX_QUEUES, csock, 654 vub_panic_cb, &vub_iface)) { 655 g_printerr("Failed to initialize libvhost-user-glib\n"); 656 exit(EXIT_FAILURE); 657 } 658 659 g_main_loop_run(vdev_blk->loop); 660 g_main_loop_unref(vdev_blk->loop); 661 g_option_context_free(context); 662 vug_deinit(&vdev_blk->parent); 663 vub_free(vdev_blk); 664 if (csock >= 0) { 665 close(csock); 666 } 667 if (lsock >= 0) { 668 close(lsock); 669 } 670 g_free(opt_socket_path); 671 g_free(opt_blk_file); 672 673 return 0; 674 } 675