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