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