a9e78034383e8758fcd1aa4265610fafde7ff781
[dragonfly.git] / sys / net / tun / if_tun.c
1 /*      $NetBSD: if_tun.c,v 1.14 1994/06/29 06:36:25 cgd Exp $  */
2
3 /*
4  * Copyright (c) 1988, Julian Onions <jpo@cs.nott.ac.uk>
5  * Nottingham University 1987.
6  *
7  * This source may be freely distributed, however I would be interested
8  * in any changes that are made.
9  *
10  * This driver takes packets off the IP i/f and hands them up to a
11  * user process to have its wicked way with. This driver has it's
12  * roots in a similar driver written by Phil Cockcroft (formerly) at
13  * UCL. This driver is based much more on read/write/poll mode of
14  * operation though.
15  *
16  * $FreeBSD: src/sys/net/if_tun.c,v 1.74.2.8 2002/02/13 00:43:11 dillon Exp $
17  * $DragonFly: src/sys/net/tun/if_tun.c,v 1.31 2006/12/20 18:14:42 dillon Exp $
18  */
19
20 #include "opt_atalk.h"
21 #include "opt_inet.h"
22 #include "opt_inet6.h"
23 #include "opt_ipx.h"
24
25 #include <sys/param.h>
26 #include <sys/proc.h>
27 #include <sys/systm.h>
28 #include <sys/mbuf.h>
29 #include <sys/socket.h>
30 #include <sys/conf.h>
31 #include <sys/device.h>
32 #include <sys/filio.h>
33 #include <sys/sockio.h>
34 #include <sys/thread2.h>
35 #include <sys/ttycom.h>
36 #include <sys/poll.h>
37 #include <sys/signalvar.h>
38 #include <sys/filedesc.h>
39 #include <sys/kernel.h>
40 #include <sys/sysctl.h>
41 #include <sys/uio.h>
42 #include <sys/vnode.h>
43 #include <sys/malloc.h>
44
45 #include <net/if.h>
46 #include <net/if_types.h>
47 #include <net/ifq_var.h>
48 #include <net/netisr.h>
49 #include <net/route.h>
50
51 #ifdef INET
52 #include <netinet/in.h>
53 #endif
54
55 #include <net/bpf.h>
56
57 #include "if_tunvar.h"
58 #include "if_tun.h"
59
60 static MALLOC_DEFINE(M_TUN, "tun", "Tunnel Interface");
61
62 static void tunattach (void *);
63 PSEUDO_SET(tunattach, if_tun);
64
65 static void tuncreate (cdev_t dev);
66
67 #define TUNDEBUG        if (tundebug) if_printf
68 static int tundebug = 0;
69 SYSCTL_INT(_debug, OID_AUTO, if_tun_debug, CTLFLAG_RW, &tundebug, 0, "");
70
71 static int tunoutput (struct ifnet *, struct mbuf *, struct sockaddr *,
72             struct rtentry *rt);
73 static int tunifioctl (struct ifnet *, u_long, caddr_t, struct ucred *);
74 static int tuninit (struct ifnet *);
75 static void tunstart(struct ifnet *);
76
77 static  d_open_t        tunopen;
78 static  d_close_t       tunclose;
79 static  d_read_t        tunread;
80 static  d_write_t       tunwrite;
81 static  d_ioctl_t       tunioctl;
82 static  d_poll_t        tunpoll;
83
84 #define CDEV_MAJOR 52
85 static struct dev_ops tun_ops = {
86         { "tun", CDEV_MAJOR, 0 },
87         .d_open =       tunopen,
88         .d_close =      tunclose,
89         .d_read =       tunread,
90         .d_write =      tunwrite,
91         .d_ioctl =      tunioctl,
92         .d_poll =       tunpoll,
93 };
94
95 static void
96 tunattach(void *dummy)
97 {
98         dev_ops_add(&tun_ops, 0, 0);
99 }
100
101 static void
102 tuncreate(cdev_t dev)
103 {
104         struct tun_softc *sc;
105         struct ifnet *ifp;
106
107         dev = make_dev(&tun_ops, minor(dev),
108             UID_UUCP, GID_DIALER, 0600, "tun%d", lminor(dev));
109
110         MALLOC(sc, struct tun_softc *, sizeof(*sc), M_TUN, M_WAITOK);
111         bzero(sc, sizeof *sc);
112         sc->tun_flags = TUN_INITED;
113
114         ifp = &sc->tun_if;
115         if_initname(ifp, "tun", lminor(dev));
116         ifp->if_mtu = TUNMTU;
117         ifp->if_ioctl = tunifioctl;
118         ifp->if_output = tunoutput;
119         ifp->if_start = tunstart;
120         ifp->if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
121         ifp->if_type = IFT_PPP;
122         ifq_set_maxlen(&ifp->if_snd, ifqmaxlen);
123         ifq_set_ready(&ifp->if_snd);
124         ifp->if_softc = sc;
125         if_attach(ifp, NULL);
126         bpfattach(ifp, DLT_NULL, sizeof(u_int));
127         dev->si_drv1 = sc;
128 }
129
130 /*
131  * tunnel open - must be superuser & the device must be
132  * configured in
133  */
134 static  int
135 tunopen(struct dev_open_args *ap)
136 {
137         cdev_t dev = ap->a_head.a_dev;
138         struct ifnet    *ifp;
139         struct tun_softc *tp;
140         int     error;
141
142         if ((error = suser_cred(ap->a_cred, 0)) != NULL)
143                 return (error);
144
145         tp = dev->si_drv1;
146         if (!tp) {
147                 tuncreate(dev);
148                 tp = dev->si_drv1;
149         }
150         if (tp->tun_flags & TUN_OPEN)
151                 return EBUSY;
152         tp->tun_pid = curproc->p_pid;
153         ifp = &tp->tun_if;
154         tp->tun_flags |= TUN_OPEN;
155         TUNDEBUG(ifp, "open\n");
156         return (0);
157 }
158
159 /*
160  * tunclose - close the device - mark i/f down & delete
161  * routing info
162  */
163 static  int
164 tunclose(struct dev_close_args *ap)
165 {
166         cdev_t dev = ap->a_head.a_dev;
167         struct tun_softc *tp;
168         struct ifnet    *ifp;
169
170         tp = dev->si_drv1;
171         ifp = &tp->tun_if;
172
173         tp->tun_flags &= ~TUN_OPEN;
174         tp->tun_pid = 0;
175
176         /* Junk all pending output. */
177         lwkt_serialize_enter(ifp->if_serializer);
178         ifq_purge(&ifp->if_snd);
179         lwkt_serialize_exit(ifp->if_serializer);
180
181         if (ifp->if_flags & IFF_UP) {
182                 lwkt_serialize_enter(ifp->if_serializer);
183                 if_down(ifp);
184                 lwkt_serialize_exit(ifp->if_serializer);
185         }
186
187         if (ifp->if_flags & IFF_RUNNING) {
188                 struct ifaddr *ifa;
189
190                 lwkt_serialize_enter(ifp->if_serializer);
191                 /* find internet addresses and delete routes */
192                 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
193                         if (ifa->ifa_addr->sa_family == AF_INET) {
194                                 rtinit(ifa, (int)RTM_DELETE,
195                                     tp->tun_flags & TUN_DSTADDR ? RTF_HOST : 0);
196                         }
197                 }
198                 ifp->if_flags &= ~IFF_RUNNING;
199                 lwkt_serialize_exit(ifp->if_serializer);
200         }
201
202         funsetown(tp->tun_sigio);
203         selwakeup(&tp->tun_rsel);
204
205         TUNDEBUG(ifp, "closed\n");
206         return (0);
207 }
208
209 static int
210 tuninit(struct ifnet *ifp)
211 {
212         struct tun_softc *tp = ifp->if_softc;
213         struct ifaddr *ifa;
214         int error = 0;
215
216         TUNDEBUG(ifp, "tuninit\n");
217
218         ifp->if_flags |= IFF_UP | IFF_RUNNING;
219         getmicrotime(&ifp->if_lastchange);
220
221         for (ifa = TAILQ_FIRST(&ifp->if_addrhead); ifa; 
222              ifa = TAILQ_NEXT(ifa, ifa_link)) {
223                 if (ifa->ifa_addr == NULL)
224                         error = EFAULT;
225                         /* XXX: Should maybe return straight off? */
226                 else {
227 #ifdef INET
228                         if (ifa->ifa_addr->sa_family == AF_INET) {
229                             struct sockaddr_in *si;
230
231                             si = (struct sockaddr_in *)ifa->ifa_addr;
232                             if (si->sin_addr.s_addr)
233                                     tp->tun_flags |= TUN_IASET;
234
235                             si = (struct sockaddr_in *)ifa->ifa_dstaddr;
236                             if (si && si->sin_addr.s_addr)
237                                     tp->tun_flags |= TUN_DSTADDR;
238                         }
239 #endif
240                 }
241         }
242         return (error);
243 }
244
245 /*
246  * Process an ioctl request.
247  *
248  * MPSAFE
249  */
250 int
251 tunifioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
252 {
253         struct ifreq *ifr = (struct ifreq *)data;
254         struct tun_softc *tp = ifp->if_softc;
255         struct ifstat *ifs;
256         int error = 0;
257
258         switch(cmd) {
259         case SIOCGIFSTATUS:
260                 ifs = (struct ifstat *)data;
261                 if (tp->tun_pid)
262                         ksprintf(ifs->ascii + strlen(ifs->ascii),
263                             "\tOpened by PID %d\n", tp->tun_pid);
264                 break;
265         case SIOCSIFADDR:
266                 error = tuninit(ifp);
267                 TUNDEBUG(ifp, "address set, error=%d\n", error);
268                 break;
269         case SIOCSIFDSTADDR:
270                 error = tuninit(ifp);
271                 TUNDEBUG(ifp, "destination address set, error=%d\n", error);
272                 break;
273         case SIOCSIFMTU:
274                 ifp->if_mtu = ifr->ifr_mtu;
275                 TUNDEBUG(ifp, "mtu set\n");
276                 break;
277         case SIOCSIFFLAGS:
278         case SIOCADDMULTI:
279         case SIOCDELMULTI:
280                 break;
281         default:
282                 error = EINVAL;
283         }
284         return (error);
285 }
286
287 /*
288  * tunoutput - queue packets from higher level ready to put out.
289  *
290  * MPSAFE
291  */
292 int
293 tunoutput(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
294           struct rtentry *rt)
295 {
296         struct tun_softc *tp = ifp->if_softc;
297         int error;
298         struct altq_pktattr pktattr;
299
300         TUNDEBUG(ifp, "tunoutput\n");
301
302         if ((tp->tun_flags & TUN_READY) != TUN_READY) {
303                 TUNDEBUG(ifp, "not ready 0%o\n", tp->tun_flags);
304                 m_freem (m0);
305                 return EHOSTDOWN;
306         }
307
308         /*
309          * if the queueing discipline needs packet classification,
310          * do it before prepending link headers.
311          */
312         ifq_classify(&ifp->if_snd, m0, dst->sa_family, &pktattr);
313
314         /* BPF write needs to be handled specially */
315         if (dst->sa_family == AF_UNSPEC) {
316                 dst->sa_family = *(mtod(m0, int *));
317                 m0->m_len -= sizeof(int);
318                 m0->m_pkthdr.len -= sizeof(int);
319                 m0->m_data += sizeof(int);
320         }
321
322         if (ifp->if_bpf) {
323                 /*
324                  * We need to prepend the address family as
325                  * a four byte field.
326                  */
327                 uint32_t af = dst->sa_family;
328
329                 bpf_ptap(ifp->if_bpf, m0, &af, sizeof(af));
330         }
331
332         /* prepend sockaddr? this may abort if the mbuf allocation fails */
333         if (tp->tun_flags & TUN_LMODE) {
334                 /* allocate space for sockaddr */
335                 M_PREPEND(m0, dst->sa_len, MB_DONTWAIT);
336
337                 /* if allocation failed drop packet */
338                 if (m0 == NULL){
339                         IF_DROP(&ifp->if_snd);
340                         ifp->if_oerrors++;
341                         return (ENOBUFS);
342                 } else {
343                         bcopy(dst, m0->m_data, dst->sa_len);
344                 }
345         }
346
347         if (tp->tun_flags & TUN_IFHEAD) {
348                 /* Prepend the address family */
349                 M_PREPEND(m0, 4, MB_DONTWAIT);
350
351                 /* if allocation failed drop packet */
352                 if (m0 == NULL){
353                         IF_DROP(&ifp->if_snd);
354                         ifp->if_oerrors++;
355                         return ENOBUFS;
356                 } else
357                         *(u_int32_t *)m0->m_data = htonl(dst->sa_family);
358         } else {
359 #ifdef INET
360                 if (dst->sa_family != AF_INET)
361 #endif
362                 {
363                         m_freem(m0);
364                         return EAFNOSUPPORT;
365                 }
366         }
367
368         error = ifq_handoff(ifp, m0, &pktattr);
369         if (error) {
370                 ifp->if_collisions++;
371         } else {
372                 ifp->if_opackets++;
373                 if (tp->tun_flags & TUN_RWAIT) {
374                         tp->tun_flags &= ~TUN_RWAIT;
375                         wakeup((caddr_t)tp);
376                 }
377                 get_mplock();
378                 if (tp->tun_flags & TUN_ASYNC && tp->tun_sigio)
379                         pgsigio(tp->tun_sigio, SIGIO, 0);
380                 selwakeup(&tp->tun_rsel);
381                 rel_mplock();
382         }
383         return (error);
384 }
385
386 /*
387  * the ops interface is now pretty minimal.
388  */
389 static  int
390 tunioctl(struct dev_ioctl_args *ap)
391 {
392         cdev_t dev = ap->a_head.a_dev;
393         struct tun_softc *tp = dev->si_drv1;
394         struct tuninfo *tunp;
395
396         switch (ap->a_cmd) {
397         case TUNSIFINFO:
398                 tunp = (struct tuninfo *)ap->a_data;
399                 if (tunp->mtu < IF_MINMTU)
400                         return (EINVAL);
401                 tp->tun_if.if_mtu = tunp->mtu;
402                 tp->tun_if.if_type = tunp->type;
403                 tp->tun_if.if_baudrate = tunp->baudrate;
404                 break;
405         case TUNGIFINFO:
406                 tunp = (struct tuninfo *)ap->a_data;
407                 tunp->mtu = tp->tun_if.if_mtu;
408                 tunp->type = tp->tun_if.if_type;
409                 tunp->baudrate = tp->tun_if.if_baudrate;
410                 break;
411         case TUNSDEBUG:
412                 tundebug = *(int *)ap->a_data;
413                 break;
414         case TUNGDEBUG:
415                 *(int *)ap->a_data = tundebug;
416                 break;
417         case TUNSLMODE:
418                 if (*(int *)ap->a_data) {
419                         tp->tun_flags |= TUN_LMODE;
420                         tp->tun_flags &= ~TUN_IFHEAD;
421                 } else
422                         tp->tun_flags &= ~TUN_LMODE;
423                 break;
424         case TUNSIFHEAD:
425                 if (*(int *)ap->a_data) {
426                         tp->tun_flags |= TUN_IFHEAD;
427                         tp->tun_flags &= ~TUN_LMODE;
428                 } else 
429                         tp->tun_flags &= ~TUN_IFHEAD;
430                 break;
431         case TUNGIFHEAD:
432                 *(int *)ap->a_data = (tp->tun_flags & TUN_IFHEAD) ? 1 : 0;
433                 break;
434         case TUNSIFMODE:
435                 /* deny this if UP */
436                 if (tp->tun_if.if_flags & IFF_UP)
437                         return(EBUSY);
438
439                 switch (*(int *)ap->a_data & ~IFF_MULTICAST) {
440                 case IFF_POINTOPOINT:
441                 case IFF_BROADCAST:
442                         tp->tun_if.if_flags &= ~(IFF_BROADCAST|IFF_POINTOPOINT);
443                         tp->tun_if.if_flags |= *(int *)ap->a_data;
444                         break;
445                 default:
446                         return(EINVAL);
447                 }
448                 break;
449         case TUNSIFPID:
450                 tp->tun_pid = curproc->p_pid;
451                 break;
452         case FIOASYNC:
453                 if (*(int *)ap->a_data)
454                         tp->tun_flags |= TUN_ASYNC;
455                 else
456                         tp->tun_flags &= ~TUN_ASYNC;
457                 break;
458         case FIONREAD:
459                 lwkt_serialize_enter(tp->tun_if.if_serializer);
460                 if (!ifq_is_empty(&tp->tun_if.if_snd)) {
461                         struct mbuf *mb;
462
463                         mb = ifq_poll(&tp->tun_if.if_snd);
464                         for( *(int *)ap->a_data = 0; mb != 0; mb = mb->m_next) 
465                                 *(int *)ap->a_data += mb->m_len;
466                 } else {
467                         *(int *)ap->a_data = 0;
468                 }
469                 lwkt_serialize_exit(tp->tun_if.if_serializer);
470                 break;
471         case FIOSETOWN:
472                 return (fsetown(*(int *)ap->a_data, &tp->tun_sigio));
473
474         case FIOGETOWN:
475                 *(int *)ap->a_data = fgetown(tp->tun_sigio);
476                 return (0);
477
478         /* This is deprecated, FIOSETOWN should be used instead. */
479         case TIOCSPGRP:
480                 return (fsetown(-(*(int *)ap->a_data), &tp->tun_sigio));
481
482         /* This is deprecated, FIOGETOWN should be used instead. */
483         case TIOCGPGRP:
484                 *(int *)ap->a_data = -fgetown(tp->tun_sigio);
485                 return (0);
486
487         default:
488                 return (ENOTTY);
489         }
490         return (0);
491 }
492
493 /*
494  * The ops read interface - reads a packet at a time, or at
495  * least as much of a packet as can be read.
496  */
497 static  int
498 tunread(struct dev_read_args *ap)
499 {
500         cdev_t dev = ap->a_head.a_dev;
501         struct uio *uio = ap->a_uio;
502         struct tun_softc *tp = dev->si_drv1;
503         struct ifnet    *ifp = &tp->tun_if;
504         struct mbuf     *m0;
505         int             error=0, len;
506
507         TUNDEBUG(ifp, "read\n");
508         if ((tp->tun_flags & TUN_READY) != TUN_READY) {
509                 TUNDEBUG(ifp, "not ready 0%o\n", tp->tun_flags);
510                 return EHOSTDOWN;
511         }
512
513         tp->tun_flags &= ~TUN_RWAIT;
514
515         lwkt_serialize_enter(ifp->if_serializer);
516
517         while ((m0 = ifq_dequeue(&ifp->if_snd, NULL)) == NULL) {
518                 if (ap->a_ioflag & IO_NDELAY) {
519                         lwkt_serialize_exit(ifp->if_serializer);
520                         return EWOULDBLOCK;
521                 }
522                 tp->tun_flags |= TUN_RWAIT;
523                 lwkt_serialize_exit(ifp->if_serializer);
524                 if ((error = tsleep(tp, PCATCH, "tunread", 0)) != 0)
525                         return error;
526                 lwkt_serialize_enter(ifp->if_serializer);
527         }
528
529         lwkt_serialize_exit(ifp->if_serializer);
530
531         while (m0 && uio->uio_resid > 0 && error == 0) {
532                 len = min(uio->uio_resid, m0->m_len);
533                 if (len != 0)
534                         error = uiomove(mtod(m0, caddr_t), len, uio);
535                 m0 = m_free(m0);
536         }
537
538         if (m0) {
539                 TUNDEBUG(ifp, "Dropping mbuf\n");
540                 m_freem(m0);
541         }
542         return error;
543 }
544
545 /*
546  * the ops write interface - an atomic write is a packet - or else!
547  */
548 static  int
549 tunwrite(struct dev_write_args *ap)
550 {
551         cdev_t dev = ap->a_head.a_dev;
552         struct uio *uio = ap->a_uio;
553         struct tun_softc *tp = dev->si_drv1;
554         struct ifnet    *ifp = &tp->tun_if;
555         struct mbuf     *top, **mp, *m;
556         int             error=0, tlen, mlen;
557         uint32_t        family;
558         int             isr;
559
560         TUNDEBUG(ifp, "tunwrite\n");
561
562         if (uio->uio_resid == 0)
563                 return 0;
564
565         if (uio->uio_resid < 0 || uio->uio_resid > TUNMRU) {
566                 TUNDEBUG(ifp, "len=%d!\n", uio->uio_resid);
567                 return EIO;
568         }
569         tlen = uio->uio_resid;
570
571         /* get a header mbuf */
572         MGETHDR(m, MB_DONTWAIT, MT_DATA);
573         if (m == NULL)
574                 return ENOBUFS;
575         mlen = MHLEN;
576
577         top = 0;
578         mp = &top;
579         while (error == 0 && uio->uio_resid > 0) {
580                 m->m_len = min(mlen, uio->uio_resid);
581                 error = uiomove(mtod (m, caddr_t), m->m_len, uio);
582                 *mp = m;
583                 mp = &m->m_next;
584                 if (uio->uio_resid > 0) {
585                         MGET (m, MB_DONTWAIT, MT_DATA);
586                         if (m == 0) {
587                                 error = ENOBUFS;
588                                 break;
589                         }
590                         mlen = MLEN;
591                 }
592         }
593         if (error) {
594                 if (top)
595                         m_freem (top);
596                 ifp->if_ierrors++;
597                 return error;
598         }
599
600         top->m_pkthdr.len = tlen;
601         top->m_pkthdr.rcvif = ifp;
602
603         if (ifp->if_bpf) {
604                 if (tp->tun_flags & TUN_IFHEAD) {
605                         /*
606                          * Conveniently, we already have a 4-byte address
607                          * family prepended to our packet !
608                          * Inconveniently, it's in the wrong byte order !
609                          */
610                         if ((top = m_pullup(top, sizeof(family))) == NULL)
611                                 return ENOBUFS;
612                         *mtod(top, u_int32_t *) =
613                             ntohl(*mtod(top, u_int32_t *));
614                         bpf_mtap(ifp->if_bpf, top);
615                         *mtod(top, u_int32_t *) =
616                             htonl(*mtod(top, u_int32_t *));
617                 } else {
618                         /*
619                          * We need to prepend the address family as
620                          * a four byte field.
621                          */
622                         static const uint32_t af = AF_INET;
623
624                         bpf_ptap(ifp->if_bpf, top, &af, sizeof(af));
625                 }
626         }
627
628         if (tp->tun_flags & TUN_IFHEAD) {
629                 if (top->m_len < sizeof(family) &&
630                     (top = m_pullup(top, sizeof(family))) == NULL)
631                                 return ENOBUFS;
632                 family = ntohl(*mtod(top, u_int32_t *));
633                 m_adj(top, sizeof(family));
634         } else
635                 family = AF_INET;
636
637         ifp->if_ibytes += top->m_pkthdr.len;
638         ifp->if_ipackets++;
639
640         switch (family) {
641 #ifdef INET
642         case AF_INET:
643                 isr = NETISR_IP;
644                 break;
645 #endif
646 #ifdef INET6
647         case AF_INET6:
648                 isr = NETISR_IPV6;
649                 break;
650 #endif
651 #ifdef IPX
652         case AF_IPX:
653                 isr = NETISR_IPX;
654                 break;
655 #endif
656 #ifdef NETATALK
657         case AF_APPLETALK:
658                 isr = NETISR_ATALK2;
659                 break;
660 #endif
661         default:
662                 m_freem(m);
663                 return (EAFNOSUPPORT);
664         }
665
666         netisr_dispatch(isr, top);
667         return (0);
668 }
669
670 /*
671  * tunpoll - the poll interface, this is only useful on reads
672  * really. The write detect always returns true, write never blocks
673  * anyway, it either accepts the packet or drops it.
674  */
675 static  int
676 tunpoll(struct dev_poll_args *ap)
677 {
678         cdev_t dev = ap->a_head.a_dev;
679         struct tun_softc *tp = dev->si_drv1;
680         struct ifnet    *ifp = &tp->tun_if;
681         int             revents = 0;
682
683         TUNDEBUG(ifp, "tunpoll\n");
684
685         lwkt_serialize_enter(ifp->if_serializer);
686
687         if (ap->a_events & (POLLIN | POLLRDNORM)) {
688                 if (!ifq_is_empty(&ifp->if_snd)) {
689                         TUNDEBUG(ifp, "tunpoll q=%d\n", ifp->if_snd.ifq_len);
690                         revents |= ap->a_events & (POLLIN | POLLRDNORM);
691                 } else {
692                         TUNDEBUG(ifp, "tunpoll waiting\n");
693                         selrecord(curthread, &tp->tun_rsel);
694                 }
695         }
696         if (ap->a_events & (POLLOUT | POLLWRNORM))
697                 revents |= ap->a_events & (POLLOUT | POLLWRNORM);
698
699         lwkt_serialize_exit(ifp->if_serializer);
700         ap->a_events = revents;
701         return(0);
702 }
703
704 /*
705  * Start packet transmission on the interface.
706  * when the interface queue is rate-limited by ALTQ,
707  * if_start is needed to drain packets from the queue in order
708  * to notify readers when outgoing packets become ready.
709  */
710 static void
711 tunstart(struct ifnet *ifp)
712 {
713         struct tun_softc *tp = ifp->if_softc;
714         struct mbuf *m;
715
716         if (!ifq_is_enabled(&ifp->if_snd))
717                 return;
718
719         m = ifq_poll(&ifp->if_snd);
720         if (m != NULL) {
721                 if (tp->tun_flags & TUN_RWAIT) {
722                         tp->tun_flags &= ~TUN_RWAIT;
723                         wakeup((caddr_t)tp);
724                 }
725                 if (tp->tun_flags & TUN_ASYNC && tp->tun_sigio)
726                         pgsigio(tp->tun_sigio, SIGIO, 0);
727                 selwakeup(&tp->tun_rsel);
728         }
729 }