vhost-user-bridge.c - qemu - FORK: QEMU emulator

vhost-user-bridge.c (20796B)
      1 /*
      2  * Vhost User Bridge
      3  *
      4  * Copyright (c) 2015 Red Hat, Inc.
      5  *
      6  * Authors:
      7  *  Victor Kaplansky <victork@redhat.com>
      8  *
      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.
     11  */
     12 
     13 /*
     14  * TODO:
     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
     27  *       dirty page logging.
     28  */
     29 
     30 #define _FILE_OFFSET_BITS 64
     31 
     32 #include "qemu/osdep.h"
     33 #include "qemu/atomic.h"
     34 #include "qemu/ctype.h"
     35 #include "qemu/iov.h"
     36 #include "standard-headers/linux/virtio_net.h"
     37 #include "libvhost-user.h"
     38 
     39 #define VHOST_USER_BRIDGE_DEBUG 1
     40 
     41 #define DPRINT(...) \
     42     do { \
     43         if (VHOST_USER_BRIDGE_DEBUG) { \
     44             printf(__VA_ARGS__); \
     45         } \
     46     } while (0)
     47 
     48 enum {
     49     VHOST_USER_BRIDGE_MAX_QUEUES = 8,
     50 };
     51 
     52 typedef void (*CallbackFunc)(int sock, void *ctx);
     53 
     54 typedef struct Event {
     55     void *ctx;
     56     CallbackFunc callback;
     57 } Event;
     58 
     59 typedef struct Dispatcher {
     60     int max_sock;
     61     fd_set fdset;
     62     Event events[FD_SETSIZE];
     63 } Dispatcher;
     64 
     65 typedef struct VubrDev {
     66     VuDev vudev;
     67     Dispatcher dispatcher;
     68     int backend_udp_sock;
     69     struct sockaddr_in backend_udp_dest;
     70     int hdrlen;
     71     int sock;
     72     int ready;
     73     int quit;
     74     struct {
     75         int fd;
     76         void *addr;
     77         pthread_t thread;
     78     } notifier;
     79 } VubrDev;
     80 
     81 static void
     82 vubr_die(const char *s)
     83 {
     84     perror(s);
     85     exit(1);
     86 }
     87 
     88 static int
     89 dispatcher_init(Dispatcher *dispr)
     90 {
     91     FD_ZERO(&dispr->fdset);
     92     dispr->max_sock = -1;
     93     return 0;
     94 }
     95 
     96 static int
     97 dispatcher_add(Dispatcher *dispr, int sock, void *ctx, CallbackFunc cb)
     98 {
     99     if (sock >= FD_SETSIZE) {
    100         fprintf(stderr,
    101                 "Error: Failed to add new event. sock %d should be less than %d\n",
    102                 sock, FD_SETSIZE);
    103         return -1;
    104     }
    105 
    106     dispr->events[sock].ctx = ctx;
    107     dispr->events[sock].callback = cb;
    108 
    109     FD_SET(sock, &dispr->fdset);
    110     if (sock > dispr->max_sock) {
    111         dispr->max_sock = sock;
    112     }
    113     DPRINT("Added sock %d for watching. max_sock: %d\n",
    114            sock, dispr->max_sock);
    115     return 0;
    116 }
    117 
    118 static int
    119 dispatcher_remove(Dispatcher *dispr, int sock)
    120 {
    121     if (sock >= FD_SETSIZE) {
    122         fprintf(stderr,
    123                 "Error: Failed to remove event. sock %d should be less than %d\n",
    124                 sock, FD_SETSIZE);
    125         return -1;
    126     }
    127 
    128     FD_CLR(sock, &dispr->fdset);
    129     DPRINT("Sock %d removed from dispatcher watch.\n", sock);
    130     return 0;
    131 }
    132 
    133 /* timeout in us */
    134 static int
    135 dispatcher_wait(Dispatcher *dispr, uint32_t timeout)
    136 {
    137     struct timeval tv;
    138     tv.tv_sec = timeout / 1000000;
    139     tv.tv_usec = timeout % 1000000;
    140 
    141     fd_set fdset = dispr->fdset;
    142 
    143     /* wait until some of sockets become readable. */
    144     int rc = select(dispr->max_sock + 1, &fdset, 0, 0, &tv);
    145 
    146     if (rc == -1) {
    147         vubr_die("select");
    148     }
    149 
    150     /* Timeout */
    151     if (rc == 0) {
    152         return 0;
    153     }
    154 
    155     /* Now call callback for every ready socket. */
    156 
    157     int sock;
    158     for (sock = 0; sock < dispr->max_sock + 1; sock++) {
    159         /* The callback on a socket can remove other sockets from the
    160          * dispatcher, thus we have to check that the socket is
    161          * still not removed from dispatcher's list
    162          */
    163         if (FD_ISSET(sock, &fdset) && FD_ISSET(sock, &dispr->fdset)) {
    164             Event *e = &dispr->events[sock];
    165             e->callback(sock, e->ctx);
    166         }
    167     }
    168 
    169     return 0;
    170 }
    171 
    172 static void
    173 vubr_handle_tx(VuDev *dev, int qidx)
    174 {
    175     VuVirtq *vq = vu_get_queue(dev, qidx);
    176     VubrDev *vubr = container_of(dev, VubrDev, vudev);
    177     int hdrlen = vubr->hdrlen;
    178     VuVirtqElement *elem = NULL;
    179 
    180     assert(qidx % 2);
    181 
    182     for (;;) {
    183         ssize_t ret;
    184         unsigned int out_num;
    185         struct iovec sg[VIRTQUEUE_MAX_SIZE], *out_sg;
    186 
    187         elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
    188         if (!elem) {
    189             break;
    190         }
    191 
    192         out_num = elem->out_num;
    193         out_sg = elem->out_sg;
    194         if (out_num < 1) {
    195             fprintf(stderr, "virtio-net header not in first element\n");
    196             break;
    197         }
    198         if (VHOST_USER_BRIDGE_DEBUG) {
    199             iov_hexdump(out_sg, out_num, stderr, "TX:", 1024);
    200         }
    201 
    202         if (hdrlen) {
    203             unsigned sg_num = iov_copy(sg, ARRAY_SIZE(sg),
    204                                        out_sg, out_num,
    205                                        hdrlen, -1);
    206             out_num = sg_num;
    207             out_sg = sg;
    208         }
    209 
    210         struct msghdr msg = {
    211             .msg_name = (struct sockaddr *) &vubr->backend_udp_dest,
    212             .msg_namelen = sizeof(struct sockaddr_in),
    213             .msg_iov = out_sg,
    214             .msg_iovlen = out_num,
    215         };
    216         do {
    217             ret = sendmsg(vubr->backend_udp_sock, &msg, 0);
    218         } while (ret == -1 && (errno == EAGAIN || errno == EINTR));
    219 
    220         if (ret == -1) {
    221             vubr_die("sendmsg()");
    222         }
    223 
    224         vu_queue_push(dev, vq, elem, 0);
    225         vu_queue_notify(dev, vq);
    226 
    227         free(elem);
    228         elem = NULL;
    229     }
    230 
    231     free(elem);
    232 }
    233 
    234 
    235 /* this function reverse the effect of iov_discard_front() it must be
    236  * called with 'front' being the original struct iovec and 'bytes'
    237  * being the number of bytes you shaved off
    238  */
    239 static void
    240 iov_restore_front(struct iovec *front, struct iovec *iov, size_t bytes)
    241 {
    242     struct iovec *cur;
    243 
    244     for (cur = front; cur != iov; cur++) {
    245         assert(bytes >= cur->iov_len);
    246         bytes -= cur->iov_len;
    247     }
    248 
    249     cur->iov_base -= bytes;
    250     cur->iov_len += bytes;
    251 }
    252 
    253 static void
    254 iov_truncate(struct iovec *iov, unsigned iovc, size_t bytes)
    255 {
    256     unsigned i;
    257 
    258     for (i = 0; i < iovc; i++, iov++) {
    259         if (bytes < iov->iov_len) {
    260             iov->iov_len = bytes;
    261             return;
    262         }
    263 
    264         bytes -= iov->iov_len;
    265     }
    266 
    267     assert(!"couldn't truncate iov");
    268 }
    269 
    270 static void
    271 vubr_backend_recv_cb(int sock, void *ctx)
    272 {
    273     VubrDev *vubr = (VubrDev *) ctx;
    274     VuDev *dev = &vubr->vudev;
    275     VuVirtq *vq = vu_get_queue(dev, 0);
    276     VuVirtqElement *elem = NULL;
    277     struct iovec mhdr_sg[VIRTQUEUE_MAX_SIZE];
    278     struct virtio_net_hdr_mrg_rxbuf mhdr;
    279     unsigned mhdr_cnt = 0;
    280     int hdrlen = vubr->hdrlen;
    281     int i = 0;
    282     struct virtio_net_hdr hdr = {
    283         .flags = 0,
    284         .gso_type = VIRTIO_NET_HDR_GSO_NONE
    285     };
    286 
    287     DPRINT("\n\n   ***   IN UDP RECEIVE CALLBACK    ***\n\n");
    288     DPRINT("    hdrlen = %d\n", hdrlen);
    289 
    290     if (!vu_queue_enabled(dev, vq) ||
    291         !vu_queue_started(dev, vq) ||
    292         !vu_queue_avail_bytes(dev, vq, hdrlen, 0)) {
    293         DPRINT("Got UDP packet, but no available descriptors on RX virtq.\n");
    294         return;
    295     }
    296 
    297     while (1) {
    298         struct iovec *sg;
    299         ssize_t ret, total = 0;
    300         unsigned int num;
    301 
    302         elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
    303         if (!elem) {
    304             break;
    305         }
    306 
    307         if (elem->in_num < 1) {
    308             fprintf(stderr, "virtio-net contains no in buffers\n");
    309             break;
    310         }
    311 
    312         sg = elem->in_sg;
    313         num = elem->in_num;
    314         if (i == 0) {
    315             if (hdrlen == 12) {
    316                 mhdr_cnt = iov_copy(mhdr_sg, ARRAY_SIZE(mhdr_sg),
    317                                     sg, elem->in_num,
    318                                     offsetof(typeof(mhdr), num_buffers),
    319                                     sizeof(mhdr.num_buffers));
    320             }
    321             iov_from_buf(sg, elem->in_num, 0, &hdr, sizeof hdr);
    322             total += hdrlen;
    323             ret = iov_discard_front(&sg, &num, hdrlen);
    324             assert(ret == hdrlen);
    325         }
    326 
    327         struct msghdr msg = {
    328             .msg_name = (struct sockaddr *) &vubr->backend_udp_dest,
    329             .msg_namelen = sizeof(struct sockaddr_in),
    330             .msg_iov = sg,
    331             .msg_iovlen = num,
    332             .msg_flags = MSG_DONTWAIT,
    333         };
    334         do {
    335             ret = recvmsg(vubr->backend_udp_sock, &msg, 0);
    336         } while (ret == -1 && (errno == EINTR));
    337 
    338         if (i == 0) {
    339             iov_restore_front(elem->in_sg, sg, hdrlen);
    340         }
    341 
    342         if (ret == -1) {
    343             if (errno == EWOULDBLOCK) {
    344                 vu_queue_rewind(dev, vq, 1);
    345                 break;
    346             }
    347 
    348             vubr_die("recvmsg()");
    349         }
    350 
    351         total += ret;
    352         iov_truncate(elem->in_sg, elem->in_num, total);
    353         vu_queue_fill(dev, vq, elem, total, i++);
    354 
    355         free(elem);
    356         elem = NULL;
    357 
    358         break;        /* could loop if DONTWAIT worked? */
    359     }
    360 
    361     if (mhdr_cnt) {
    362         mhdr.num_buffers = i;
    363         iov_from_buf(mhdr_sg, mhdr_cnt,
    364                      0,
    365                      &mhdr.num_buffers, sizeof mhdr.num_buffers);
    366     }
    367 
    368     vu_queue_flush(dev, vq, i);
    369     vu_queue_notify(dev, vq);
    370 
    371     free(elem);
    372 }
    373 
    374 static void
    375 vubr_receive_cb(int sock, void *ctx)
    376 {
    377     VubrDev *vubr = (VubrDev *)ctx;
    378 
    379     if (!vu_dispatch(&vubr->vudev)) {
    380         fprintf(stderr, "Error while dispatching\n");
    381     }
    382 }
    383 
    384 typedef struct WatchData {
    385     VuDev *dev;
    386     vu_watch_cb cb;
    387     void *data;
    388 } WatchData;
    389 
    390 static void
    391 watch_cb(int sock, void *ctx)
    392 {
    393     struct WatchData *wd = ctx;
    394 
    395     wd->cb(wd->dev, VU_WATCH_IN, wd->data);
    396 }
    397 
    398 static void
    399 vubr_set_watch(VuDev *dev, int fd, int condition,
    400                vu_watch_cb cb, void *data)
    401 {
    402     VubrDev *vubr = container_of(dev, VubrDev, vudev);
    403     static WatchData watches[FD_SETSIZE];
    404     struct WatchData *wd = &watches[fd];
    405 
    406     wd->cb = cb;
    407     wd->data = data;
    408     wd->dev = dev;
    409     dispatcher_add(&vubr->dispatcher, fd, wd, watch_cb);
    410 }
    411 
    412 static void
    413 vubr_remove_watch(VuDev *dev, int fd)
    414 {
    415     VubrDev *vubr = container_of(dev, VubrDev, vudev);
    416 
    417     dispatcher_remove(&vubr->dispatcher, fd);
    418 }
    419 
    420 static int
    421 vubr_send_rarp_exec(VuDev *dev, VhostUserMsg *vmsg)
    422 {
    423     DPRINT("Function %s() not implemented yet.\n", __func__);
    424     return 0;
    425 }
    426 
    427 static int
    428 vubr_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
    429 {
    430     switch (vmsg->request) {
    431     case VHOST_USER_SEND_RARP:
    432         *do_reply = vubr_send_rarp_exec(dev, vmsg);
    433         return 1;
    434     default:
    435         /* let the library handle the rest */
    436         return 0;
    437     }
    438 
    439     return 0;
    440 }
    441 
    442 static void
    443 vubr_set_features(VuDev *dev, uint64_t features)
    444 {
    445     VubrDev *vubr = container_of(dev, VubrDev, vudev);
    446 
    447     if ((features & (1ULL << VIRTIO_F_VERSION_1)) ||
    448         (features & (1ULL << VIRTIO_NET_F_MRG_RXBUF))) {
    449         vubr->hdrlen = 12;
    450     } else {
    451         vubr->hdrlen = 10;
    452     }
    453 }
    454 
    455 static uint64_t
    456 vubr_get_features(VuDev *dev)
    457 {
    458     return 1ULL << VIRTIO_NET_F_GUEST_ANNOUNCE |
    459         1ULL << VIRTIO_NET_F_MRG_RXBUF |
    460         1ULL << VIRTIO_F_VERSION_1;
    461 }
    462 
    463 static void
    464 vubr_queue_set_started(VuDev *dev, int qidx, bool started)
    465 {
    466     VubrDev *vubr = container_of(dev, VubrDev, vudev);
    467     VuVirtq *vq = vu_get_queue(dev, qidx);
    468 
    469     if (started && vubr->notifier.fd >= 0) {
    470         vu_set_queue_host_notifier(dev, vq, vubr->notifier.fd,
    471                                    qemu_real_host_page_size(),
    472                                    qidx * qemu_real_host_page_size());
    473     }
    474 
    475     if (qidx % 2 == 1) {
    476         vu_set_queue_handler(dev, vq, started ? vubr_handle_tx : NULL);
    477     }
    478 }
    479 
    480 static void
    481 vubr_panic(VuDev *dev, const char *msg)
    482 {
    483     VubrDev *vubr = container_of(dev, VubrDev, vudev);
    484 
    485     fprintf(stderr, "PANIC: %s\n", msg);
    486 
    487     dispatcher_remove(&vubr->dispatcher, dev->sock);
    488     vubr->quit = 1;
    489 }
    490 
    491 static bool
    492 vubr_queue_is_processed_in_order(VuDev *dev, int qidx)
    493 {
    494     return true;
    495 }
    496 
    497 static const VuDevIface vuiface = {
    498     .get_features = vubr_get_features,
    499     .set_features = vubr_set_features,
    500     .process_msg = vubr_process_msg,
    501     .queue_set_started = vubr_queue_set_started,
    502     .queue_is_processed_in_order = vubr_queue_is_processed_in_order,
    503 };
    504 
    505 static void
    506 vubr_accept_cb(int sock, void *ctx)
    507 {
    508     VubrDev *dev = (VubrDev *)ctx;
    509     int conn_fd;
    510     struct sockaddr_un un;
    511     socklen_t len = sizeof(un);
    512 
    513     conn_fd = accept(sock, (struct sockaddr *) &un, &len);
    514     if (conn_fd == -1) {
    515         vubr_die("accept()");
    516     }
    517     DPRINT("Got connection from remote peer on sock %d\n", conn_fd);
    518 
    519     if (!vu_init(&dev->vudev,
    520                  VHOST_USER_BRIDGE_MAX_QUEUES,
    521                  conn_fd,
    522                  vubr_panic,
    523                  NULL,
    524                  vubr_set_watch,
    525                  vubr_remove_watch,
    526                  &vuiface)) {
    527         fprintf(stderr, "Failed to initialize libvhost-user\n");
    528         exit(1);
    529     }
    530 
    531     dispatcher_add(&dev->dispatcher, conn_fd, ctx, vubr_receive_cb);
    532     dispatcher_remove(&dev->dispatcher, sock);
    533 }
    534 
    535 static VubrDev *
    536 vubr_new(const char *path, bool client)
    537 {
    538     VubrDev *dev = (VubrDev *) calloc(1, sizeof(VubrDev));
    539     struct sockaddr_un un;
    540     CallbackFunc cb;
    541     size_t len;
    542 
    543     if (strlen(path) >= sizeof(un.sun_path)) {
    544         fprintf(stderr, "unix domain socket path '%s' is too long\n", path);
    545         exit(1);
    546     }
    547 
    548     /* Get a UNIX socket. */
    549     dev->sock = socket(AF_UNIX, SOCK_STREAM, 0);
    550     if (dev->sock == -1) {
    551         vubr_die("socket");
    552     }
    553 
    554     dev->notifier.fd = -1;
    555 
    556     un.sun_family = AF_UNIX;
    557     strcpy(un.sun_path, path);
    558     len = sizeof(un.sun_family) + strlen(path);
    559 
    560     if (!client) {
    561         unlink(path);
    562 
    563         if (bind(dev->sock, (struct sockaddr *) &un, len) == -1) {
    564             vubr_die("bind");
    565         }
    566 
    567         if (listen(dev->sock, 1) == -1) {
    568             vubr_die("listen");
    569         }
    570         cb = vubr_accept_cb;
    571 
    572         DPRINT("Waiting for connections on UNIX socket %s ...\n", path);
    573     } else {
    574         if (connect(dev->sock, (struct sockaddr *)&un, len) == -1) {
    575             vubr_die("connect");
    576         }
    577 
    578         if (!vu_init(&dev->vudev,
    579                      VHOST_USER_BRIDGE_MAX_QUEUES,
    580                      dev->sock,
    581                      vubr_panic,
    582                      NULL,
    583                      vubr_set_watch,
    584                      vubr_remove_watch,
    585                      &vuiface)) {
    586             fprintf(stderr, "Failed to initialize libvhost-user\n");
    587             exit(1);
    588         }
    589 
    590         cb = vubr_receive_cb;
    591     }
    592 
    593     dispatcher_init(&dev->dispatcher);
    594 
    595     dispatcher_add(&dev->dispatcher, dev->sock, (void *)dev, cb);
    596 
    597     return dev;
    598 }
    599 
    600 static void *notifier_thread(void *arg)
    601 {
    602     VuDev *dev = (VuDev *)arg;
    603     VubrDev *vubr = container_of(dev, VubrDev, vudev);
    604     int pagesize = qemu_real_host_page_size();
    605     int qidx;
    606 
    607     while (true) {
    608         for (qidx = 0; qidx < VHOST_USER_BRIDGE_MAX_QUEUES; qidx++) {
    609             uint16_t *n = vubr->notifier.addr + pagesize * qidx;
    610 
    611             if (*n == qidx) {
    612                 *n = 0xffff;
    613                 /* We won't miss notifications if we reset
    614                  * the memory first. */
    615                 smp_mb();
    616 
    617                 DPRINT("Got a notification for queue%d via host notifier.\n",
    618                        qidx);
    619 
    620                 if (qidx % 2 == 1) {
    621                     vubr_handle_tx(dev, qidx);
    622                 }
    623             }
    624             usleep(1000);
    625         }
    626     }
    627 
    628     return NULL;
    629 }
    630 
    631 static void
    632 vubr_host_notifier_setup(VubrDev *dev)
    633 {
    634     pthread_t thread;
    635     size_t length;
    636     void *addr;
    637     int fd;
    638 
    639     length = qemu_real_host_page_size() * VHOST_USER_BRIDGE_MAX_QUEUES;
    640 
    641     fd = g_file_open_tmp("vubr-XXXXXX", NULL, NULL);
    642     if (fd < 0) {
    643         vubr_die("mkstemp()");
    644     }
    645 
    646     if (posix_fallocate(fd, 0, length) != 0) {
    647         vubr_die("posix_fallocate()");
    648     }
    649 
    650     addr = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    651     if (addr == MAP_FAILED) {
    652         vubr_die("mmap()");
    653     }
    654 
    655     memset(addr, 0xff, length);
    656 
    657     if (pthread_create(&thread, NULL, notifier_thread, &dev->vudev) != 0) {
    658         vubr_die("pthread_create()");
    659     }
    660 
    661     dev->notifier.fd = fd;
    662     dev->notifier.addr = addr;
    663     dev->notifier.thread = thread;
    664 }
    665 
    666 static void
    667 vubr_set_host(struct sockaddr_in *saddr, const char *host)
    668 {
    669     if (qemu_isdigit(host[0])) {
    670         if (!inet_aton(host, &saddr->sin_addr)) {
    671             fprintf(stderr, "inet_aton() failed.\n");
    672             exit(1);
    673         }
    674     } else {
    675         struct hostent *he = gethostbyname(host);
    676 
    677         if (!he) {
    678             fprintf(stderr, "gethostbyname() failed.\n");
    679             exit(1);
    680         }
    681         saddr->sin_addr = *(struct in_addr *)he->h_addr;
    682     }
    683 }
    684 
    685 static void
    686 vubr_backend_udp_setup(VubrDev *dev,
    687                        const char *local_host,
    688                        const char *local_port,
    689                        const char *remote_host,
    690                        const char *remote_port)
    691 {
    692     int sock;
    693     const char *r;
    694 
    695     int lport, rport;
    696 
    697     lport = strtol(local_port, (char **)&r, 0);
    698     if (r == local_port) {
    699         fprintf(stderr, "lport parsing failed.\n");
    700         exit(1);
    701     }
    702 
    703     rport = strtol(remote_port, (char **)&r, 0);
    704     if (r == remote_port) {
    705         fprintf(stderr, "rport parsing failed.\n");
    706         exit(1);
    707     }
    708 
    709     struct sockaddr_in si_local = {
    710         .sin_family = AF_INET,
    711         .sin_port = htons(lport),
    712     };
    713 
    714     vubr_set_host(&si_local, local_host);
    715 
    716     /* setup destination for sends */
    717     dev->backend_udp_dest = (struct sockaddr_in) {
    718         .sin_family = AF_INET,
    719         .sin_port = htons(rport),
    720     };
    721     vubr_set_host(&dev->backend_udp_dest, remote_host);
    722 
    723     sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    724     if (sock == -1) {
    725         vubr_die("socket");
    726     }
    727 
    728     if (bind(sock, (struct sockaddr *)&si_local, sizeof(si_local)) == -1) {
    729         vubr_die("bind");
    730     }
    731 
    732     dev->backend_udp_sock = sock;
    733     dispatcher_add(&dev->dispatcher, sock, dev, vubr_backend_recv_cb);
    734     DPRINT("Waiting for data from udp backend on %s:%d...\n",
    735            local_host, lport);
    736 }
    737 
    738 static void
    739 vubr_run(VubrDev *dev)
    740 {
    741     while (!dev->quit) {
    742         /* timeout 200ms */
    743         dispatcher_wait(&dev->dispatcher, 200000);
    744         /* Here one can try polling strategy. */
    745     }
    746 }
    747 
    748 static int
    749 vubr_parse_host_port(const char **host, const char **port, const char *buf)
    750 {
    751     char *p = strchr(buf, ':');
    752 
    753     if (!p) {
    754         return -1;
    755     }
    756     *p = '\0';
    757     *host = strdup(buf);
    758     *port = strdup(p + 1);
    759     return 0;
    760 }
    761 
    762 #define DEFAULT_UD_SOCKET "/tmp/vubr.sock"
    763 #define DEFAULT_LHOST "127.0.0.1"
    764 #define DEFAULT_LPORT "4444"
    765 #define DEFAULT_RHOST "127.0.0.1"
    766 #define DEFAULT_RPORT "5555"
    767 
    768 static const char *ud_socket_path = DEFAULT_UD_SOCKET;
    769 static const char *lhost = DEFAULT_LHOST;
    770 static const char *lport = DEFAULT_LPORT;
    771 static const char *rhost = DEFAULT_RHOST;
    772 static const char *rport = DEFAULT_RPORT;
    773 
    774 int
    775 main(int argc, char *argv[])
    776 {
    777     VubrDev *dev;
    778     int opt;
    779     bool client = false;
    780     bool host_notifier = false;
    781 
    782     while ((opt = getopt(argc, argv, "l:r:u:cH")) != -1) {
    783 
    784         switch (opt) {
    785         case 'l':
    786             if (vubr_parse_host_port(&lhost, &lport, optarg) < 0) {
    787                 goto out;
    788             }
    789             break;
    790         case 'r':
    791             if (vubr_parse_host_port(&rhost, &rport, optarg) < 0) {
    792                 goto out;
    793             }
    794             break;
    795         case 'u':
    796             ud_socket_path = strdup(optarg);
    797             break;
    798         case 'c':
    799             client = true;
    800             break;
    801         case 'H':
    802             host_notifier = true;
    803             break;
    804         default:
    805             goto out;
    806         }
    807     }
    808 
    809     DPRINT("ud socket: %s (%s)\n", ud_socket_path,
    810            client ? "client" : "server");
    811     DPRINT("local:     %s:%s\n", lhost, lport);
    812     DPRINT("remote:    %s:%s\n", rhost, rport);
    813 
    814     dev = vubr_new(ud_socket_path, client);
    815     if (!dev) {
    816         return 1;
    817     }
    818 
    819     if (host_notifier) {
    820         vubr_host_notifier_setup(dev);
    821     }
    822 
    823     vubr_backend_udp_setup(dev, lhost, lport, rhost, rport);
    824     vubr_run(dev);
    825 
    826     vu_deinit(&dev->vudev);
    827 
    828     return 0;
    829 
    830 out:
    831     fprintf(stderr, "Usage: %s ", argv[0]);
    832     fprintf(stderr, "[-c] [-H] [-u ud_socket_path] [-l lhost:lport] [-r rhost:rport]\n");
    833     fprintf(stderr, "\t-u path to unix domain socket. default: %s\n",
    834             DEFAULT_UD_SOCKET);
    835     fprintf(stderr, "\t-l local host and port. default: %s:%s\n",
    836             DEFAULT_LHOST, DEFAULT_LPORT);
    837     fprintf(stderr, "\t-r remote host and port. default: %s:%s\n",
    838             DEFAULT_RHOST, DEFAULT_RPORT);
    839     fprintf(stderr, "\t-c client mode\n");
    840     fprintf(stderr, "\t-H use host notifier\n");
    841 
    842     return 1;
    843 }
	qemu FORK: QEMU emulator
	git clone https://git.neptards.moe/neptards/qemu.git
	Log \| Files \| Refs \| Submodules \| LICENSE