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/if_media.h>
  53 #include <net/ifq_var.h>
  54 #include <net/vlan/if_vlan_ether.h>
  55
  56 #include <netinet/in_var.h>
  57
  58 #include <sys/stat.h>
  59 #include <net/tap/if_tap.h>
  60 #include <err.h>
  61 #include <errno.h>
  62 #include <stdio.h>
  63 #include <string.h>
  64 #include <unistd.h>
  65 #include <fcntl.h>
  66
  67 #define VKE_DEVNAME             "vke"
  68
  69 #define VKE_CHUNK       8 /* number of mbufs to queue before interrupting */
  70
  71 #define NETFIFOINDEX(u, sc) ((u) & ((sc)->sc_ringsize - 1))
  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;
  79         int             rindex;
  80         int             windex;
  81 };
  82 typedef struct vke_fifo *fifo_t;
  83
  84 /* Default value for a long time */
  85 #define VKE_DEFAULT_RINGSIZE    256
  86 static int vke_max_ringsize = 0;
  87 TUNABLE_INT("hw.vke.max_ringsize", &vke_max_ringsize);
  88
  89 #define LOW_POW_2(n)    (1 << (fls(n) - 1))
  90
  91 struct vke_softc {
  92         struct arpcom           arpcom;
  93         int                     sc_fd;
  94         int                     sc_unit;
  95
  96         cothread_t              cotd_tx;
  97         cothread_t              cotd_rx;
  98
  99         int                     cotd_tx_exit;
 100         int                     cotd_rx_exit;
 101
 102         void                    *sc_txbuf;
 103         int                     sc_txbuf_len;
 104
 105         fifo_t                  sc_txfifo;
 106         fifo_t                  sc_txfifo_done;
 107         fifo_t                  sc_rxfifo;
 108
 109         int                     sc_ringsize;
 110
 111         long                    cotd_ipackets;
 112         long                    cotd_oerrors;
 113         long                    cotd_opackets;
 114
 115         struct sysctl_ctx_list  sc_sysctl_ctx;
 116         struct sysctl_oid       *sc_sysctl_tree;
 117
 118         int                     sc_tap_unit;    /* unit of backend tap(4) */
 119         in_addr_t               sc_addr;        /* address */
 120         in_addr_t               sc_mask;        /* netmask */
 121
 122         struct ifmedia          sc_media;
 123 };
 124
 125 static void     vke_start(struct ifnet *, struct ifaltq_subque *);
 126 static void     vke_init(void *);
 127 static int      vke_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
 128
 129 static int      vke_media_change(struct ifnet *);
 130 static void     vke_media_status(struct ifnet *, struct ifmediareq *);
 131
 132 static int      vke_attach(const struct vknetif_info *, int);
 133 static int      vke_stop(struct vke_softc *);
 134 static int      vke_init_addr(struct ifnet *, in_addr_t, in_addr_t);
 135 static void     vke_tx_intr(cothread_t cotd);
 136 static void     vke_tx_thread(cothread_t cotd);
 137 static void     vke_rx_intr(cothread_t cotd);
 138 static void     vke_rx_thread(cothread_t cotd);
 139
 140 static int vke_txfifo_enqueue(struct vke_softc *sc, struct mbuf *m);
 141 static struct mbuf *vke_txfifo_dequeue(struct vke_softc *sc);
 142
 143 static int vke_txfifo_done_enqueue(struct vke_softc *sc, struct mbuf *m);
 144 static struct mbuf * vke_txfifo_done_dequeue(struct vke_softc *sc, struct mbuf *nm);
 145
 146 static struct mbuf *vke_rxfifo_dequeue(struct vke_softc *sc, struct mbuf *nm);
 147 static struct mbuf *vke_rxfifo_sniff(struct vke_softc *sc);
 148
 149 static void
 150 vke_sysinit(void *arg __unused)
 151 {
 152         int i, unit;
 153
 154         KASSERT(NetifNum <= VKNETIF_MAX, ("too many netifs: %d", NetifNum));
 155
 156         unit = 0;
 157         for (i = 0; i < NetifNum; ++i) {
 158                 if (vke_attach(&NetifInfo[i], unit) == 0)
 159                         ++unit;
 160         }
 161 }
 162 SYSINIT(vke, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, vke_sysinit, NULL);
 163
 164 /*
 165  * vke_txfifo_done_enqueue() - Add an mbuf to the transmit done fifo.  Since
 166  * the cothread cannot free transmit mbufs after processing we put them on
 167  * the done fifo so the kernel can free them.
 168  */
 169 static int
 170 vke_txfifo_done_enqueue(struct vke_softc *sc, struct mbuf *m)
 171 {
 172         fifo_t fifo = sc->sc_txfifo_done;
 173
 174         while (NETFIFOINDEX(fifo->windex + 1, sc) == NETFIFOINDEX(fifo->rindex, sc)) {
 175                 usleep(20000);
 176         }
 177
 178         fifo->array[NETFIFOINDEX(fifo->windex, sc)] = m;
 179         cpu_sfence();
 180         ++fifo->windex;
 181         return (0);
 182 }
 183
 184 /*
 185  * vke_txfifo_done_dequeue() - Remove an mbuf from the transmit done fifo.
 186  */
 187 static struct mbuf *
 188 vke_txfifo_done_dequeue(struct vke_softc *sc, struct mbuf *nm)
 189 {
 190         fifo_t fifo = sc->sc_txfifo_done;
 191         struct mbuf *m;
 192
 193         if (NETFIFOINDEX(fifo->rindex, sc) == NETFIFOINDEX(fifo->windex, sc))
 194                 return (NULL);
 195
 196         m = fifo->array[NETFIFOINDEX(fifo->rindex, sc)];
 197         fifo->array[NETFIFOINDEX(fifo->rindex, sc)] = nm;
 198         cpu_lfence();
 199         ++fifo->rindex;
 200         return (m);
 201 }
 202
 203 /*
 204  * vke_txfifo_enqueue() - Add an mbuf to the transmit fifo.
 205  */
 206 static int
 207 vke_txfifo_enqueue(struct vke_softc *sc, struct mbuf *m)
 208 {
 209         fifo_t fifo = sc->sc_txfifo;
 210
 211         if (NETFIFOINDEX(fifo->windex + 1, sc) == NETFIFOINDEX(fifo->rindex, sc))
 212                 return (-1);
 213
 214         fifo->array[NETFIFOINDEX(fifo->windex, sc)] = m;
 215         cpu_sfence();
 216         ++fifo->windex;
 217
 218         return (0);
 219 }
 220
 221 /*
 222  * vke_txfifo_dequeue() - Return next mbuf on the transmit fifo if one
 223  * exists.
 224  */
 225 static struct mbuf *
 226 vke_txfifo_dequeue(struct vke_softc *sc)
 227 {
 228         fifo_t fifo = sc->sc_txfifo;
 229         struct mbuf *m;
 230
 231         if (NETFIFOINDEX(fifo->rindex, sc) == NETFIFOINDEX(fifo->windex, sc))
 232                 return (NULL);
 233
 234         m = fifo->array[NETFIFOINDEX(fifo->rindex, sc)];
 235         fifo->array[NETFIFOINDEX(fifo->rindex, sc)] = NULL;
 236
 237         cpu_lfence();
 238         ++fifo->rindex;
 239         return (m);
 240 }
 241
 242 static int
 243 vke_txfifo_empty(struct vke_softc *sc)
 244 {
 245         fifo_t fifo = sc->sc_txfifo;
 246
 247         if (NETFIFOINDEX(fifo->rindex, sc) == NETFIFOINDEX(fifo->windex, sc))
 248                 return (1);
 249         return(0);
 250 }
 251
 252 /*
 253  * vke_rxfifo_dequeue() - Return next mbuf on the receice fifo if one
 254  * exists replacing it with newm which should point to a newly allocated
 255  * mbuf.
 256  */
 257 static struct mbuf *
 258 vke_rxfifo_dequeue(struct vke_softc *sc, struct mbuf *newm)
 259 {
 260         fifo_t fifo = sc->sc_rxfifo;
 261         struct mbuf *m;
 262
 263         if (NETFIFOINDEX(fifo->rindex, sc) == NETFIFOINDEX(fifo->windex, sc))
 264                 return (NULL);
 265
 266         m = fifo->array[NETFIFOINDEX(fifo->rindex, sc)];
 267         fifo->array[NETFIFOINDEX(fifo->rindex, sc)] = newm;
 268         cpu_lfence();
 269         ++fifo->rindex;
 270         return (m);
 271 }
 272
 273 /*
 274  * Return the next mbuf if available but do NOT remove it from the FIFO.
 275  */
 276 static struct mbuf *
 277 vke_rxfifo_sniff(struct vke_softc *sc)
 278 {
 279         fifo_t fifo = sc->sc_rxfifo;
 280         struct mbuf *m;
 281
 282         if (NETFIFOINDEX(fifo->rindex, sc) == NETFIFOINDEX(fifo->windex, sc))
 283                 return (NULL);
 284
 285         m = fifo->array[NETFIFOINDEX(fifo->rindex, sc)];
 286         cpu_lfence();
 287         return (m);
 288 }
 289
 290 static void
 291 vke_init(void *xsc)
 292 {
 293         struct vke_softc *sc = xsc;
 294         struct ifnet *ifp = &sc->arpcom.ac_if;
 295         size_t ringsize = sc->sc_ringsize * sizeof(struct mbuf *);
 296         int i;
 297
 298         ASSERT_SERIALIZED(ifp->if_serializer);
 299
 300         vke_stop(sc);
 301
 302         ifp->if_flags |= IFF_RUNNING;
 303         ifsq_clr_oactive(ifq_get_subq_default(&ifp->if_snd));
 304
 305         /*
 306          * Allocate memory for FIFO structures and mbufs.
 307          */
 308         sc->sc_txfifo = kmalloc(sizeof(*sc->sc_txfifo),
 309             M_DEVBUF, M_WAITOK | M_ZERO);
 310         sc->sc_txfifo_done = kmalloc(sizeof(*sc->sc_txfifo_done),
 311             M_DEVBUF, M_WAITOK | M_ZERO);
 312         sc->sc_rxfifo = kmalloc(sizeof(*sc->sc_rxfifo),
 313             M_DEVBUF, M_WAITOK | M_ZERO);
 314         sc->sc_txfifo->array = kmalloc(ringsize, M_DEVBUF, M_WAITOK | M_ZERO);
 315         sc->sc_txfifo_done->array = kmalloc(ringsize, M_DEVBUF, M_WAITOK | M_ZERO);
 316         sc->sc_rxfifo->array = kmalloc(ringsize, M_DEVBUF, M_WAITOK | M_ZERO);
 317
 318         for (i = 0; i < sc->sc_ringsize; i++) {
 319                 sc->sc_rxfifo->array[i] = m_getcl(M_WAITOK, MT_DATA, M_PKTHDR);
 320                 sc->sc_txfifo->array[i] = NULL;
 321                 sc->sc_txfifo_done->array[i] = NULL;
 322         }
 323
 324         sc->cotd_tx_exit = sc->cotd_rx_exit = VKE_COTD_RUN;
 325         sc->cotd_tx = cothread_create(vke_tx_thread, vke_tx_intr, sc, "vke_tx");
 326         sc->cotd_rx = cothread_create(vke_rx_thread, vke_rx_intr, sc, "vke_rx");
 327
 328         if (sc->sc_addr != 0) {
 329                 in_addr_t addr, mask;
 330
 331                 addr = sc->sc_addr;
 332                 mask = sc->sc_mask;
 333
 334                 /*
 335                  * Make sure vkernel assigned
 336                  * address will not be added
 337                  * again.
 338                  */
 339                 sc->sc_addr = 0;
 340                 sc->sc_mask = 0;
 341
 342                 vke_init_addr(ifp, addr, mask);
 343         }
 344
 345 }
 346
 347 /*
 348  * Called from kernel.
 349  *
 350  * NOTE: We can't make any kernel callbacks while holding cothread lock
 351  *       because the cothread lock is not governed by the kernel scheduler
 352  *       (so mplock, tokens, etc will not be released).
 353  */
 354 static void
 355 vke_start(struct ifnet *ifp, struct ifaltq_subque *ifsq)
 356 {
 357         struct vke_softc *sc = ifp->if_softc;
 358         struct mbuf *m;
 359         cothread_t cotd = sc->cotd_tx;
 360         int count;
 361
 362         ASSERT_ALTQ_SQ_DEFAULT(ifp, ifsq);
 363         ASSERT_SERIALIZED(ifp->if_serializer);
 364
 365         if ((ifp->if_flags & IFF_RUNNING) == 0 || ifsq_is_oactive(ifsq))
 366                 return;
 367
 368         count = 0;
 369         while ((m = ifsq_dequeue(ifsq)) != NULL) {
 370                 if (vke_txfifo_enqueue(sc, m) != -1) {
 371                         ETHER_BPF_MTAP(ifp, m);
 372                         if (count++ == VKE_CHUNK) {
 373                                 cothread_lock(cotd, 0);
 374                                 cothread_signal(cotd);
 375                                 cothread_unlock(cotd, 0);
 376                                 count = 0;
 377                         }
 378                 } else {
 379                         m_freem(m);
 380                 }
 381         }
 382         if (count) {
 383                 cothread_lock(cotd, 0);
 384                 cothread_signal(cotd);
 385                 cothread_unlock(cotd, 0);
 386         }
 387 }
 388
 389 static int
 390 vke_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
 391 {
 392         struct vke_softc *sc = ifp->if_softc;
 393         struct ifreq *ifr = (struct ifreq *)data;
 394         int error = 0;
 395
 396         ASSERT_SERIALIZED(ifp->if_serializer);
 397
 398         switch (cmd) {
 399         case SIOCSIFFLAGS:
 400                 if (ifp->if_flags & IFF_UP) {
 401                         if ((ifp->if_flags & IFF_RUNNING) == 0)
 402                                 vke_init(sc);
 403                 } else {
 404                         if (ifp->if_flags & IFF_RUNNING)
 405                                 vke_stop(sc);
 406                 }
 407                 break;
 408         case SIOCGIFMEDIA:
 409         case SIOCSIFMEDIA:
 410                 error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
 411                 break;
 412         case SIOCGIFSTATUS: {
 413                 struct ifstat *ifs = (struct ifstat *)data;
 414                 int len;
 415
 416                 len = strlen(ifs->ascii);
 417                 if (len < sizeof(ifs->ascii)) {
 418                         if (sc->sc_tap_unit >= 0)
 419                                 ksnprintf(ifs->ascii + len, sizeof(ifs->ascii) - len,
 420                                     "\tBacked by tap%d\n", sc->sc_tap_unit);
 421                 }
 422                 break;
 423         }
 424         case SIOCSIFADDR:
 425                 if (((struct ifaddr *)data)->ifa_addr->sa_family == AF_INET) {
 426                         /*
 427                          * If we are explicitly requested to change address,
 428                          * we should invalidate address/netmask passed in
 429                          * from vkernel command line.
 430                          */
 431                         sc->sc_addr = 0;
 432                         sc->sc_mask = 0;
 433                 }
 434                 /* FALL THROUGH */
 435         default:
 436                 error = ether_ioctl(ifp, cmd, data);
 437                 break;
 438         }
 439         return error;
 440 }
 441
 442 static int
 443 vke_stop(struct vke_softc *sc)
 444 {
 445         struct ifnet *ifp = &sc->arpcom.ac_if;
 446         int i;
 447
 448         ASSERT_SERIALIZED(ifp->if_serializer);
 449
 450         ifp->if_flags &= ~IFF_RUNNING;
 451         ifsq_clr_oactive(ifq_get_subq_default(&ifp->if_snd));
 452
 453         if (sc) {
 454                 if (sc->cotd_tx) {
 455                         cothread_lock(sc->cotd_tx, 0);
 456                         if (sc->cotd_tx_exit == VKE_COTD_RUN)
 457                                 sc->cotd_tx_exit = VKE_COTD_EXIT;
 458                         cothread_signal(sc->cotd_tx);
 459                         cothread_unlock(sc->cotd_tx, 0);
 460                         cothread_delete(&sc->cotd_tx);
 461                 }
 462                 if (sc->cotd_rx) {
 463                         cothread_lock(sc->cotd_rx, 0);
 464                         if (sc->cotd_rx_exit == VKE_COTD_RUN)
 465                                 sc->cotd_rx_exit = VKE_COTD_EXIT;
 466                         cothread_signal(sc->cotd_rx);
 467                         cothread_unlock(sc->cotd_rx, 0);
 468                         cothread_delete(&sc->cotd_rx);
 469                 }
 470
 471                 for (i = 0; i < sc->sc_ringsize; i++) {
 472                         if (sc->sc_rxfifo && sc->sc_rxfifo->array[i]) {
 473                                 m_freem(sc->sc_rxfifo->array[i]);
 474                                 sc->sc_rxfifo->array[i] = NULL;
 475                         }
 476                         if (sc->sc_txfifo && sc->sc_txfifo->array[i]) {
 477                                 m_freem(sc->sc_txfifo->array[i]);
 478                                 sc->sc_txfifo->array[i] = NULL;
 479                         }
 480                         if (sc->sc_txfifo_done && sc->sc_txfifo_done->array[i]) {
 481                                 m_freem(sc->sc_txfifo_done->array[i]);
 482                                 sc->sc_txfifo_done->array[i] = NULL;
 483                         }
 484                 }
 485
 486                 if (sc->sc_txfifo) {
 487                         if (sc->sc_txfifo->array)
 488                                 kfree(sc->sc_txfifo->array, M_DEVBUF);
 489                         kfree(sc->sc_txfifo, M_DEVBUF);
 490                         sc->sc_txfifo = NULL;
 491                 }
 492
 493                 if (sc->sc_txfifo_done) {
 494                         if (sc->sc_txfifo_done->array)
 495                                 kfree(sc->sc_txfifo_done->array, M_DEVBUF);
 496                         kfree(sc->sc_txfifo_done, M_DEVBUF);
 497                         sc->sc_txfifo_done = NULL;
 498                 }
 499
 500                 if (sc->sc_rxfifo) {
 501                         if (sc->sc_rxfifo->array)
 502                                 kfree(sc->sc_rxfifo->array, M_DEVBUF);
 503                         kfree(sc->sc_rxfifo, M_DEVBUF);
 504                         sc->sc_rxfifo = NULL;
 505                 }
 506         }
 507
 508
 509         return 0;
 510 }
 511
 512 /*
 513  * vke_rx_intr() is the interrupt function for the receive cothread.
 514  */
 515 static void
 516 vke_rx_intr(cothread_t cotd)
 517 {
 518         struct mbuf *m;
 519         struct mbuf *nm;
 520         struct vke_softc *sc = cotd->arg;
 521         struct ifnet *ifp = &sc->arpcom.ac_if;
 522         static int count = 0;
 523
 524         ifnet_serialize_all(ifp);
 525         cothread_lock(cotd, 0);
 526
 527         if (sc->cotd_rx_exit != VKE_COTD_RUN) {
 528                 cothread_unlock(cotd, 0);
 529                 ifnet_deserialize_all(ifp);
 530                 return;
 531         }
 532         if (sc->cotd_ipackets) {
 533                 IFNET_STAT_INC(ifp, ipackets, 1);
 534                 sc->cotd_ipackets = 0;
 535         }
 536         cothread_unlock(cotd, 0);
 537
 538         while ((m = vke_rxfifo_sniff(sc)) != NULL) {
 539                 nm = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
 540                 if (nm) {
 541                         vke_rxfifo_dequeue(sc, nm);
 542                         ifp->if_input(ifp, m, NULL, -1);
 543                         if (count++ == VKE_CHUNK) {
 544                                 cothread_lock(cotd, 0);
 545                                 cothread_signal(cotd);
 546                                 cothread_unlock(cotd, 0);
 547                                 count = 0;
 548                         }
 549                 } else {
 550                         vke_rxfifo_dequeue(sc, m);
 551                 }
 552         }
 553
 554         if (count) {
 555                 cothread_lock(cotd, 0);
 556                 cothread_signal(cotd);
 557                 cothread_unlock(cotd, 0);
 558         }
 559         ifnet_deserialize_all(ifp);
 560 }
 561
 562 /*
 563  * vke_tx_intr() is the interrupt function for the transmit cothread.
 564  * Calls vke_start() to handle processing transmit mbufs.
 565  */
 566 static void
 567 vke_tx_intr(cothread_t cotd)
 568 {
 569         struct vke_softc *sc = cotd->arg;
 570         struct ifnet *ifp = &sc->arpcom.ac_if;
 571         struct mbuf *m;
 572
 573         ifnet_serialize_all(ifp);
 574         cothread_lock(cotd, 0);
 575         if (sc->cotd_tx_exit != VKE_COTD_RUN) {
 576                 cothread_unlock(cotd, 0);
 577                 ifnet_deserialize_all(ifp);
 578                 return;
 579         }
 580         if (sc->cotd_opackets) {
 581                 IFNET_STAT_INC(ifp, opackets, 1);
 582                 sc->cotd_opackets = 0;
 583         }
 584         if (sc->cotd_oerrors) {
 585                 IFNET_STAT_INC(ifp, oerrors, 1);
 586                 sc->cotd_oerrors = 0;
 587         }
 588         cothread_unlock(cotd, 0);
 589
 590         /*
 591          * Free TX mbufs that have been processed before starting new
 592          * ones going to be pipeline friendly.
 593          */
 594         while ((m = vke_txfifo_done_dequeue(sc, NULL)) != NULL) {
 595                 m_freem(m);
 596         }
 597
 598         if ((ifp->if_flags & IFF_RUNNING) == 0)
 599                 if_devstart(ifp);
 600
 601         ifnet_deserialize_all(ifp);
 602 }
 603
 604 /*
 605  * vke_rx_thread() is the body of the receive cothread.
 606  *
 607  * WARNING!  THIS IS A COTHREAD WHICH HAS NO PER-CPU GLOBALDATA!!!!!
 608  */
 609 static void
 610 vke_rx_thread(cothread_t cotd)
 611 {
 612         struct mbuf *m;
 613         struct vke_softc *sc = cotd->arg;
 614         struct ifnet *ifp = &sc->arpcom.ac_if;
 615         fifo_t fifo = sc->sc_rxfifo;
 616         fd_set fdset;
 617         struct timeval tv;
 618         int count;
 619         int n;
 620
 621         /* Select timeout cannot be infinite since we need to check for
 622          * the exit flag sc->cotd_rx_exit.
 623          */
 624         tv.tv_sec = 0;
 625         tv.tv_usec = 500000;
 626
 627         FD_ZERO(&fdset);
 628         count = 0;
 629
 630         while (sc->cotd_rx_exit == VKE_COTD_RUN) {
 631                 /*
 632                  * Wait for the RX FIFO to be loaded with
 633                  * empty mbufs.
 634                  */
 635                 if (NETFIFOINDEX(fifo->windex + 1, sc) ==
 636                     NETFIFOINDEX(fifo->rindex, sc)) {
 637                         usleep(20000);
 638                         continue;
 639                 }
 640
 641                 /*
 642                  * Load data into the rx fifo
 643                  */
 644                 m = fifo->array[NETFIFOINDEX(fifo->windex, sc)];
 645                 if (m == NULL)
 646                         continue;
 647                 n = read(sc->sc_fd, mtod(m, void *), MCLBYTES);
 648                 if (n > 0) {
 649                         /* no mycpu in cothread */
 650                         /*IFNET_STAT_INC(ifp, ipackets, 1);*/
 651                         ++sc->cotd_ipackets;
 652                         m->m_pkthdr.rcvif = ifp;
 653                         m->m_pkthdr.len = m->m_len = n;
 654                         cpu_sfence();
 655                         ++fifo->windex;
 656                         if (count++ == VKE_CHUNK) {
 657                                 cothread_intr(cotd);
 658                                 count = 0;
 659                         }
 660                 } else {
 661                         if (count) {
 662                                 cothread_intr(cotd);
 663                                 count = 0;
 664                         }
 665                         FD_SET(sc->sc_fd, &fdset);
 666
 667                         if (select(sc->sc_fd + 1, &fdset, NULL, NULL, &tv) == -1) {
 668                                 fprintf(stderr,
 669                                         VKE_DEVNAME "%d: select failed for "
 670                                         "TAP device\n", sc->sc_unit);
 671                                 usleep(1000000);
 672                         }
 673                 }
 674         }
 675         cpu_sfence();
 676         sc->cotd_rx_exit = VKE_COTD_DEAD;
 677 }
 678
 679 /*
 680  * vke_tx_thread() is the body of the transmit cothread.
 681  *
 682  * WARNING!  THIS IS A COTHREAD WHICH HAS NO PER-CPU GLOBALDATA!!!!!
 683  */
 684 static void
 685 vke_tx_thread(cothread_t cotd)
 686 {
 687         struct mbuf *m;
 688         struct vke_softc *sc = cotd->arg;
 689         /*struct ifnet *ifp = &sc->arpcom.ac_if;*/
 690         int count = 0;
 691
 692         while (sc->cotd_tx_exit == VKE_COTD_RUN) {
 693                 /*
 694                  * Write outgoing packets to the TAP interface
 695                  */
 696                 m = vke_txfifo_dequeue(sc);
 697                 if (m) {
 698                         if (m->m_pkthdr.len <= MCLBYTES) {
 699                                 m_copydata(m, 0, m->m_pkthdr.len, sc->sc_txbuf);
 700                                 sc->sc_txbuf_len = m->m_pkthdr.len;
 701
 702                                 if (write(sc->sc_fd, sc->sc_txbuf,
 703                                           sc->sc_txbuf_len) < 0) {
 704                                         /* no mycpu in cothread */
 705                                         /*IFNET_STAT_INC(ifp, oerrors, 1);*/
 706                                         ++sc->cotd_oerrors;
 707                                 } else {
 708                                         /* no mycpu in cothread */
 709                                         /*IFNET_STAT_INC(ifp, opackets, 1);*/
 710                                         ++sc->cotd_opackets;
 711                                 }
 712                         }
 713                         if (count++ == VKE_CHUNK) {
 714                                 cothread_intr(cotd);
 715                                 count = 0;
 716                         }
 717                         vke_txfifo_done_enqueue(sc, m);
 718                 } else {
 719                         if (count) {
 720                                 cothread_intr(cotd);
 721                                 count = 0;
 722                         }
 723                         cothread_lock(cotd, 1);
 724                         if (vke_txfifo_empty(sc))
 725                                 cothread_wait(cotd);
 726                         cothread_unlock(cotd, 1);
 727                 }
 728         }
 729         cpu_sfence();
 730         sc->cotd_tx_exit = VKE_COTD_DEAD;
 731 }
 732
 733 static int
 734 vke_attach(const struct vknetif_info *info, int unit)
 735 {
 736         struct vke_softc *sc;
 737         struct ifnet *ifp;
 738         struct tapinfo tapinfo;
 739         uint8_t enaddr[ETHER_ADDR_LEN];
 740         int nmbufs;
 741         int fd;
 742
 743         KKASSERT(info->tap_fd >= 0);
 744         fd = info->tap_fd;
 745
 746         if (info->enaddr) {
 747                 /*
 748                  * enaddr is supplied
 749                  */
 750                 bcopy(info->enaddr, enaddr, ETHER_ADDR_LEN);
 751         } else {
 752                 /*
 753                  * This is only a TAP device if tap_unit is non-zero.  If
 754                  * connecting to a virtual socket we generate a unique MAC.
 755                  *
 756                  * WARNING: enaddr[0] bit 0 is the multicast bit, when
 757                  *          randomizing enaddr[] just leave the first
 758                  *          two bytes 00 00 for now.
 759                  */
 760                 bzero(enaddr, sizeof(enaddr));
 761                 if (info->tap_unit >= 0) {
 762                         if (ioctl(fd, TAPGIFINFO, &tapinfo) < 0) {
 763                                 kprintf(VKE_DEVNAME "%d: ioctl(TAPGIFINFO) "
 764                                         "failed: %s\n", unit, strerror(errno));
 765                                 return ENXIO;
 766                         }
 767
 768                         if (ioctl(fd, SIOCGIFADDR, enaddr) < 0) {
 769                                 kprintf(VKE_DEVNAME "%d: ioctl(SIOCGIFADDR) "
 770                                         "failed: %s\n", unit, strerror(errno));
 771                                 return ENXIO;
 772                         }
 773                 } else {
 774                         int fd = open("/dev/urandom", O_RDONLY);
 775                         if (fd >= 0) {
 776                                 read(fd, enaddr + 2, 4);
 777                                 close(fd);
 778                         }
 779                         enaddr[4] = (int)getpid() >> 8;
 780                         enaddr[5] = (int)getpid() & 255;
 781
 782                 }
 783                 enaddr[1] += 1;
 784         }
 785         if (ETHER_IS_MULTICAST(enaddr)) {
 786                 kprintf(VKE_DEVNAME "%d: illegal MULTICAST ether mac!\n", unit);
 787                 return ENXIO;
 788         }
 789
 790         sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
 791
 792         sc->sc_txbuf = kmalloc(MCLBYTES, M_DEVBUF, M_WAITOK);
 793         sc->sc_fd = fd;
 794         sc->sc_unit = unit;
 795         sc->sc_tap_unit = info->tap_unit;
 796         sc->sc_addr = info->netif_addr;
 797         sc->sc_mask = info->netif_mask;
 798
 799         if (vke_max_ringsize == 0) {
 800                 nmbufs = nmbclusters / (NetifNum * 2);
 801                 sc->sc_ringsize = LOW_POW_2(nmbufs);
 802                 if (sc->sc_ringsize > VKE_DEFAULT_RINGSIZE)
 803                         sc->sc_ringsize = VKE_DEFAULT_RINGSIZE;
 804         } else if (vke_max_ringsize >= VKE_CHUNK) {     /* Tunable specified */
 805                 sc->sc_ringsize = LOW_POW_2(vke_max_ringsize);
 806         } else {
 807                 sc->sc_ringsize = LOW_POW_2(VKE_CHUNK);
 808         }
 809
 810         ifp = &sc->arpcom.ac_if;
 811         if_initname(ifp, VKE_DEVNAME, sc->sc_unit);
 812
 813         /* NB: after if_initname() */
 814         sysctl_ctx_init(&sc->sc_sysctl_ctx);
 815         sc->sc_sysctl_tree = SYSCTL_ADD_NODE(&sc->sc_sysctl_ctx,
 816                                              SYSCTL_STATIC_CHILDREN(_hw),
 817                                              OID_AUTO, ifp->if_xname,
 818                                              CTLFLAG_RD, 0, "");
 819         if (sc->sc_sysctl_tree == NULL) {
 820                 kprintf(VKE_DEVNAME "%d: can't add sysctl node\n", unit);
 821         } else {
 822                 SYSCTL_ADD_INT(&sc->sc_sysctl_ctx,
 823                                SYSCTL_CHILDREN(sc->sc_sysctl_tree),
 824                                OID_AUTO, "tap_unit",
 825                                CTLFLAG_RD, &sc->sc_tap_unit, 0,
 826                                "Backend tap(4) unit");
 827         }
 828
 829         ifp->if_softc = sc;
 830         ifp->if_ioctl = vke_ioctl;
 831         ifp->if_start = vke_start;
 832         ifp->if_init = vke_init;
 833         ifp->if_mtu = tapinfo.mtu;
 834         ifp->if_baudrate = tapinfo.baudrate;
 835         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 836         ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
 837         ifq_set_ready(&ifp->if_snd);
 838
 839         ifmedia_init(&sc->sc_media, 0, vke_media_change, vke_media_status);
 840         /* We support as many media types as we please for
 841            debugging purposes */
 842         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10_T, 0, NULL);
 843         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10_T | IFM_FDX, 0, NULL);
 844         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10_2, 0, NULL);
 845         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10_5, 0, NULL);
 846         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_100_TX, 0, NULL);
 847         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_100_TX | IFM_FDX, 0, NULL);
 848         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_100_FX, 0, NULL);
 849         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_100_T4, 0, NULL);
 850         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_100_VG, 0, NULL);
 851         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_100_T2, 0, NULL);
 852         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_1000_FX, 0, NULL);
 853         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10_STP, 0, NULL);
 854         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10_FL, 0, NULL);
 855         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_1000_SX, 0, NULL);
 856         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_1000_LX, 0, NULL);
 857         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_1000_CX, 0, NULL);
 858         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_1000_T, 0, NULL);
 859         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL);
 860         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_HPNA_1, 0, NULL);
 861         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10G_LR, 0, NULL);
 862         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10G_SR, 0, NULL);
 863         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10G_CX4, 0, NULL);
 864         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_2500_SX, 0, NULL);
 865         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10G_TWINAX, 0, NULL);
 866         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10G_TWINAX_LONG, 0, NULL);
 867         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10G_LRM, 0, NULL);
 868         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10G_T, 0, NULL);
 869         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_40G_CR4, 0, NULL);
 870         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_40G_SR4, 0, NULL);
 871         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_40G_LR4, 0, NULL);
 872         ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_AUTO, 0, NULL);
 873
 874         ifmedia_set(&sc->sc_media, IFM_ETHER | IFM_AUTO);
 875
 876         ifp->if_link_state = LINK_STATE_UP;
 877
 878         ether_ifattach(ifp, enaddr, NULL);
 879
 880         if (bootverbose && sc->sc_addr != 0) {
 881                 if_printf(ifp, "pre-configured "
 882                     "address 0x%08x, netmask 0x%08x, %d mbuf clusters\n",
 883                     ntohl(sc->sc_addr), ntohl(sc->sc_mask), sc->sc_ringsize);
 884         }
 885
 886         return 0;
 887 }
 888
 889 static int
 890 vke_init_addr(struct ifnet *ifp, in_addr_t addr, in_addr_t mask)
 891 {
 892         struct ifaliasreq ifra;
 893         struct sockaddr_in *sin;
 894         int ret;
 895
 896         ASSERT_SERIALIZED(ifp->if_serializer);
 897
 898         if (bootverbose) {
 899                 if_printf(ifp, "add pre-configured "
 900                           "address 0x%08x, netmask 0x%08x\n",
 901                           ntohl(addr), ntohl(mask));
 902         }
 903
 904         bzero(&ifra, sizeof(ifra));
 905
 906         /* NB: no need to set ifaliasreq.ifra_name */
 907
 908         sin = (struct sockaddr_in *)&ifra.ifra_addr;
 909         sin->sin_family = AF_INET;
 910         sin->sin_len = sizeof(*sin);
 911         sin->sin_addr.s_addr = addr;
 912
 913         if (mask != 0) {
 914                 sin = (struct sockaddr_in *)&ifra.ifra_mask;
 915                 sin->sin_len = sizeof(*sin);
 916                 sin->sin_addr.s_addr = mask;
 917         }
 918
 919         /*
 920          * Temporarily release serializer, in_control() will hold
 921          * it again before calling ifnet.if_ioctl().
 922          */
 923         ifnet_deserialize_all(ifp);
 924         ret = in_control(SIOCAIFADDR, (caddr_t)&ifra, ifp, NULL);
 925         ifnet_serialize_all(ifp);
 926
 927         return ret;
 928 }
 929
 930 static int vke_media_change(struct ifnet *ifp)
 931 {
 932         /* ignored */
 933         return(0);
 934 }
 935
 936 static void vke_media_status(struct ifnet *ifp, struct ifmediareq *imr)
 937 {
 938         struct vke_softc *sc = (struct vke_softc *)ifp->if_softc;
 939
 940         imr->ifm_status = IFM_AVALID;
 941         imr->ifm_status |= IFM_ACTIVE;
 942
 943         if(sc->sc_media.ifm_cur) {
 944                 if(sc->sc_media.ifm_cur->ifm_media == IFM_ETHER) {
 945                         imr->ifm_active = IFM_ETHER | IFM_1000_T | IFM_FDX;
 946                 } else {
 947                         imr->ifm_active = sc->sc_media.ifm_cur->ifm_media;
 948                 }
 949         } else {
 950                 imr->ifm_active = IFM_ETHER | IFM_1000_T | IFM_FDX;
 951         }
 952 }