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 }
676