4 * Copyright (c) 2015 Red Hat, Inc.
7 * Victor Kaplansky <victork@redhat.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or
10 * later. See the COPYING file in the top-level directory.
15 * - main should get parameters from the command line.
16 * - implement all request handlers. Still not implemented:
17 * vubr_get_queue_num_exec()
18 * vubr_send_rarp_exec()
19 * - test for broken requests and virtqueue.
20 * - implement features defined by Virtio 1.0 spec.
21 * - support mergeable buffers and indirect descriptors.
22 * - implement clean shutdown.
23 * - implement non-blocking writes to UDP backend.
24 * - implement polling strategy.
25 * - implement clean starting/stopping of vq processing
26 * - implement clean starting/stopping of used and buffers
30 #define _FILE_OFFSET_BITS 64
32 #include "qemu/osdep.h"
33 #include "qemu/atomic.h"
34 #include "qemu/ctype.h"
36 #include "standard-headers/linux/virtio_net.h"
37 #include "contrib/libvhost-user/libvhost-user.h"
39 #define VHOST_USER_BRIDGE_DEBUG 1
43 if (VHOST_USER_BRIDGE_DEBUG) { \
44 printf(__VA_ARGS__); \
48 typedef void (*CallbackFunc
)(int sock
, void *ctx
);
50 typedef struct Event
{
52 CallbackFunc callback
;
55 typedef struct Dispatcher
{
58 Event events
[FD_SETSIZE
];
61 typedef struct VubrDev
{
63 Dispatcher dispatcher
;
65 struct sockaddr_in backend_udp_dest
;
78 vubr_die(const char *s
)
85 dispatcher_init(Dispatcher
*dispr
)
87 FD_ZERO(&dispr
->fdset
);
93 dispatcher_add(Dispatcher
*dispr
, int sock
, void *ctx
, CallbackFunc cb
)
95 if (sock
>= FD_SETSIZE
) {
97 "Error: Failed to add new event. sock %d should be less than %d\n",
102 dispr
->events
[sock
].ctx
= ctx
;
103 dispr
->events
[sock
].callback
= cb
;
105 FD_SET(sock
, &dispr
->fdset
);
106 if (sock
> dispr
->max_sock
) {
107 dispr
->max_sock
= sock
;
109 DPRINT("Added sock %d for watching. max_sock: %d\n",
110 sock
, dispr
->max_sock
);
115 dispatcher_remove(Dispatcher
*dispr
, int sock
)
117 if (sock
>= FD_SETSIZE
) {
119 "Error: Failed to remove event. sock %d should be less than %d\n",
124 FD_CLR(sock
, &dispr
->fdset
);
125 DPRINT("Sock %d removed from dispatcher watch.\n", sock
);
131 dispatcher_wait(Dispatcher
*dispr
, uint32_t timeout
)
134 tv
.tv_sec
= timeout
/ 1000000;
135 tv
.tv_usec
= timeout
% 1000000;
137 fd_set fdset
= dispr
->fdset
;
139 /* wait until some of sockets become readable. */
140 int rc
= select(dispr
->max_sock
+ 1, &fdset
, 0, 0, &tv
);
151 /* Now call callback for every ready socket. */
154 for (sock
= 0; sock
< dispr
->max_sock
+ 1; sock
++) {
155 /* The callback on a socket can remove other sockets from the
156 * dispatcher, thus we have to check that the socket is
157 * still not removed from dispatcher's list
159 if (FD_ISSET(sock
, &fdset
) && FD_ISSET(sock
, &dispr
->fdset
)) {
160 Event
*e
= &dispr
->events
[sock
];
161 e
->callback(sock
, e
->ctx
);
169 vubr_handle_tx(VuDev
*dev
, int qidx
)
171 VuVirtq
*vq
= vu_get_queue(dev
, qidx
);
172 VubrDev
*vubr
= container_of(dev
, VubrDev
, vudev
);
173 int hdrlen
= vubr
->hdrlen
;
174 VuVirtqElement
*elem
= NULL
;
180 unsigned int out_num
;
181 struct iovec sg
[VIRTQUEUE_MAX_SIZE
], *out_sg
;
183 elem
= vu_queue_pop(dev
, vq
, sizeof(VuVirtqElement
));
188 out_num
= elem
->out_num
;
189 out_sg
= elem
->out_sg
;
191 fprintf(stderr
, "virtio-net header not in first element\n");
194 if (VHOST_USER_BRIDGE_DEBUG
) {
195 iov_hexdump(out_sg
, out_num
, stderr
, "TX:", 1024);
199 unsigned sg_num
= iov_copy(sg
, ARRAY_SIZE(sg
),
206 struct msghdr msg
= {
207 .msg_name
= (struct sockaddr
*) &vubr
->backend_udp_dest
,
208 .msg_namelen
= sizeof(struct sockaddr_in
),
210 .msg_iovlen
= out_num
,
213 ret
= sendmsg(vubr
->backend_udp_sock
, &msg
, 0);
214 } while (ret
== -1 && (errno
== EAGAIN
|| errno
== EINTR
));
217 vubr_die("sendmsg()");
220 vu_queue_push(dev
, vq
, elem
, 0);
221 vu_queue_notify(dev
, vq
);
231 /* this function reverse the effect of iov_discard_front() it must be
232 * called with 'front' being the original struct iovec and 'bytes'
233 * being the number of bytes you shaved off
236 iov_restore_front(struct iovec
*front
, struct iovec
*iov
, size_t bytes
)
240 for (cur
= front
; cur
!= iov
; cur
++) {
241 assert(bytes
>= cur
->iov_len
);
242 bytes
-= cur
->iov_len
;
245 cur
->iov_base
-= bytes
;
246 cur
->iov_len
+= bytes
;
250 iov_truncate(struct iovec
*iov
, unsigned iovc
, size_t bytes
)
254 for (i
= 0; i
< iovc
; i
++, iov
++) {
255 if (bytes
< iov
->iov_len
) {
256 iov
->iov_len
= bytes
;
260 bytes
-= iov
->iov_len
;
263 assert(!"couldn't truncate iov");
267 vubr_backend_recv_cb(int sock
, void *ctx
)
269 VubrDev
*vubr
= (VubrDev
*) ctx
;
270 VuDev
*dev
= &vubr
->vudev
;
271 VuVirtq
*vq
= vu_get_queue(dev
, 0);
272 VuVirtqElement
*elem
= NULL
;
273 struct iovec mhdr_sg
[VIRTQUEUE_MAX_SIZE
];
274 struct virtio_net_hdr_mrg_rxbuf mhdr
;
275 unsigned mhdr_cnt
= 0;
276 int hdrlen
= vubr
->hdrlen
;
278 struct virtio_net_hdr hdr
= {
280 .gso_type
= VIRTIO_NET_HDR_GSO_NONE
283 DPRINT("\n\n *** IN UDP RECEIVE CALLBACK ***\n\n");
284 DPRINT(" hdrlen = %d\n", hdrlen
);
286 if (!vu_queue_enabled(dev
, vq
) ||
287 !vu_queue_started(dev
, vq
) ||
288 !vu_queue_avail_bytes(dev
, vq
, hdrlen
, 0)) {
289 DPRINT("Got UDP packet, but no available descriptors on RX virtq.\n");
295 ssize_t ret
, total
= 0;
298 elem
= vu_queue_pop(dev
, vq
, sizeof(VuVirtqElement
));
303 if (elem
->in_num
< 1) {
304 fprintf(stderr
, "virtio-net contains no in buffers\n");
312 mhdr_cnt
= iov_copy(mhdr_sg
, ARRAY_SIZE(mhdr_sg
),
314 offsetof(typeof(mhdr
), num_buffers
),
315 sizeof(mhdr
.num_buffers
));
317 iov_from_buf(sg
, elem
->in_num
, 0, &hdr
, sizeof hdr
);
319 ret
= iov_discard_front(&sg
, &num
, hdrlen
);
320 assert(ret
== hdrlen
);
323 struct msghdr msg
= {
324 .msg_name
= (struct sockaddr
*) &vubr
->backend_udp_dest
,
325 .msg_namelen
= sizeof(struct sockaddr_in
),
328 .msg_flags
= MSG_DONTWAIT
,
331 ret
= recvmsg(vubr
->backend_udp_sock
, &msg
, 0);
332 } while (ret
== -1 && (errno
== EINTR
));
335 iov_restore_front(elem
->in_sg
, sg
, hdrlen
);
339 if (errno
== EWOULDBLOCK
) {
340 vu_queue_rewind(dev
, vq
, 1);
344 vubr_die("recvmsg()");
348 iov_truncate(elem
->in_sg
, elem
->in_num
, total
);
349 vu_queue_fill(dev
, vq
, elem
, total
, i
++);
354 break; /* could loop if DONTWAIT worked? */
358 mhdr
.num_buffers
= i
;
359 iov_from_buf(mhdr_sg
, mhdr_cnt
,
361 &mhdr
.num_buffers
, sizeof mhdr
.num_buffers
);
364 vu_queue_flush(dev
, vq
, i
);
365 vu_queue_notify(dev
, vq
);
371 vubr_receive_cb(int sock
, void *ctx
)
373 VubrDev
*vubr
= (VubrDev
*)ctx
;
375 if (!vu_dispatch(&vubr
->vudev
)) {
376 fprintf(stderr
, "Error while dispatching\n");
380 typedef struct WatchData
{
387 watch_cb(int sock
, void *ctx
)
389 struct WatchData
*wd
= ctx
;
391 wd
->cb(wd
->dev
, VU_WATCH_IN
, wd
->data
);
395 vubr_set_watch(VuDev
*dev
, int fd
, int condition
,
396 vu_watch_cb cb
, void *data
)
398 VubrDev
*vubr
= container_of(dev
, VubrDev
, vudev
);
399 static WatchData watches
[FD_SETSIZE
];
400 struct WatchData
*wd
= &watches
[fd
];
405 dispatcher_add(&vubr
->dispatcher
, fd
, wd
, watch_cb
);
409 vubr_remove_watch(VuDev
*dev
, int fd
)
411 VubrDev
*vubr
= container_of(dev
, VubrDev
, vudev
);
413 dispatcher_remove(&vubr
->dispatcher
, fd
);
417 vubr_send_rarp_exec(VuDev
*dev
, VhostUserMsg
*vmsg
)
419 DPRINT("Function %s() not implemented yet.\n", __func__
);
424 vubr_process_msg(VuDev
*dev
, VhostUserMsg
*vmsg
, int *do_reply
)
426 switch (vmsg
->request
) {
427 case VHOST_USER_SEND_RARP
:
428 *do_reply
= vubr_send_rarp_exec(dev
, vmsg
);
431 /* let the library handle the rest */
439 vubr_set_features(VuDev
*dev
, uint64_t features
)
441 VubrDev
*vubr
= container_of(dev
, VubrDev
, vudev
);
443 if ((features
& (1ULL << VIRTIO_F_VERSION_1
)) ||
444 (features
& (1ULL << VIRTIO_NET_F_MRG_RXBUF
))) {
452 vubr_get_features(VuDev
*dev
)
454 return 1ULL << VIRTIO_NET_F_GUEST_ANNOUNCE
|
455 1ULL << VIRTIO_NET_F_MRG_RXBUF
|
456 1ULL << VIRTIO_F_VERSION_1
;
460 vubr_queue_set_started(VuDev
*dev
, int qidx
, bool started
)
462 VubrDev
*vubr
= container_of(dev
, VubrDev
, vudev
);
463 VuVirtq
*vq
= vu_get_queue(dev
, qidx
);
465 if (started
&& vubr
->notifier
.fd
>= 0) {
466 vu_set_queue_host_notifier(dev
, vq
, vubr
->notifier
.fd
,
468 qidx
* getpagesize());
472 vu_set_queue_handler(dev
, vq
, started
? vubr_handle_tx
: NULL
);
477 vubr_panic(VuDev
*dev
, const char *msg
)
479 VubrDev
*vubr
= container_of(dev
, VubrDev
, vudev
);
481 fprintf(stderr
, "PANIC: %s\n", msg
);
483 dispatcher_remove(&vubr
->dispatcher
, dev
->sock
);
488 vubr_queue_is_processed_in_order(VuDev
*dev
, int qidx
)
493 static const VuDevIface vuiface
= {
494 .get_features
= vubr_get_features
,
495 .set_features
= vubr_set_features
,
496 .process_msg
= vubr_process_msg
,
497 .queue_set_started
= vubr_queue_set_started
,
498 .queue_is_processed_in_order
= vubr_queue_is_processed_in_order
,
502 vubr_accept_cb(int sock
, void *ctx
)
504 VubrDev
*dev
= (VubrDev
*)ctx
;
506 struct sockaddr_un un
;
507 socklen_t len
= sizeof(un
);
509 conn_fd
= accept(sock
, (struct sockaddr
*) &un
, &len
);
511 vubr_die("accept()");
513 DPRINT("Got connection from remote peer on sock %d\n", conn_fd
);
522 dispatcher_add(&dev
->dispatcher
, conn_fd
, ctx
, vubr_receive_cb
);
523 dispatcher_remove(&dev
->dispatcher
, sock
);
527 vubr_new(const char *path
, bool client
)
529 VubrDev
*dev
= (VubrDev
*) calloc(1, sizeof(VubrDev
));
530 struct sockaddr_un un
;
534 /* Get a UNIX socket. */
535 dev
->sock
= socket(AF_UNIX
, SOCK_STREAM
, 0);
536 if (dev
->sock
== -1) {
540 dev
->notifier
.fd
= -1;
542 un
.sun_family
= AF_UNIX
;
543 strcpy(un
.sun_path
, path
);
544 len
= sizeof(un
.sun_family
) + strlen(path
);
549 if (bind(dev
->sock
, (struct sockaddr
*) &un
, len
) == -1) {
553 if (listen(dev
->sock
, 1) == -1) {
558 DPRINT("Waiting for connections on UNIX socket %s ...\n", path
);
560 if (connect(dev
->sock
, (struct sockaddr
*)&un
, len
) == -1) {
569 cb
= vubr_receive_cb
;
572 dispatcher_init(&dev
->dispatcher
);
574 dispatcher_add(&dev
->dispatcher
, dev
->sock
, (void *)dev
, cb
);
579 static void *notifier_thread(void *arg
)
581 VuDev
*dev
= (VuDev
*)arg
;
582 VubrDev
*vubr
= container_of(dev
, VubrDev
, vudev
);
583 int pagesize
= getpagesize();
587 for (qidx
= 0; qidx
< VHOST_MAX_NR_VIRTQUEUE
; qidx
++) {
588 uint16_t *n
= vubr
->notifier
.addr
+ pagesize
* qidx
;
592 /* We won't miss notifications if we reset
593 * the memory first. */
596 DPRINT("Got a notification for queue%d via host notifier.\n",
600 vubr_handle_tx(dev
, qidx
);
611 vubr_host_notifier_setup(VubrDev
*dev
)
613 char template[] = "/tmp/vubr-XXXXXX";
619 length
= getpagesize() * VHOST_MAX_NR_VIRTQUEUE
;
621 fd
= mkstemp(template);
623 vubr_die("mkstemp()");
626 if (posix_fallocate(fd
, 0, length
) != 0) {
627 vubr_die("posix_fallocate()");
630 addr
= mmap(NULL
, length
, PROT_READ
| PROT_WRITE
, MAP_SHARED
, fd
, 0);
631 if (addr
== MAP_FAILED
) {
635 memset(addr
, 0xff, length
);
637 if (pthread_create(&thread
, NULL
, notifier_thread
, &dev
->vudev
) != 0) {
638 vubr_die("pthread_create()");
641 dev
->notifier
.fd
= fd
;
642 dev
->notifier
.addr
= addr
;
643 dev
->notifier
.thread
= thread
;
647 vubr_set_host(struct sockaddr_in
*saddr
, const char *host
)
649 if (qemu_isdigit(host
[0])) {
650 if (!inet_aton(host
, &saddr
->sin_addr
)) {
651 fprintf(stderr
, "inet_aton() failed.\n");
655 struct hostent
*he
= gethostbyname(host
);
658 fprintf(stderr
, "gethostbyname() failed.\n");
661 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
666 vubr_backend_udp_setup(VubrDev
*dev
,
667 const char *local_host
,
668 const char *local_port
,
669 const char *remote_host
,
670 const char *remote_port
)
677 lport
= strtol(local_port
, (char **)&r
, 0);
678 if (r
== local_port
) {
679 fprintf(stderr
, "lport parsing failed.\n");
683 rport
= strtol(remote_port
, (char **)&r
, 0);
684 if (r
== remote_port
) {
685 fprintf(stderr
, "rport parsing failed.\n");
689 struct sockaddr_in si_local
= {
690 .sin_family
= AF_INET
,
691 .sin_port
= htons(lport
),
694 vubr_set_host(&si_local
, local_host
);
696 /* setup destination for sends */
697 dev
->backend_udp_dest
= (struct sockaddr_in
) {
698 .sin_family
= AF_INET
,
699 .sin_port
= htons(rport
),
701 vubr_set_host(&dev
->backend_udp_dest
, remote_host
);
703 sock
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
708 if (bind(sock
, (struct sockaddr
*)&si_local
, sizeof(si_local
)) == -1) {
712 dev
->backend_udp_sock
= sock
;
713 dispatcher_add(&dev
->dispatcher
, sock
, dev
, vubr_backend_recv_cb
);
714 DPRINT("Waiting for data from udp backend on %s:%d...\n",
719 vubr_run(VubrDev
*dev
)
723 dispatcher_wait(&dev
->dispatcher
, 200000);
724 /* Here one can try polling strategy. */
729 vubr_parse_host_port(const char **host
, const char **port
, const char *buf
)
731 char *p
= strchr(buf
, ':');
738 *port
= strdup(p
+ 1);
742 #define DEFAULT_UD_SOCKET "/tmp/vubr.sock"
743 #define DEFAULT_LHOST "127.0.0.1"
744 #define DEFAULT_LPORT "4444"
745 #define DEFAULT_RHOST "127.0.0.1"
746 #define DEFAULT_RPORT "5555"
748 static const char *ud_socket_path
= DEFAULT_UD_SOCKET
;
749 static const char *lhost
= DEFAULT_LHOST
;
750 static const char *lport
= DEFAULT_LPORT
;
751 static const char *rhost
= DEFAULT_RHOST
;
752 static const char *rport
= DEFAULT_RPORT
;
755 main(int argc
, char *argv
[])
760 bool host_notifier
= false;
762 while ((opt
= getopt(argc
, argv
, "l:r:u:cH")) != -1) {
766 if (vubr_parse_host_port(&lhost
, &lport
, optarg
) < 0) {
771 if (vubr_parse_host_port(&rhost
, &rport
, optarg
) < 0) {
776 ud_socket_path
= strdup(optarg
);
782 host_notifier
= true;
789 DPRINT("ud socket: %s (%s)\n", ud_socket_path
,
790 client
? "client" : "server");
791 DPRINT("local: %s:%s\n", lhost
, lport
);
792 DPRINT("remote: %s:%s\n", rhost
, rport
);
794 dev
= vubr_new(ud_socket_path
, client
);
800 vubr_host_notifier_setup(dev
);
803 vubr_backend_udp_setup(dev
, lhost
, lport
, rhost
, rport
);
806 vu_deinit(&dev
->vudev
);
811 fprintf(stderr
, "Usage: %s ", argv
[0]);
812 fprintf(stderr
, "[-c] [-H] [-u ud_socket_path] [-l lhost:lport] [-r rhost:rport]\n");
813 fprintf(stderr
, "\t-u path to unix doman socket. default: %s\n",
815 fprintf(stderr
, "\t-l local host and port. default: %s:%s\n",
816 DEFAULT_LHOST
, DEFAULT_LPORT
);
817 fprintf(stderr
, "\t-r remote host and port. default: %s:%s\n",
818 DEFAULT_RHOST
, DEFAULT_RPORT
);
819 fprintf(stderr
, "\t-c client mode\n");
820 fprintf(stderr
, "\t-H use host notifier\n");