sys/dev/virtual/vkernel/net/if_vke.c

   1 /*
   2  * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Sepherosa Ziehau <sepherosa@gmail.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/param.h>
  36 #include <sys/endian.h>
  37 #include <sys/kernel.h>
  38 #include <sys/malloc.h>
  39 #include <sys/proc.h>
  40 #include <sys/serialize.h>
  41 #include <sys/socket.h>
  42 #include <sys/sockio.h>
  43 #include <sys/sysctl.h>
  44
  45 #include <machine/md_var.h>
  46 #include <machine/cothread.h>
  47
  48 #include <net/ethernet.h>
  49 #include <net/if.h>
  50 #include <net/bpf.h>
  51 #include <net/if_arp.h>
  52 #include <net/ifq_var.h>
  53
  54 #include <netinet/in_var.h>
  55
  56 #include <sys/stat.h>
  57 #include <net/tap/if_tap.h>
  58 #include <err.h>
  59 #include <errno.h>
  60 #include <stdio.h>
  61 #include <string.h>
  62 #include <unistd.h>
  63 #include <fcntl.h>
  64
  65 #define VKE_DEVNAME             "vke"
  66
  67 #define VKE_CHUNK       8 /* number of mbufs to queue before interrupting */
  68
  69 #define NETFIFOSIZE     256
  70 #define NETFIFOMASK     (NETFIFOSIZE -1)
  71 #define NETFIFOINDEX(u) ((u) & NETFIFOMASK)
  72
  73 #define VKE_COTD_RUN    0
  74 #define VKE_COTD_EXIT   1
  75 #define VKE_COTD_DEAD   2
  76
  77 struct vke_fifo {
  78         struct mbuf     *array[NETFIFOSIZE];
  79         int             rindex;
  80         int             windex;
  81 };
  82 typedef struct vke_fifo *fifo_t;
  83
  84 struct vke_softc {
  85         struct arpcom           arpcom;
  86         int                     sc_fd;
  87         int                     sc_unit;
  88
  89         cothread_t              cotd_tx;
  90         cothread_t              cotd_rx;
  91
  92         int                     cotd_tx_exit;
  93         int                     cotd_rx_exit;
  94
  95         void                    *sc_txbuf;
  96         int                     sc_txbuf_len;
  97
  98         fifo_t                  sc_txfifo;
  99         fifo_t                  sc_txfifo_done;
 100         fifo_t                  sc_rxfifo;
 101
 102         struct sysctl_ctx_list  sc_sysctl_ctx;
 103         struct sysctl_oid       *sc_sysctl_tree;
 104
 105         int                     sc_tap_unit;    /* unit of backend tap(4) */
 106         in_addr_t               sc_addr;        /* address */
 107         in_addr_t               sc_mask;        /* netmask */
 108 };
 109
 110 static void     vke_start(struct ifnet *);
 111 static void     vke_init(void *);
 112 static int      vke_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
 113
 114 static int      vke_attach(const struct vknetif_info *, int);
 115 static int      vke_stop(struct vke_softc *);
 116 static int      vke_init_addr(struct ifnet *, in_addr_t, in_addr_t);
 117 static void     vke_tx_intr(cothread_t cotd);
 118 static void     vke_tx_thread(cothread_t cotd);
 119 static void     vke_rx_intr(cothread_t cotd);
 120 static void     vke_rx_thread(cothread_t cotd);
 121
 122 static int vke_txfifo_enqueue(struct vke_softc *sc, struct mbuf *m);
 123 static struct mbuf *vke_txfifo_dequeue(struct vke_softc *sc);
 124
 125 static int vke_txfifo_done_enqueue(struct vke_softc *sc, struct mbuf *m);
 126 static struct mbuf * vke_txfifo_done_dequeue(struct vke_softc *sc, struct mbuf *nm);
 127
 128 static struct mbuf *vke_rxfifo_dequeue(struct vke_softc *sc, struct mbuf *nm);
 129 static struct mbuf *vke_rxfifo_sniff(struct vke_softc *sc);
 130
 131 static void
 132 vke_sysinit(void *arg __unused)
 133 {
 134         int i, unit;
 135
 136         KASSERT(NetifNum <= VKNETIF_MAX, ("too many netifs: %d", NetifNum));
 137
 138         unit = 0;
 139         for (i = 0; i < NetifNum; ++i) {
 140                 if (vke_attach(&NetifInfo[i], unit) == 0)
 141                         ++unit;
 142         }
 143 }
 144 SYSINIT(vke, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, vke_sysinit, NULL);
 145
 146 /*
 147  * vke_txfifo_done_enqueue() - Add an mbuf to the transmit done fifo.  Since
 148  * the cothread cannot free transmit mbufs after processing we put them on
 149  * the done fifo so the kernel can free them.
 150  */
 151 static int
 152 vke_txfifo_done_enqueue(struct vke_softc *sc, struct mbuf *m)
 153 {
 154         fifo_t fifo = sc->sc_txfifo_done;
 155
 156         while (NETFIFOINDEX(fifo->windex + 1) == NETFIFOINDEX(fifo->rindex)) {
 157                 usleep(20000);
 158         }
 159
 160         fifo->array[NETFIFOINDEX(fifo->windex)] = m;
 161         cpu_sfence();
 162         ++fifo->windex;
 163         return (0);
 164 }
 165
 166 /*
 167  * vke_txfifo_done_dequeue() - Remove an mbuf from the transmit done fifo.
 168  */
 169 static struct mbuf *
 170 vke_txfifo_done_dequeue(struct vke_softc *sc, struct mbuf *nm)
 171 {
 172         fifo_t fifo = sc->sc_txfifo_done;
 173         struct mbuf *m;
 174
 175         if (NETFIFOINDEX(fifo->rindex) == NETFIFOINDEX(fifo->windex))
 176                 return (NULL);
 177
 178         m = fifo->array[NETFIFOINDEX(fifo->rindex)];
 179         fifo->array[NETFIFOINDEX(fifo->rindex)] = nm;
 180         cpu_lfence();
 181         ++fifo->rindex;
 182         return (m);
 183 }
 184
 185 /*
 186  * vke_txfifo_enqueue() - Add an mbuf to the transmit fifo.
 187  */
 188 static int
 189 vke_txfifo_enqueue(struct vke_softc *sc, struct mbuf *m)
 190 {
 191         fifo_t fifo = sc->sc_txfifo;
 192
 193         if (NETFIFOINDEX(fifo->windex + 1) == NETFIFOINDEX(fifo->rindex))
 194                 return (-1);
 195
 196         fifo->array[NETFIFOINDEX(fifo->windex)] = m;
 197         cpu_sfence();
 198         ++fifo->windex;
 199
 200         return (0);
 201 }
 202
 203 /*
 204  * vke_txfifo_dequeue() - Return next mbuf on the transmit fifo if one
 205  * exists.
 206  */
 207 static struct mbuf *
 208 vke_txfifo_dequeue(struct vke_softc *sc)
 209 {
 210         fifo_t fifo = sc->sc_txfifo;
 211         struct mbuf *m;
 212
 213         if (NETFIFOINDEX(fifo->rindex) == NETFIFOINDEX(fifo->windex))
 214                 return (NULL);
 215
 216         m = fifo->array[NETFIFOINDEX(fifo->rindex)];
 217         fifo->array[NETFIFOINDEX(fifo->rindex)] = NULL;
 218
 219         cpu_lfence();
 220         ++fifo->rindex;
 221         return (m);
 222 }
 223
 224 static int
 225 vke_txfifo_empty(struct vke_softc *sc)
 226 {
 227         fifo_t fifo = sc->sc_txfifo;
 228
 229         if (NETFIFOINDEX(fifo->rindex) == NETFIFOINDEX(fifo->windex))
 230                 return (1);
 231         return(0);
 232 }
 233
 234 /*
 235  * vke_rxfifo_dequeue() - Return next mbuf on the receice fifo if one
 236  * exists replacing it with newm which should point to a newly allocated
 237  * mbuf.
 238  */
 239 static struct mbuf *
 240 vke_rxfifo_dequeue(struct vke_softc *sc, struct mbuf *newm)
 241 {
 242         fifo_t fifo = sc->sc_rxfifo;
 243         struct mbuf *m;
 244
 245         if (NETFIFOINDEX(fifo->rindex) == NETFIFOINDEX(fifo->windex))
 246                 return (NULL);
 247
 248         m = fifo->array[NETFIFOINDEX(fifo->rindex)];
 249         fifo->array[NETFIFOINDEX(fifo->rindex)] = newm;
 250         cpu_lfence();
 251         ++fifo->rindex;
 252         return (m);
 253 }
 254
 255 /*
 256  * Return the next mbuf if available but do NOT remove it from the FIFO.
 257  */
 258 static struct mbuf *
 259 vke_rxfifo_sniff(struct vke_softc *sc)
 260 {
 261         fifo_t fifo = sc->sc_rxfifo;
 262         struct mbuf *m;
 263
 264         if (NETFIFOINDEX(fifo->rindex) == NETFIFOINDEX(fifo->windex))
 265                 return (NULL);
 266
 267         m = fifo->array[NETFIFOINDEX(fifo->rindex)];
 268         cpu_lfence();
 269         return (m);
 270 }
 271
 272 static void
 273 vke_init(void *xsc)
 274 {
 275         struct vke_softc *sc = xsc;
 276         struct ifnet *ifp = &sc->arpcom.ac_if;
 277         int i;
 278
 279         ASSERT_SERIALIZED(ifp->if_serializer);
 280
 281         vke_stop(sc);
 282
 283         ifp->if_flags |= IFF_RUNNING;
 284         ifp->if_flags &= ~IFF_OACTIVE;
 285
 286         sc->sc_txfifo = kmalloc(sizeof(*sc->sc_txfifo), M_DEVBUF, M_WAITOK);
 287         sc->sc_txfifo_done = kmalloc(sizeof(*sc->sc_txfifo_done), M_DEVBUF, M_WAITOK);
 288
 289         sc->sc_rxfifo = kmalloc(sizeof(*sc->sc_rxfifo), M_DEVBUF, M_WAITOK);
 290         for (i = 0; i < NETFIFOSIZE; i++) {
 291                 sc->sc_rxfifo->array[i] = m_getcl(MB_WAIT, MT_DATA, M_PKTHDR);
 292                 sc->sc_txfifo->array[i] = NULL;
 293                 sc->sc_txfifo_done->array[i] = NULL;
 294         }
 295
 296         sc->cotd_tx_exit = sc->cotd_rx_exit = VKE_COTD_RUN;
 297         sc->cotd_tx = cothread_create(vke_tx_thread, vke_tx_intr, sc, "vke_tx");
 298         sc->cotd_rx = cothread_create(vke_rx_thread, vke_rx_intr, sc, "vke_rx");
 299
 300         if (sc->sc_addr != 0) {
 301                 in_addr_t addr, mask;
 302
 303                 addr = sc->sc_addr;
 304                 mask = sc->sc_mask;
 305
 306                 /*
 307                  * Make sure vkernel assigned
 308                  * address will not be added
 309                  * again.
 310                  */
 311                 sc->sc_addr = 0;
 312                 sc->sc_mask = 0;
 313
 314                 vke_init_addr(ifp, addr, mask);
 315         }
 316
 317 }
 318
 319 /*
 320  * Called from kernel.
 321  *
 322  * NOTE: We can't make any kernel callbacks while holding cothread lock
 323  *       because the cothread lock is not governed by the kernel scheduler
 324  *       (so mplock, tokens, etc will not be released).
 325  */
 326 static void
 327 vke_start(struct ifnet *ifp)
 328 {
 329         struct vke_softc *sc = ifp->if_softc;
 330         struct mbuf *m;
 331         cothread_t cotd = sc->cotd_tx;
 332         int count;
 333
 334         ASSERT_SERIALIZED(ifp->if_serializer);
 335
 336         if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
 337                 return;
 338
 339         count = 0;
 340         while ((m = ifq_dequeue(&ifp->if_snd, NULL)) != NULL) {
 341                 if (vke_txfifo_enqueue(sc, m) != -1) {
 342                         if (count++ == VKE_CHUNK) {
 343                                 cothread_lock(cotd, 0);
 344                                 cothread_signal(cotd);
 345                                 cothread_unlock(cotd, 0);
 346                                 count = 0;
 347                         }
 348                 } else {
 349                         m_freem(m);
 350                 }
 351         }
 352         if (count) {
 353                 cothread_lock(cotd, 0);
 354                 cothread_signal(cotd);
 355                 cothread_unlock(cotd, 0);
 356         }
 357 }
 358
 359 static int
 360 vke_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
 361 {
 362         struct vke_softc *sc = ifp->if_softc;
 363         int error = 0;
 364
 365         ASSERT_SERIALIZED(ifp->if_serializer);
 366
 367         switch (cmd) {
 368         case SIOCSIFFLAGS:
 369                 if (ifp->if_flags & IFF_UP) {
 370                         if ((ifp->if_flags & IFF_RUNNING) == 0)
 371                                 vke_init(sc);
 372                 } else {
 373                         if (ifp->if_flags & IFF_RUNNING)
 374                                 vke_stop(sc);
 375                 }
 376                 break;
 377         case SIOCGIFMEDIA:
 378         case SIOCSIFMEDIA:
 379                 error = EOPNOTSUPP;
 380                 /* TODO */
 381                 break;
 382         case SIOCGIFSTATUS: {
 383                 struct ifstat *ifs = (struct ifstat *)data;
 384                 int len;
 385
 386                 len = strlen(ifs->ascii);
 387                 if (len < sizeof(ifs->ascii)) {
 388                         ksnprintf(ifs->ascii + len, sizeof(ifs->ascii) - len,
 389                                   "\tBacked by tap%d\n", sc->sc_tap_unit);
 390                 }
 391                 break;
 392         }
 393         case SIOCSIFADDR:
 394                 if (((struct ifaddr *)data)->ifa_addr->sa_family == AF_INET) {
 395                         /*
 396                          * If we are explicitly requested to change address,
 397                          * we should invalidate address/netmask passed in
 398                          * from vkernel command line.
 399                          */
 400                         sc->sc_addr = 0;
 401                         sc->sc_mask = 0;
 402                 }
 403                 /* FALL THROUGH */
 404         default:
 405                 error = ether_ioctl(ifp, cmd, data);
 406                 break;
 407         }
 408         return error;
 409 }
 410
 411 static int
 412 vke_stop(struct vke_softc *sc)
 413 {
 414         struct ifnet *ifp = &sc->arpcom.ac_if;
 415         int i;
 416
 417         ASSERT_SERIALIZED(ifp->if_serializer);
 418
 419         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 420
 421         if (sc) {
 422                 if (sc->cotd_tx) {
 423                         cothread_lock(sc->cotd_tx, 0);
 424                         if (sc->cotd_tx_exit == VKE_COTD_RUN)
 425                                 sc->cotd_tx_exit = VKE_COTD_EXIT;
 426                         cothread_signal(sc->cotd_tx);
 427                         cothread_unlock(sc->cotd_tx, 0);
 428                         cothread_delete(&sc->cotd_tx);
 429                 }
 430                 if (sc->cotd_rx) {
 431                         cothread_lock(sc->cotd_rx, 0);
 432                         if (sc->cotd_rx_exit == VKE_COTD_RUN)
 433                                 sc->cotd_rx_exit = VKE_COTD_EXIT;
 434                         cothread_signal(sc->cotd_rx);
 435                         cothread_unlock(sc->cotd_rx, 0);
 436                         cothread_delete(&sc->cotd_rx);
 437                 }
 438
 439                 for (i = 0; i < NETFIFOSIZE; i++) {
 440                         if (sc->sc_rxfifo && sc->sc_rxfifo->array[i]) {
 441                                 m_freem(sc->sc_rxfifo->array[i]);
 442                                 sc->sc_rxfifo->array[i] = NULL;
 443                         }
 444                         if (sc->sc_txfifo && sc->sc_txfifo->array[i]) {
 445                                 m_freem(sc->sc_txfifo->array[i]);
 446                                 sc->sc_txfifo->array[i] = NULL;
 447                         }
 448                         if (sc->sc_txfifo_done && sc->sc_txfifo_done->array[i]) {
 449                                 m_freem(sc->sc_txfifo_done->array[i]);
 450                                 sc->sc_txfifo_done->array[i] = NULL;
 451                         }
 452                 }
 453
 454                 if (sc->sc_txfifo) {
 455                         kfree(sc->sc_txfifo, M_DEVBUF);
 456                         sc->sc_txfifo = NULL;
 457                 }
 458
 459                 if (sc->sc_txfifo_done) {
 460                         kfree(sc->sc_txfifo_done, M_DEVBUF);
 461                         sc->sc_txfifo_done = NULL;
 462                 }
 463
 464                 if (sc->sc_rxfifo) {
 465                         kfree(sc->sc_rxfifo, M_DEVBUF);
 466                         sc->sc_rxfifo = NULL;
 467                 }
 468         }
 469
 470
 471         return 0;
 472 }
 473
 474 /*
 475  * vke_rx_intr() is the interrupt function for the receive cothread.
 476  */
 477 static void
 478 vke_rx_intr(cothread_t cotd)
 479 {
 480         struct mbuf *m;
 481         struct mbuf *nm;
 482         struct vke_softc *sc = cotd->arg;
 483         struct ifnet *ifp = &sc->arpcom.ac_if;
 484         static int count = 0;
 485
 486         ifnet_serialize_all(ifp);
 487         cothread_lock(cotd, 0);
 488
 489         if (sc->cotd_rx_exit != VKE_COTD_RUN) {
 490                 cothread_unlock(cotd, 0);
 491                 ifnet_deserialize_all(ifp);
 492                 return;
 493         }
 494         cothread_unlock(cotd, 0);
 495
 496         while ((m = vke_rxfifo_sniff(sc)) != NULL) {
 497                 nm = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
 498                 if (nm) {
 499                         vke_rxfifo_dequeue(sc, nm);
 500                         ifp->if_input(ifp, m);
 501                         if (count++ == VKE_CHUNK) {
 502                                 cothread_lock(cotd, 0);
 503                                 cothread_signal(cotd);
 504                                 cothread_unlock(cotd, 0);
 505                                 count = 0;
 506                         }
 507                 } else {
 508                         vke_rxfifo_dequeue(sc, m);
 509                 }
 510         }
 511
 512         if (count) {
 513                 cothread_lock(cotd, 0);
 514                 cothread_signal(cotd);
 515                 cothread_unlock(cotd, 0);
 516         }
 517         ifnet_deserialize_all(ifp);
 518 }
 519
 520 /*
 521  * vke_tx_intr() is the interrupt function for the transmit cothread.
 522  * Calls vke_start() to handle processing transmit mbufs.
 523  */
 524 static void
 525 vke_tx_intr(cothread_t cotd)
 526 {
 527         struct vke_softc *sc = cotd->arg;
 528         struct ifnet *ifp = &sc->arpcom.ac_if;
 529         struct mbuf *m;
 530
 531         ifnet_serialize_all(ifp);
 532         cothread_lock(cotd, 0);
 533         if (sc->cotd_tx_exit != VKE_COTD_RUN) {
 534                 cothread_unlock(cotd, 0);
 535                 ifnet_deserialize_all(ifp);
 536                 return;
 537         }
 538         cothread_unlock(cotd, 0);
 539
 540         /*
 541          * Free TX mbufs that have been processed before starting new
 542          * ones going to be pipeline friendly.
 543          */
 544         while ((m = vke_txfifo_done_dequeue(sc, NULL)) != NULL) {
 545                 m_freem(m);
 546         }
 547
 548         if ((ifp->if_flags & IFF_RUNNING) == 0)
 549                 ifp->if_start(ifp);
 550
 551         ifnet_deserialize_all(ifp);
 552 }
 553
 554 /*
 555  * vke_rx_thread() is the body of the receive cothread.
 556  */
 557 static void
 558 vke_rx_thread(cothread_t cotd)
 559 {
 560         struct mbuf *m;
 561         struct vke_softc *sc = cotd->arg;
 562         struct ifnet *ifp = &sc->arpcom.ac_if;
 563         fifo_t fifo = sc->sc_rxfifo;
 564         fd_set fdset;
 565         struct timeval tv;
 566         int count;
 567         int n;
 568
 569         /* Select timeout cannot be infinite since we need to check for
 570          * the exit flag sc->cotd_rx_exit.
 571          */
 572         tv.tv_sec = 0;
 573         tv.tv_usec = 500000;
 574
 575         FD_ZERO(&fdset);
 576         count = 0;
 577
 578         while (sc->cotd_rx_exit == VKE_COTD_RUN) {
 579                 /*
 580                  * Wait for the RX FIFO to be loaded with
 581                  * empty mbufs.
 582                  */
 583                 if (NETFIFOINDEX(fifo->windex + 1) ==
 584                     NETFIFOINDEX(fifo->rindex)) {
 585                         usleep(20000);
 586                         continue;
 587                 }
 588
 589                 /*
 590                  * Load data into the rx fifo
 591                  */
 592                 m = fifo->array[NETFIFOINDEX(fifo->windex)];
 593                 if (m == NULL)
 594                         continue;
 595                 n = read(sc->sc_fd, mtod(m, void *), MCLBYTES);
 596                 if (n > 0) {
 597                         ifp->if_ipackets++;
 598                         m->m_pkthdr.rcvif = ifp;
 599                         m->m_pkthdr.len = m->m_len = n;
 600                         cpu_sfence();
 601                         ++fifo->windex;
 602                         if (count++ == VKE_CHUNK) {
 603                                 cothread_intr(cotd);
 604                                 count = 0;
 605                         }
 606                 } else {
 607                         if (count) {
 608                                 cothread_intr(cotd);
 609                                 count = 0;
 610                         }
 611                         FD_SET(sc->sc_fd, &fdset);
 612
 613                         if (select(sc->sc_fd + 1, &fdset, NULL, NULL, &tv) == -1) {
 614                                 kprintf(VKE_DEVNAME "%d: select failed for "
 615                                         "TAP device\n", sc->sc_unit);
 616                                 usleep(1000000);
 617                         }
 618                 }
 619         }
 620         cpu_sfence();
 621         sc->cotd_rx_exit = VKE_COTD_DEAD;
 622 }
 623
 624 /*
 625  * vke_tx_thread() is the body of the transmit cothread.
 626  */
 627 static void
 628 vke_tx_thread(cothread_t cotd)
 629 {
 630         struct mbuf *m;
 631         struct vke_softc *sc = cotd->arg;
 632         struct ifnet *ifp = &sc->arpcom.ac_if;
 633         int count = 0;
 634
 635         while (sc->cotd_tx_exit == VKE_COTD_RUN) {
 636                 /*
 637                  * Write outgoing packets to the TAP interface
 638                  */
 639                 m = vke_txfifo_dequeue(sc);
 640                 if (m) {
 641                         if (m->m_pkthdr.len <= MCLBYTES) {
 642                                 m_copydata(m, 0, m->m_pkthdr.len, sc->sc_txbuf);
 643                                 sc->sc_txbuf_len = m->m_pkthdr.len;
 644
 645                                 if (write(sc->sc_fd, sc->sc_txbuf,
 646                                           sc->sc_txbuf_len) < 0) {
 647                                         ifp->if_oerrors++;
 648                                 } else {
 649                                         ifp->if_opackets++;
 650                                 }
 651                         }
 652                         if (count++ == VKE_CHUNK) {
 653                                 cothread_intr(cotd);
 654                                 count = 0;
 655                         }
 656                         vke_txfifo_done_enqueue(sc, m);
 657                 } else {
 658                         if (count) {
 659                                 cothread_intr(cotd);
 660                                 count = 0;
 661                         }
 662                         cothread_lock(cotd, 1);
 663                         if (vke_txfifo_empty(sc))
 664                                 cothread_wait(cotd);
 665                         cothread_unlock(cotd, 1);
 666                 }
 667         }
 668         cpu_sfence();
 669         sc->cotd_tx_exit = VKE_COTD_DEAD;
 670 }
 671
 672 static int
 673 vke_attach(const struct vknetif_info *info, int unit)
 674 {
 675         struct vke_softc *sc;
 676         struct ifnet *ifp;
 677         struct tapinfo tapinfo;
 678         uint8_t enaddr[ETHER_ADDR_LEN];
 679         int fd;
 680
 681         KKASSERT(info->tap_fd >= 0);
 682         fd = info->tap_fd;
 683
 684         /*
 685          * This is only a TAP device if tap_unit is non-zero.  If
 686          * connecting to a virtual socket we generate a unique MAC.
 687          */
 688         if (info->tap_unit >= 0) {
 689                 if (ioctl(fd, TAPGIFINFO, &tapinfo) < 0) {
 690                         kprintf(VKE_DEVNAME "%d: ioctl(TAPGIFINFO) "
 691                                 "failed: %s\n", unit, strerror(errno));
 692                         return ENXIO;
 693                 }
 694
 695                 if (ioctl(fd, SIOCGIFADDR, enaddr) < 0) {
 696                         kprintf(VKE_DEVNAME "%d: ioctl(SIOCGIFADDR) "
 697                                 "failed: %s\n", unit, strerror(errno));
 698                         return ENXIO;
 699                 }
 700         } else {
 701                 int fd = open("/dev/urandom", O_RDONLY);
 702                 if (fd >= 0) {
 703                         read(fd, enaddr + 2, 4);
 704                         close(fd);
 705                 }
 706                 enaddr[4] = (int)getpid() >> 8;
 707                 enaddr[5] = (int)getpid() & 255;
 708
 709         }
 710         enaddr[1] += 1;
 711
 712         sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
 713
 714         sc->sc_txbuf = kmalloc(MCLBYTES, M_DEVBUF, M_WAITOK);
 715         sc->sc_fd = fd;
 716         sc->sc_unit = unit;
 717         sc->sc_tap_unit = info->tap_unit;
 718         sc->sc_addr = info->netif_addr;
 719         sc->sc_mask = info->netif_mask;
 720
 721         ifp = &sc->arpcom.ac_if;
 722         if_initname(ifp, VKE_DEVNAME, sc->sc_unit);
 723
 724         /* NB: after if_initname() */
 725         sysctl_ctx_init(&sc->sc_sysctl_ctx);
 726         sc->sc_sysctl_tree = SYSCTL_ADD_NODE(&sc->sc_sysctl_ctx,
 727                                              SYSCTL_STATIC_CHILDREN(_hw),
 728                                              OID_AUTO, ifp->if_xname,
 729                                              CTLFLAG_RD, 0, "");
 730         if (sc->sc_sysctl_tree == NULL) {
 731                 kprintf(VKE_DEVNAME "%d: can't add sysctl node\n", unit);
 732         } else {
 733                 SYSCTL_ADD_INT(&sc->sc_sysctl_ctx,
 734                                SYSCTL_CHILDREN(sc->sc_sysctl_tree),
 735                                OID_AUTO, "tap_unit",
 736                                CTLFLAG_RD, &sc->sc_tap_unit, 0,
 737                                "Backend tap(4) unit");
 738         }
 739
 740         ifp->if_softc = sc;
 741         ifp->if_ioctl = vke_ioctl;
 742         ifp->if_start = vke_start;
 743         ifp->if_init = vke_init;
 744         ifp->if_mtu = tapinfo.mtu;
 745         ifp->if_baudrate = tapinfo.baudrate;
 746         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 747         ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
 748         ifq_set_ready(&ifp->if_snd);
 749
 750         /* TODO: if_media */
 751
 752         ether_ifattach(ifp, enaddr, NULL);
 753
 754         if (bootverbose && sc->sc_addr != 0) {
 755                 if_printf(ifp, "pre-configured "
 756                           "address 0x%08x, netmask 0x%08x\n",
 757                           ntohl(sc->sc_addr), ntohl(sc->sc_mask));
 758         }
 759
 760         return 0;
 761 }
 762
 763 static int
 764 vke_init_addr(struct ifnet *ifp, in_addr_t addr, in_addr_t mask)
 765 {
 766         struct ifaliasreq ifra;
 767         struct sockaddr_in *sin;
 768         int ret;
 769
 770         ASSERT_SERIALIZED(ifp->if_serializer);
 771
 772         if (bootverbose) {
 773                 if_printf(ifp, "add pre-configured "
 774                           "address 0x%08x, netmask 0x%08x\n",
 775                           ntohl(addr), ntohl(mask));
 776         }
 777
 778         bzero(&ifra, sizeof(ifra));
 779
 780         /* NB: no need to set ifaliasreq.ifra_name */
 781
 782         sin = (struct sockaddr_in *)&ifra.ifra_addr;
 783         sin->sin_family = AF_INET;
 784         sin->sin_len = sizeof(*sin);
 785         sin->sin_addr.s_addr = addr;
 786
 787         if (mask != 0) {
 788                 sin = (struct sockaddr_in *)&ifra.ifra_mask;
 789                 sin->sin_len = sizeof(*sin);
 790                 sin->sin_addr.s_addr = mask;
 791         }
 792
 793         /*
 794          * Temporarily release serializer, in_control() will hold
 795          * it again before calling ifnet.if_ioctl().
 796          */
 797         ifnet_deserialize_all(ifp);
 798         ret = in_control(NULL, SIOCAIFADDR, (caddr_t)&ifra, ifp, NULL);
 799         ifnet_serialize_all(ifp);
 800
 801         return ret;
 802 }