2 * vhost-user-blk sample application
4 * Copyright (c) 2017 Intel Corporation. All rights reserved.
7 * Changpeng Liu <changpeng.liu@intel.com>
9 * This work is based on the "vhost-user-scsi" sample and "virtio-blk" driver
11 * Felipe Franciosi <felipe@nutanix.com>
12 * Anthony Liguori <aliguori@us.ibm.com>
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.
18 #include "qemu/osdep.h"
19 #include "standard-headers/linux/virtio_blk.h"
20 #include "libvhost-user-glib.h"
22 #if defined(__linux__)
24 #include <sys/ioctl.h>
28 VHOST_USER_BLK_MAX_QUEUES = 8,
31 struct virtio_blk_inhdr {
35 /* vhost user block device */
36 typedef struct VubDev {
39 struct virtio_blk_config blkcfg;
45 typedef struct VubReq {
49 struct virtio_blk_inhdr *in;
50 struct virtio_blk_outhdr *out;
55 /* refer util/iov.c */
56 static size_t vub_iov_size(const struct iovec *iov,
57 const unsigned int iov_cnt)
63 for (i = 0; i < iov_cnt; i++) {
64 len += iov[i].iov_len;
69 static size_t vub_iov_to_buf(const struct iovec *iov,
70 const unsigned int iov_cnt, void *buf)
76 for (i = 0; i < iov_cnt; i++) {
77 memcpy(buf + len, iov[i].iov_base, iov[i].iov_len);
78 len += iov[i].iov_len;
83 static void vub_panic_cb(VuDev *vu_dev, const char *buf)
90 gdev = container_of(vu_dev, VugDev, parent);
91 vdev_blk = container_of(gdev, VubDev, parent);
93 g_warning("vu_panic: %s", buf);
96 g_main_loop_quit(vdev_blk->loop);
99 static void vub_req_complete(VubReq *req)
101 VugDev *gdev = &req->vdev_blk->parent;
102 VuDev *vu_dev = &gdev->parent;
104 /* IO size with 1 extra status byte */
105 vu_queue_push(vu_dev, req->vq, req->elem,
107 vu_queue_notify(vu_dev, req->vq);
113 static int vub_open(const char *file_name, bool wce)
122 fd = open(file_name, flags);
124 fprintf(stderr, "Cannot open file %s, %s\n", file_name,
133 vub_readv(VubReq *req, struct iovec *iov, uint32_t iovcnt)
135 VubDev *vdev_blk = req->vdev_blk;
139 fprintf(stderr, "Invalid Read IOV count\n");
143 req->size = vub_iov_size(iov, iovcnt);
144 rc = preadv(vdev_blk->blk_fd, iov, iovcnt, req->sector_num * 512);
146 fprintf(stderr, "%s, Sector %"PRIu64", Size %zu failed with %s\n",
147 vdev_blk->blk_name, req->sector_num, req->size,
156 vub_writev(VubReq *req, struct iovec *iov, uint32_t iovcnt)
158 VubDev *vdev_blk = req->vdev_blk;
162 fprintf(stderr, "Invalid Write IOV count\n");
166 req->size = vub_iov_size(iov, iovcnt);
167 rc = pwritev(vdev_blk->blk_fd, iov, iovcnt, req->sector_num * 512);
169 fprintf(stderr, "%s, Sector %"PRIu64", Size %zu failed with %s\n",
170 vdev_blk->blk_name, req->sector_num, req->size,
179 vub_discard_write_zeroes(VubReq *req, struct iovec *iov, uint32_t iovcnt,
182 struct virtio_blk_discard_write_zeroes *desc;
186 size = vub_iov_size(iov, iovcnt);
187 if (size != sizeof(*desc)) {
188 fprintf(stderr, "Invalid size %zd, expect %zd\n", size, sizeof(*desc));
191 buf = g_new0(char, size);
192 vub_iov_to_buf(iov, iovcnt, buf);
194 #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT)
195 VubDev *vdev_blk = req->vdev_blk;
197 uint64_t range[2] = { le64toh(desc->sector) << 9,
198 le32toh(desc->num_sectors) << 9 };
199 if (type == VIRTIO_BLK_T_DISCARD) {
200 if (ioctl(vdev_blk->blk_fd, BLKDISCARD, range) == 0) {
204 } else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
205 if (ioctl(vdev_blk->blk_fd, BLKZEROOUT, range) == 0) {
217 vub_flush(VubReq *req)
219 VubDev *vdev_blk = req->vdev_blk;
221 fdatasync(vdev_blk->blk_fd);
224 static int vub_virtio_process_req(VubDev *vdev_blk,
227 VugDev *gdev = &vdev_blk->parent;
228 VuDev *vu_dev = &gdev->parent;
229 VuVirtqElement *elem;
235 elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) + sizeof(VubReq));
240 /* refer to hw/block/virtio_blk.c */
241 if (elem->out_num < 1 || elem->in_num < 1) {
242 fprintf(stderr, "virtio-blk request missing headers\n");
247 req = g_new0(VubReq, 1);
248 req->vdev_blk = vdev_blk;
252 in_num = elem->in_num;
253 out_num = elem->out_num;
255 /* don't support VIRTIO_F_ANY_LAYOUT and virtio 1.0 only */
256 if (elem->out_sg[0].iov_len < sizeof(struct virtio_blk_outhdr)) {
257 fprintf(stderr, "Invalid outhdr size\n");
260 req->out = (struct virtio_blk_outhdr *)elem->out_sg[0].iov_base;
263 if (elem->in_sg[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
264 fprintf(stderr, "Invalid inhdr size\n");
267 req->in = (struct virtio_blk_inhdr *)elem->in_sg[in_num - 1].iov_base;
270 type = le32toh(req->out->type);
271 switch (type & ~VIRTIO_BLK_T_BARRIER) {
272 case VIRTIO_BLK_T_IN:
273 case VIRTIO_BLK_T_OUT: {
275 bool is_write = type & VIRTIO_BLK_T_OUT;
276 req->sector_num = le64toh(req->out->sector);
278 ret = vub_writev(req, &elem->out_sg[1], out_num);
280 ret = vub_readv(req, &elem->in_sg[0], in_num);
283 req->in->status = VIRTIO_BLK_S_OK;
285 req->in->status = VIRTIO_BLK_S_IOERR;
287 vub_req_complete(req);
290 case VIRTIO_BLK_T_FLUSH:
292 req->in->status = VIRTIO_BLK_S_OK;
293 vub_req_complete(req);
295 case VIRTIO_BLK_T_GET_ID: {
296 size_t size = MIN(vub_iov_size(&elem->in_sg[0], in_num),
297 VIRTIO_BLK_ID_BYTES);
298 snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk");
299 req->in->status = VIRTIO_BLK_S_OK;
300 req->size = elem->in_sg[0].iov_len;
301 vub_req_complete(req);
304 case VIRTIO_BLK_T_DISCARD:
305 case VIRTIO_BLK_T_WRITE_ZEROES: {
307 rc = vub_discard_write_zeroes(req, &elem->out_sg[1], out_num, type);
309 req->in->status = VIRTIO_BLK_S_OK;
311 req->in->status = VIRTIO_BLK_S_IOERR;
313 vub_req_complete(req);
317 req->in->status = VIRTIO_BLK_S_UNSUPP;
318 vub_req_complete(req);
330 static void vub_process_vq(VuDev *vu_dev, int idx)
337 gdev = container_of(vu_dev, VugDev, parent);
338 vdev_blk = container_of(gdev, VubDev, parent);
341 vq = vu_get_queue(vu_dev, idx);
345 ret = vub_virtio_process_req(vdev_blk, vq);
352 static void vub_queue_set_started(VuDev *vu_dev, int idx, bool started)
358 vq = vu_get_queue(vu_dev, idx);
359 vu_set_queue_handler(vu_dev, vq, started ? vub_process_vq : NULL);
363 vub_get_features(VuDev *dev)
369 gdev = container_of(dev, VugDev, parent);
370 vdev_blk = container_of(gdev, VubDev, parent);
372 features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
373 1ull << VIRTIO_BLK_F_SEG_MAX |
374 1ull << VIRTIO_BLK_F_TOPOLOGY |
375 1ull << VIRTIO_BLK_F_BLK_SIZE |
376 1ull << VIRTIO_BLK_F_FLUSH |
377 #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT)
378 1ull << VIRTIO_BLK_F_DISCARD |
379 1ull << VIRTIO_BLK_F_WRITE_ZEROES |
381 1ull << VIRTIO_BLK_F_CONFIG_WCE;
383 if (vdev_blk->enable_ro) {
384 features |= 1ull << VIRTIO_BLK_F_RO;
391 vub_get_protocol_features(VuDev *dev)
393 return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |
394 1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;
398 vub_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
403 if (len > sizeof(struct virtio_blk_config)) {
407 gdev = container_of(vu_dev, VugDev, parent);
408 vdev_blk = container_of(gdev, VubDev, parent);
409 memcpy(config, &vdev_blk->blkcfg, len);
415 vub_set_config(VuDev *vu_dev, const uint8_t *data,
416 uint32_t offset, uint32_t size, uint32_t flags)
423 /* don't support live migration */
424 if (flags != VHOST_SET_CONFIG_TYPE_FRONTEND) {
428 gdev = container_of(vu_dev, VugDev, parent);
429 vdev_blk = container_of(gdev, VubDev, parent);
431 if (offset != offsetof(struct virtio_blk_config, wce) ||
437 if (wce == vdev_blk->blkcfg.wce) {
438 /* Do nothing as same with old configuration */
442 vdev_blk->blkcfg.wce = wce;
443 fprintf(stdout, "Write Cache Policy Changed\n");
444 if (vdev_blk->blk_fd >= 0) {
445 close(vdev_blk->blk_fd);
446 vdev_blk->blk_fd = -1;
449 fd = vub_open(vdev_blk->blk_name, wce);
451 fprintf(stderr, "Error to open block device %s\n", vdev_blk->blk_name);
452 vdev_blk->blk_fd = -1;
455 vdev_blk->blk_fd = fd;
460 static const VuDevIface vub_iface = {
461 .get_features = vub_get_features,
462 .queue_set_started = vub_queue_set_started,
463 .get_protocol_features = vub_get_protocol_features,
464 .get_config = vub_get_config,
465 .set_config = vub_set_config,
468 static int unix_sock_new(char *unix_fn)
471 struct sockaddr_un un;
476 sock = socket(AF_UNIX, SOCK_STREAM, 0);
482 un.sun_family = AF_UNIX;
483 (void)snprintf(un.sun_path, sizeof(un.sun_path), "%s", unix_fn);
484 len = sizeof(un.sun_family) + strlen(un.sun_path);
486 (void)unlink(unix_fn);
487 if (bind(sock, (struct sockaddr *)&un, len) < 0) {
492 if (listen(sock, 1) < 0) {
505 static void vub_free(struct VubDev *vdev_blk)
511 g_main_loop_unref(vdev_blk->loop);
512 if (vdev_blk->blk_fd >= 0) {
513 close(vdev_blk->blk_fd);
519 vub_get_blocksize(int fd)
521 uint32_t blocksize = 512;
523 #if defined(__linux__) && defined(BLKSSZGET)
524 if (ioctl(fd, BLKSSZGET, &blocksize) == 0) {
533 vub_initialize_config(int fd, struct virtio_blk_config *config)
537 capacity = lseek(fd, 0, SEEK_END);
538 config->capacity = capacity >> 9;
539 config->blk_size = vub_get_blocksize(fd);
540 config->size_max = 65536;
541 config->seg_max = 128 - 2;
542 config->min_io_size = 1;
543 config->opt_io_size = 1;
544 config->num_queues = 1;
545 #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT)
546 config->max_discard_sectors = 32768;
547 config->max_discard_seg = 1;
548 config->discard_sector_alignment = config->blk_size >> 9;
549 config->max_write_zeroes_sectors = 32768;
550 config->max_write_zeroes_seg = 1;
555 vub_new(char *blk_file)
559 vdev_blk = g_new0(VubDev, 1);
560 vdev_blk->loop = g_main_loop_new(NULL, FALSE);
561 vdev_blk->blk_fd = vub_open(blk_file, 0);
562 if (vdev_blk->blk_fd < 0) {
563 fprintf(stderr, "Error to open block device %s\n", blk_file);
567 vdev_blk->enable_ro = false;
568 vdev_blk->blkcfg.wce = 0;
569 vdev_blk->blk_name = blk_file;
571 /* fill virtio_blk_config with block parameters */
572 vub_initialize_config(vdev_blk->blk_fd, &vdev_blk->blkcfg);
577 static int opt_fdnum = -1;
578 static char *opt_socket_path;
579 static char *opt_blk_file;
580 static gboolean opt_print_caps;
581 static gboolean opt_read_only;
583 static GOptionEntry entries[] = {
584 { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &opt_print_caps,
585 "Print capabilities", NULL },
586 { "fd", 'f', 0, G_OPTION_ARG_INT, &opt_fdnum,
587 "Use inherited fd socket", "FDNUM" },
588 { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &opt_socket_path,
589 "Use UNIX socket path", "PATH" },
590 {"blk-file", 'b', 0, G_OPTION_ARG_FILENAME, &opt_blk_file,
591 "block device or file path", "PATH"},
592 { "read-only", 'r', 0, G_OPTION_ARG_NONE, &opt_read_only,
593 "Enable read-only", NULL },
597 int main(int argc, char **argv)
599 int lsock = -1, csock = -1;
600 VubDev *vdev_blk = NULL;
601 GError *error = NULL;
602 GOptionContext *context;
604 context = g_option_context_new(NULL);
605 g_option_context_add_main_entries(context, entries, NULL);
606 if (!g_option_context_parse(context, &argc, &argv, &error)) {
607 g_printerr("Option parsing failed: %s\n", error->message);
610 if (opt_print_caps) {
612 g_print(" \"type\": \"block\",\n");
613 g_print(" \"features\": [\n");
614 g_print(" \"read-only\",\n");
615 g_print(" \"blk-file\"\n");
622 g_print("%s\n", g_option_context_get_help(context, true, NULL));
626 if (opt_socket_path) {
627 lsock = unix_sock_new(opt_socket_path);
631 } else if (opt_fdnum < 0) {
632 g_print("%s\n", g_option_context_get_help(context, true, NULL));
638 csock = accept(lsock, NULL, NULL);
640 g_printerr("Accept error %s\n", strerror(errno));
644 vdev_blk = vub_new(opt_blk_file);
649 vdev_blk->enable_ro = true;
652 if (!vug_init(&vdev_blk->parent, VHOST_USER_BLK_MAX_QUEUES, csock,
653 vub_panic_cb, &vub_iface)) {
654 g_printerr("Failed to initialize libvhost-user-glib\n");
658 g_main_loop_run(vdev_blk->loop);
659 g_main_loop_unref(vdev_blk->loop);
660 g_option_context_free(context);
661 vug_deinit(&vdev_blk->parent);
669 g_free(opt_socket_path);
670 g_free(opt_blk_file);