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 "contrib/libvhost-user/libvhost-user-glib.h"
21 #include "contrib/libvhost-user/libvhost-user.h"
23 #if defined(__linux__)
25 #include <sys/ioctl.h>
28 struct virtio_blk_inhdr
{
32 /* vhost user block device */
33 typedef struct VubDev
{
36 struct virtio_blk_config blkcfg
;
42 typedef struct VubReq
{
46 struct virtio_blk_inhdr
*in
;
47 struct virtio_blk_outhdr
*out
;
52 /* refer util/iov.c */
53 static size_t vub_iov_size(const struct iovec
*iov
,
54 const unsigned int iov_cnt
)
60 for (i
= 0; i
< iov_cnt
; i
++) {
61 len
+= iov
[i
].iov_len
;
66 static size_t vub_iov_to_buf(const struct iovec
*iov
,
67 const unsigned int iov_cnt
, void *buf
)
73 for (i
= 0; i
< iov_cnt
; i
++) {
74 memcpy(buf
+ len
, iov
[i
].iov_base
, iov
[i
].iov_len
);
75 len
+= iov
[i
].iov_len
;
80 static void vub_panic_cb(VuDev
*vu_dev
, const char *buf
)
87 gdev
= container_of(vu_dev
, VugDev
, parent
);
88 vdev_blk
= container_of(gdev
, VubDev
, parent
);
90 g_warning("vu_panic: %s", buf
);
93 g_main_loop_quit(vdev_blk
->loop
);
96 static void vub_req_complete(VubReq
*req
)
98 VugDev
*gdev
= &req
->vdev_blk
->parent
;
99 VuDev
*vu_dev
= &gdev
->parent
;
101 /* IO size with 1 extra status byte */
102 vu_queue_push(vu_dev
, req
->vq
, req
->elem
,
104 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 %lu 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 %lu 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 %ld, expect %ld\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
;
196 desc
= (struct virtio_blk_discard_write_zeroes
*)buf
;
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 if ((idx
< 0) || (idx
>= VHOST_MAX_NR_VIRTQUEUE
)) {
338 fprintf(stderr
, "VQ Index out of range: %d\n", idx
);
339 vub_panic_cb(vu_dev
, NULL
);
343 gdev
= container_of(vu_dev
, VugDev
, parent
);
344 vdev_blk
= container_of(gdev
, VubDev
, parent
);
347 vq
= vu_get_queue(vu_dev
, idx
);
351 ret
= vub_virtio_process_req(vdev_blk
, vq
);
358 static void vub_queue_set_started(VuDev
*vu_dev
, int idx
, bool started
)
364 vq
= vu_get_queue(vu_dev
, idx
);
365 vu_set_queue_handler(vu_dev
, vq
, started
? vub_process_vq
: NULL
);
369 vub_get_features(VuDev
*dev
)
375 gdev
= container_of(dev
, VugDev
, parent
);
376 vdev_blk
= container_of(gdev
, VubDev
, parent
);
378 features
= 1ull << VIRTIO_BLK_F_SIZE_MAX
|
379 1ull << VIRTIO_BLK_F_SEG_MAX
|
380 1ull << VIRTIO_BLK_F_TOPOLOGY
|
381 1ull << VIRTIO_BLK_F_BLK_SIZE
|
382 1ull << VIRTIO_BLK_F_FLUSH
|
383 #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT)
384 1ull << VIRTIO_BLK_F_DISCARD
|
385 1ull << VIRTIO_BLK_F_WRITE_ZEROES
|
387 1ull << VIRTIO_BLK_F_CONFIG_WCE
|
388 1ull << VIRTIO_F_VERSION_1
|
389 1ull << VHOST_USER_F_PROTOCOL_FEATURES
;
391 if (vdev_blk
->enable_ro
) {
392 features
|= 1ull << VIRTIO_BLK_F_RO
;
399 vub_get_protocol_features(VuDev
*dev
)
401 return 1ull << VHOST_USER_PROTOCOL_F_CONFIG
|
402 1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD
;
406 vub_get_config(VuDev
*vu_dev
, uint8_t *config
, uint32_t len
)
411 gdev
= container_of(vu_dev
, VugDev
, parent
);
412 vdev_blk
= container_of(gdev
, VubDev
, parent
);
413 memcpy(config
, &vdev_blk
->blkcfg
, len
);
419 vub_set_config(VuDev
*vu_dev
, const uint8_t *data
,
420 uint32_t offset
, uint32_t size
, uint32_t flags
)
427 /* don't support live migration */
428 if (flags
!= VHOST_SET_CONFIG_TYPE_MASTER
) {
432 gdev
= container_of(vu_dev
, VugDev
, parent
);
433 vdev_blk
= container_of(gdev
, VubDev
, parent
);
435 if (offset
!= offsetof(struct virtio_blk_config
, wce
) ||
441 if (wce
== vdev_blk
->blkcfg
.wce
) {
442 /* Do nothing as same with old configuration */
446 vdev_blk
->blkcfg
.wce
= wce
;
447 fprintf(stdout
, "Write Cache Policy Changed\n");
448 if (vdev_blk
->blk_fd
>= 0) {
449 close(vdev_blk
->blk_fd
);
450 vdev_blk
->blk_fd
= -1;
453 fd
= vub_open(vdev_blk
->blk_name
, wce
);
455 fprintf(stderr
, "Error to open block device %s\n", vdev_blk
->blk_name
);
456 vdev_blk
->blk_fd
= -1;
459 vdev_blk
->blk_fd
= fd
;
464 static const VuDevIface vub_iface
= {
465 .get_features
= vub_get_features
,
466 .queue_set_started
= vub_queue_set_started
,
467 .get_protocol_features
= vub_get_protocol_features
,
468 .get_config
= vub_get_config
,
469 .set_config
= vub_set_config
,
472 static int unix_sock_new(char *unix_fn
)
475 struct sockaddr_un un
;
480 sock
= socket(AF_UNIX
, SOCK_STREAM
, 0);
486 un
.sun_family
= AF_UNIX
;
487 (void)snprintf(un
.sun_path
, sizeof(un
.sun_path
), "%s", unix_fn
);
488 len
= sizeof(un
.sun_family
) + strlen(un
.sun_path
);
490 (void)unlink(unix_fn
);
491 if (bind(sock
, (struct sockaddr
*)&un
, len
) < 0) {
496 if (listen(sock
, 1) < 0) {
509 static void vub_free(struct VubDev
*vdev_blk
)
515 g_main_loop_unref(vdev_blk
->loop
);
516 if (vdev_blk
->blk_fd
>= 0) {
517 close(vdev_blk
->blk_fd
);
523 vub_get_blocksize(int fd
)
525 uint32_t blocksize
= 512;
527 #if defined(__linux__) && defined(BLKSSZGET)
528 if (ioctl(fd
, BLKSSZGET
, &blocksize
) == 0) {
537 vub_initialize_config(int fd
, struct virtio_blk_config
*config
)
541 capacity
= lseek64(fd
, 0, SEEK_END
);
542 config
->capacity
= capacity
>> 9;
543 config
->blk_size
= vub_get_blocksize(fd
);
544 config
->size_max
= 65536;
545 config
->seg_max
= 128 - 2;
546 config
->min_io_size
= 1;
547 config
->opt_io_size
= 1;
548 config
->num_queues
= 1;
549 #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT)
550 config
->max_discard_sectors
= 32768;
551 config
->max_discard_seg
= 1;
552 config
->discard_sector_alignment
= config
->blk_size
>> 9;
553 config
->max_write_zeroes_sectors
= 32768;
554 config
->max_write_zeroes_seg
= 1;
559 vub_new(char *blk_file
)
563 vdev_blk
= g_new0(VubDev
, 1);
564 vdev_blk
->loop
= g_main_loop_new(NULL
, FALSE
);
565 vdev_blk
->blk_fd
= vub_open(blk_file
, 0);
566 if (vdev_blk
->blk_fd
< 0) {
567 fprintf(stderr
, "Error to open block device %s\n", blk_file
);
571 vdev_blk
->enable_ro
= false;
572 vdev_blk
->blkcfg
.wce
= 0;
573 vdev_blk
->blk_name
= blk_file
;
575 /* fill virtio_blk_config with block parameters */
576 vub_initialize_config(vdev_blk
->blk_fd
, &vdev_blk
->blkcfg
);
581 int main(int argc
, char **argv
)
584 char *unix_socket
= NULL
;
585 char *blk_file
= NULL
;
586 bool enable_ro
= false;
587 int lsock
= -1, csock
= -1;
588 VubDev
*vdev_blk
= NULL
;
590 while ((opt
= getopt(argc
, argv
, "b:rs:h")) != -1) {
593 blk_file
= g_strdup(optarg
);
596 unix_socket
= g_strdup(optarg
);
603 printf("Usage: %s [ -b block device or file, -s UNIX domain socket"
604 " | -r Enable read-only ] | [ -h ]\n", argv
[0]);
609 if (!unix_socket
|| !blk_file
) {
610 printf("Usage: %s [ -b block device or file, -s UNIX domain socket"
611 " | -r Enable read-only ] | [ -h ]\n", argv
[0]);
615 lsock
= unix_sock_new(unix_socket
);
620 csock
= accept(lsock
, (void *)0, (void *)0);
622 fprintf(stderr
, "Accept error %s\n", strerror(errno
));
626 vdev_blk
= vub_new(blk_file
);
631 vdev_blk
->enable_ro
= true;
634 vug_init(&vdev_blk
->parent
, csock
, vub_panic_cb
, &vub_iface
);
636 g_main_loop_run(vdev_blk
->loop
);
638 vug_deinit(&vdev_blk
->parent
);