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