The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/net/bpf.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*
    2  * Copyright (c) 1990, 1991, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * This code is derived from the Stanford/CMU enet packet filter,
    6  * (net/enet.c) distributed as part of 4.3BSD, and code contributed
    7  * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
    8  * Berkeley Laboratory.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 3. All advertising materials mentioning features or use of this software
   19  *    must display the following acknowledgement:
   20  *      This product includes software developed by the University of
   21  *      California, Berkeley and its contributors.
   22  * 4. Neither the name of the University nor the names of its contributors
   23  *    may be used to endorse or promote products derived from this software
   24  *    without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   36  * SUCH DAMAGE.
   37  *
   38  *      @(#)bpf.c       8.4 (Berkeley) 1/9/95
   39  *
   40  * $FreeBSD: releng/5.0/sys/net/bpf.c 107080 2002-11-19 02:50:46Z sam $
   41  */
   42 
   43 #include "opt_bpf.h"
   44 #include "opt_mac.h"
   45 #include "opt_netgraph.h"
   46 
   47 #include <sys/param.h>
   48 #include <sys/systm.h>
   49 #include <sys/conf.h>
   50 #include <sys/mac.h>
   51 #include <sys/malloc.h>
   52 #include <sys/mbuf.h>
   53 #include <sys/time.h>
   54 #include <sys/proc.h>
   55 #include <sys/signalvar.h>
   56 #include <sys/filio.h>
   57 #include <sys/sockio.h>
   58 #include <sys/ttycom.h>
   59 #include <sys/filedesc.h>
   60 
   61 #include <sys/poll.h>
   62 
   63 #include <sys/socket.h>
   64 #include <sys/vnode.h>
   65 
   66 #include <net/if.h>
   67 #include <net/bpf.h>
   68 #include <net/bpfdesc.h>
   69 
   70 #include <netinet/in.h>
   71 #include <netinet/if_ether.h>
   72 #include <sys/kernel.h>
   73 #include <sys/sysctl.h>
   74 
   75 static MALLOC_DEFINE(M_BPF, "BPF", "BPF data");
   76 
   77 #if defined(DEV_BPF) || defined(NETGRAPH_BPF)
   78 
   79 #define PRINET  26                      /* interruptible */
   80 
   81 /*
   82  * The default read buffer size is patchable.
   83  */
   84 static int bpf_bufsize = 4096;
   85 SYSCTL_INT(_debug, OID_AUTO, bpf_bufsize, CTLFLAG_RW, 
   86         &bpf_bufsize, 0, "");
   87 static int bpf_maxbufsize = BPF_MAXBUFSIZE;
   88 SYSCTL_INT(_debug, OID_AUTO, bpf_maxbufsize, CTLFLAG_RW, 
   89         &bpf_maxbufsize, 0, "");
   90 
   91 /*
   92  *  bpf_iflist is the list of interfaces; each corresponds to an ifnet
   93  */
   94 static struct bpf_if    *bpf_iflist;
   95 static struct mtx       bpf_mtx;                /* bpf global lock */
   96 
   97 static int      bpf_allocbufs(struct bpf_d *);
   98 static void     bpf_attachd(struct bpf_d *d, struct bpf_if *bp);
   99 static void     bpf_detachd(struct bpf_d *d);
  100 static void     bpf_freed(struct bpf_d *);
  101 static void     bpf_mcopy(const void *, void *, size_t);
  102 static int      bpf_movein(struct uio *, int,
  103                     struct mbuf **, struct sockaddr *, int *);
  104 static int      bpf_setif(struct bpf_d *, struct ifreq *);
  105 static void     bpf_timed_out(void *);
  106 static __inline void
  107                 bpf_wakeup(struct bpf_d *);
  108 static void     catchpacket(struct bpf_d *, u_char *, u_int,
  109                     u_int, void (*)(const void *, void *, size_t));
  110 static void     reset_d(struct bpf_d *);
  111 static int       bpf_setf(struct bpf_d *, struct bpf_program *);
  112 
  113 static  d_open_t        bpfopen;
  114 static  d_close_t       bpfclose;
  115 static  d_read_t        bpfread;
  116 static  d_write_t       bpfwrite;
  117 static  d_ioctl_t       bpfioctl;
  118 static  d_poll_t        bpfpoll;
  119 
  120 #define CDEV_MAJOR 23
  121 static struct cdevsw bpf_cdevsw = {
  122         /* open */      bpfopen,
  123         /* close */     bpfclose,
  124         /* read */      bpfread,
  125         /* write */     bpfwrite,
  126         /* ioctl */     bpfioctl,
  127         /* poll */      bpfpoll,
  128         /* mmap */      nommap,
  129         /* strategy */  nostrategy,
  130         /* name */      "bpf",
  131         /* maj */       CDEV_MAJOR,
  132         /* dump */      nodump,
  133         /* psize */     nopsize,
  134         /* flags */     0,
  135 };
  136 
  137 
  138 static int
  139 bpf_movein(uio, linktype, mp, sockp, datlen)
  140         register struct uio *uio;
  141         int linktype, *datlen;
  142         register struct mbuf **mp;
  143         register struct sockaddr *sockp;
  144 {
  145         struct mbuf *m;
  146         int error;
  147         int len;
  148         int hlen;
  149 
  150         /*
  151          * Build a sockaddr based on the data link layer type.
  152          * We do this at this level because the ethernet header
  153          * is copied directly into the data field of the sockaddr.
  154          * In the case of SLIP, there is no header and the packet
  155          * is forwarded as is.
  156          * Also, we are careful to leave room at the front of the mbuf
  157          * for the link level header.
  158          */
  159         switch (linktype) {
  160 
  161         case DLT_SLIP:
  162                 sockp->sa_family = AF_INET;
  163                 hlen = 0;
  164                 break;
  165 
  166         case DLT_EN10MB:
  167                 sockp->sa_family = AF_UNSPEC;
  168                 /* XXX Would MAXLINKHDR be better? */
  169                 hlen = sizeof(struct ether_header);
  170                 break;
  171 
  172         case DLT_FDDI:
  173                 sockp->sa_family = AF_IMPLINK;
  174                 hlen = 0;
  175                 break;
  176 
  177         case DLT_RAW:
  178         case DLT_NULL:
  179                 sockp->sa_family = AF_UNSPEC;
  180                 hlen = 0;
  181                 break;
  182 
  183         case DLT_ATM_RFC1483:
  184                 /*
  185                  * en atm driver requires 4-byte atm pseudo header.
  186                  * though it isn't standard, vpi:vci needs to be
  187                  * specified anyway.
  188                  */
  189                 sockp->sa_family = AF_UNSPEC;
  190                 hlen = 12;      /* XXX 4(ATM_PH) + 3(LLC) + 5(SNAP) */
  191                 break;
  192 
  193         case DLT_PPP:
  194                 sockp->sa_family = AF_UNSPEC;
  195                 hlen = 4;       /* This should match PPP_HDRLEN */
  196                 break;
  197 
  198         default:
  199                 return (EIO);
  200         }
  201 
  202         len = uio->uio_resid;
  203         *datlen = len - hlen;
  204         if ((unsigned)len > MCLBYTES)
  205                 return (EIO);
  206 
  207         if (len > MHLEN) {
  208                 m = m_getcl(M_TRYWAIT, MT_DATA, M_PKTHDR);
  209         } else {
  210                 MGETHDR(m, M_TRYWAIT, MT_DATA);
  211         }
  212         if (m == NULL)
  213                 return (ENOBUFS);
  214         m->m_pkthdr.len = m->m_len = len;
  215         m->m_pkthdr.rcvif = NULL;
  216         *mp = m;
  217 
  218         /*
  219          * Make room for link header.
  220          */
  221         if (hlen != 0) {
  222                 m->m_pkthdr.len -= hlen;
  223                 m->m_len -= hlen;
  224 #if BSD >= 199103
  225                 m->m_data += hlen; /* XXX */
  226 #else
  227                 m->m_off += hlen;
  228 #endif
  229                 error = uiomove((caddr_t)sockp->sa_data, hlen, uio);
  230                 if (error)
  231                         goto bad;
  232         }
  233         error = uiomove(mtod(m, caddr_t), len - hlen, uio);
  234         if (!error)
  235                 return (0);
  236 bad:
  237         m_freem(m);
  238         return (error);
  239 }
  240 
  241 /*
  242  * Attach file to the bpf interface, i.e. make d listen on bp.
  243  */
  244 static void
  245 bpf_attachd(d, bp)
  246         struct bpf_d *d;
  247         struct bpf_if *bp;
  248 {
  249         /*
  250          * Point d at bp, and add d to the interface's list of listeners.
  251          * Finally, point the driver's bpf cookie at the interface so
  252          * it will divert packets to bpf.
  253          */
  254         BPFIF_LOCK(bp);
  255         d->bd_bif = bp;
  256         d->bd_next = bp->bif_dlist;
  257         bp->bif_dlist = d;
  258 
  259         *bp->bif_driverp = bp;
  260         BPFIF_UNLOCK(bp);
  261 }
  262 
  263 /*
  264  * Detach a file from its interface.
  265  */
  266 static void
  267 bpf_detachd(d)
  268         struct bpf_d *d;
  269 {
  270         int error;
  271         struct bpf_d **p;
  272         struct bpf_if *bp;
  273 
  274         bp = d->bd_bif;
  275         /*
  276          * Check if this descriptor had requested promiscuous mode.
  277          * If so, turn it off.
  278          */
  279         if (d->bd_promisc) {
  280                 d->bd_promisc = 0;
  281                 error = ifpromisc(bp->bif_ifp, 0);
  282                 if (error != 0 && error != ENXIO) {
  283                         /*
  284                          * ENXIO can happen if a pccard is unplugged
  285                          * Something is really wrong if we were able to put
  286                          * the driver into promiscuous mode, but can't
  287                          * take it out.
  288                          */
  289                         if_printf(bp->bif_ifp, "ifpromisc failed %d\n", error);
  290                 }
  291         }
  292         /* Remove d from the interface's descriptor list. */
  293         BPFIF_LOCK(bp);
  294         p = &bp->bif_dlist;
  295         while (*p != d) {
  296                 p = &(*p)->bd_next;
  297                 if (*p == 0)
  298                         panic("bpf_detachd: descriptor not in list");
  299         }
  300         *p = (*p)->bd_next;
  301         if (bp->bif_dlist == 0)
  302                 /*
  303                  * Let the driver know that there are no more listeners.
  304                  */
  305                 *d->bd_bif->bif_driverp = 0;
  306         BPFIF_UNLOCK(bp);
  307         d->bd_bif = 0;
  308 }
  309 
  310 /*
  311  * Open ethernet device.  Returns ENXIO for illegal minor device number,
  312  * EBUSY if file is open by another process.
  313  */
  314 /* ARGSUSED */
  315 static  int
  316 bpfopen(dev, flags, fmt, td)
  317         dev_t dev;
  318         int flags;
  319         int fmt;
  320         struct thread *td;
  321 {
  322         struct bpf_d *d;
  323 
  324         mtx_lock(&bpf_mtx);
  325         d = dev->si_drv1;
  326         /*
  327          * Each minor can be opened by only one process.  If the requested 
  328          * minor is in use, return EBUSY.
  329          */
  330         if (d) {
  331                 mtx_unlock(&bpf_mtx);
  332                 return (EBUSY);
  333         }
  334         dev->si_drv1 = (struct bpf_d *)~0;      /* mark device in use */
  335         mtx_unlock(&bpf_mtx);
  336 
  337         if ((dev->si_flags & SI_NAMED) == 0)
  338                 make_dev(&bpf_cdevsw, minor(dev), UID_ROOT, GID_WHEEL, 0600,
  339                     "bpf%d", dev2unit(dev));
  340         MALLOC(d, struct bpf_d *, sizeof(*d), M_BPF, M_WAITOK | M_ZERO);
  341         dev->si_drv1 = d;
  342         d->bd_bufsize = bpf_bufsize;
  343         d->bd_sig = SIGIO;
  344         d->bd_seesent = 1;
  345 #ifdef MAC
  346         mac_init_bpfdesc(d);
  347         mac_create_bpfdesc(td->td_ucred, d);
  348 #endif
  349         mtx_init(&d->bd_mtx, devtoname(dev), "bpf cdev lock", MTX_DEF);
  350         callout_init(&d->bd_callout, 1);
  351 
  352         return (0);
  353 }
  354 
  355 /*
  356  * Close the descriptor by detaching it from its interface,
  357  * deallocating its buffers, and marking it free.
  358  */
  359 /* ARGSUSED */
  360 static  int
  361 bpfclose(dev, flags, fmt, td)
  362         dev_t dev;
  363         int flags;
  364         int fmt;
  365         struct thread *td;
  366 {
  367         struct bpf_d *d = dev->si_drv1;
  368 
  369         BPFD_LOCK(d);
  370         if (d->bd_state == BPF_WAITING)
  371                 callout_stop(&d->bd_callout);
  372         d->bd_state = BPF_IDLE;
  373         BPFD_UNLOCK(d);
  374         funsetown(&d->bd_sigio);
  375         mtx_lock(&bpf_mtx);
  376         if (d->bd_bif)
  377                 bpf_detachd(d);
  378         mtx_unlock(&bpf_mtx);
  379 #ifdef MAC
  380         mac_destroy_bpfdesc(d);
  381 #endif /* MAC */
  382         bpf_freed(d);
  383         dev->si_drv1 = 0;
  384         free(d, M_BPF);
  385 
  386         return (0);
  387 }
  388 
  389 
  390 /*
  391  * Rotate the packet buffers in descriptor d.  Move the store buffer
  392  * into the hold slot, and the free buffer into the store slot.
  393  * Zero the length of the new store buffer.
  394  */
  395 #define ROTATE_BUFFERS(d) \
  396         (d)->bd_hbuf = (d)->bd_sbuf; \
  397         (d)->bd_hlen = (d)->bd_slen; \
  398         (d)->bd_sbuf = (d)->bd_fbuf; \
  399         (d)->bd_slen = 0; \
  400         (d)->bd_fbuf = 0;
  401 /*
  402  *  bpfread - read next chunk of packets from buffers
  403  */
  404 static  int
  405 bpfread(dev, uio, ioflag)
  406         dev_t dev;
  407         register struct uio *uio;
  408         int ioflag;
  409 {
  410         struct bpf_d *d = dev->si_drv1;
  411         int timed_out;
  412         int error;
  413 
  414         /*
  415          * Restrict application to use a buffer the same size as
  416          * as kernel buffers.
  417          */
  418         if (uio->uio_resid != d->bd_bufsize)
  419                 return (EINVAL);
  420 
  421         BPFD_LOCK(d);
  422         if (d->bd_state == BPF_WAITING)
  423                 callout_stop(&d->bd_callout);
  424         timed_out = (d->bd_state == BPF_TIMED_OUT);
  425         d->bd_state = BPF_IDLE;
  426         /*
  427          * If the hold buffer is empty, then do a timed sleep, which
  428          * ends when the timeout expires or when enough packets
  429          * have arrived to fill the store buffer.
  430          */
  431         while (d->bd_hbuf == 0) {
  432                 if ((d->bd_immediate || timed_out) && d->bd_slen != 0) {
  433                         /*
  434                          * A packet(s) either arrived since the previous
  435                          * read or arrived while we were asleep.
  436                          * Rotate the buffers and return what's here.
  437                          */
  438                         ROTATE_BUFFERS(d);
  439                         break;
  440                 }
  441 
  442                 /*
  443                  * No data is available, check to see if the bpf device
  444                  * is still pointed at a real interface.  If not, return
  445                  * ENXIO so that the userland process knows to rebind
  446                  * it before using it again.
  447                  */
  448                 if (d->bd_bif == NULL) {
  449                         BPFD_UNLOCK(d);
  450                         return (ENXIO);
  451                 }
  452 
  453                 if (ioflag & IO_NDELAY) {
  454                         BPFD_UNLOCK(d);
  455                         return (EWOULDBLOCK);
  456                 }
  457                 error = msleep((caddr_t)d, &d->bd_mtx, PRINET|PCATCH,
  458                      "bpf", d->bd_rtout);
  459                 if (error == EINTR || error == ERESTART) {
  460                         BPFD_UNLOCK(d);
  461                         return (error);
  462                 }
  463                 if (error == EWOULDBLOCK) {
  464                         /*
  465                          * On a timeout, return what's in the buffer,
  466                          * which may be nothing.  If there is something
  467                          * in the store buffer, we can rotate the buffers.
  468                          */
  469                         if (d->bd_hbuf)
  470                                 /*
  471                                  * We filled up the buffer in between
  472                                  * getting the timeout and arriving
  473                                  * here, so we don't need to rotate.
  474                                  */
  475                                 break;
  476 
  477                         if (d->bd_slen == 0) {
  478                                 BPFD_UNLOCK(d);
  479                                 return (0);
  480                         }
  481                         ROTATE_BUFFERS(d);
  482                         break;
  483                 }
  484         }
  485         /*
  486          * At this point, we know we have something in the hold slot.
  487          */
  488         BPFD_UNLOCK(d);
  489 
  490         /*
  491          * Move data from hold buffer into user space.
  492          * We know the entire buffer is transferred since
  493          * we checked above that the read buffer is bpf_bufsize bytes.
  494          */
  495         error = uiomove(d->bd_hbuf, d->bd_hlen, uio);
  496 
  497         BPFD_LOCK(d);
  498         d->bd_fbuf = d->bd_hbuf;
  499         d->bd_hbuf = 0;
  500         d->bd_hlen = 0;
  501         BPFD_UNLOCK(d);
  502 
  503         return (error);
  504 }
  505 
  506 
  507 /*
  508  * If there are processes sleeping on this descriptor, wake them up.
  509  */
  510 static __inline void
  511 bpf_wakeup(d)
  512         register struct bpf_d *d;
  513 {
  514         if (d->bd_state == BPF_WAITING) {
  515                 callout_stop(&d->bd_callout);
  516                 d->bd_state = BPF_IDLE;
  517         }
  518         wakeup((caddr_t)d);
  519         if (d->bd_async && d->bd_sig && d->bd_sigio)
  520                 pgsigio(&d->bd_sigio, d->bd_sig, 0);
  521 
  522         selwakeup(&d->bd_sel);
  523 }
  524 
  525 static void
  526 bpf_timed_out(arg)
  527         void *arg;
  528 {
  529         struct bpf_d *d = (struct bpf_d *)arg;
  530 
  531         BPFD_LOCK(d);
  532         if (d->bd_state == BPF_WAITING) {
  533                 d->bd_state = BPF_TIMED_OUT;
  534                 if (d->bd_slen != 0)
  535                         bpf_wakeup(d);
  536         }
  537         BPFD_UNLOCK(d);
  538 }
  539 
  540 static  int
  541 bpfwrite(dev, uio, ioflag)
  542         dev_t dev;
  543         struct uio *uio;
  544         int ioflag;
  545 {
  546         struct bpf_d *d = dev->si_drv1;
  547         struct ifnet *ifp;
  548         struct mbuf *m;
  549         int error;
  550         static struct sockaddr dst;
  551         int datlen;
  552 
  553         if (d->bd_bif == 0)
  554                 return (ENXIO);
  555 
  556         ifp = d->bd_bif->bif_ifp;
  557 
  558         if (uio->uio_resid == 0)
  559                 return (0);
  560 
  561         error = bpf_movein(uio, (int)d->bd_bif->bif_dlt, &m, &dst, &datlen);
  562         if (error)
  563                 return (error);
  564 
  565         if (datlen > ifp->if_mtu)
  566                 return (EMSGSIZE);
  567 
  568         if (d->bd_hdrcmplt)
  569                 dst.sa_family = pseudo_AF_HDRCMPLT;
  570 
  571         mtx_lock(&Giant);
  572 #ifdef MAC
  573         mac_create_mbuf_from_bpfdesc(d, m);
  574 #endif
  575         error = (*ifp->if_output)(ifp, m, &dst, (struct rtentry *)0);
  576         mtx_unlock(&Giant);
  577         /*
  578          * The driver frees the mbuf.
  579          */
  580         return (error);
  581 }
  582 
  583 /*
  584  * Reset a descriptor by flushing its packet buffer and clearing the
  585  * receive and drop counts.
  586  */
  587 static void
  588 reset_d(d)
  589         struct bpf_d *d;
  590 {
  591 
  592         mtx_assert(&d->bd_mtx, MA_OWNED);
  593         if (d->bd_hbuf) {
  594                 /* Free the hold buffer. */
  595                 d->bd_fbuf = d->bd_hbuf;
  596                 d->bd_hbuf = 0;
  597         }
  598         d->bd_slen = 0;
  599         d->bd_hlen = 0;
  600         d->bd_rcount = 0;
  601         d->bd_dcount = 0;
  602 }
  603 
  604 /*
  605  *  FIONREAD            Check for read packet available.
  606  *  SIOCGIFADDR         Get interface address - convenient hook to driver.
  607  *  BIOCGBLEN           Get buffer len [for read()].
  608  *  BIOCSETF            Set ethernet read filter.
  609  *  BIOCFLUSH           Flush read packet buffer.
  610  *  BIOCPROMISC         Put interface into promiscuous mode.
  611  *  BIOCGDLT            Get link layer type.
  612  *  BIOCGETIF           Get interface name.
  613  *  BIOCSETIF           Set interface.
  614  *  BIOCSRTIMEOUT       Set read timeout.
  615  *  BIOCGRTIMEOUT       Get read timeout.
  616  *  BIOCGSTATS          Get packet stats.
  617  *  BIOCIMMEDIATE       Set immediate mode.
  618  *  BIOCVERSION         Get filter language version.
  619  *  BIOCGHDRCMPLT       Get "header already complete" flag
  620  *  BIOCSHDRCMPLT       Set "header already complete" flag
  621  *  BIOCGSEESENT        Get "see packets sent" flag
  622  *  BIOCSSEESENT        Set "see packets sent" flag
  623  */
  624 /* ARGSUSED */
  625 static  int
  626 bpfioctl(dev, cmd, addr, flags, td)
  627         dev_t dev;
  628         u_long cmd;
  629         caddr_t addr;
  630         int flags;
  631         struct thread *td;
  632 {
  633         struct bpf_d *d = dev->si_drv1;
  634         int error = 0;
  635 
  636         BPFD_LOCK(d);
  637         if (d->bd_state == BPF_WAITING)
  638                 callout_stop(&d->bd_callout);
  639         d->bd_state = BPF_IDLE;
  640         BPFD_UNLOCK(d);
  641 
  642         switch (cmd) {
  643 
  644         default:
  645                 error = EINVAL;
  646                 break;
  647 
  648         /*
  649          * Check for read packet available.
  650          */
  651         case FIONREAD:
  652                 {
  653                         int n;
  654 
  655                         BPFD_LOCK(d);
  656                         n = d->bd_slen;
  657                         if (d->bd_hbuf)
  658                                 n += d->bd_hlen;
  659                         BPFD_UNLOCK(d);
  660 
  661                         *(int *)addr = n;
  662                         break;
  663                 }
  664 
  665         case SIOCGIFADDR:
  666                 {
  667                         struct ifnet *ifp;
  668 
  669                         if (d->bd_bif == 0)
  670                                 error = EINVAL;
  671                         else {
  672                                 ifp = d->bd_bif->bif_ifp;
  673                                 error = (*ifp->if_ioctl)(ifp, cmd, addr);
  674                         }
  675                         break;
  676                 }
  677 
  678         /*
  679          * Get buffer len [for read()].
  680          */
  681         case BIOCGBLEN:
  682                 *(u_int *)addr = d->bd_bufsize;
  683                 break;
  684 
  685         /*
  686          * Set buffer length.
  687          */
  688         case BIOCSBLEN:
  689                 if (d->bd_bif != 0)
  690                         error = EINVAL;
  691                 else {
  692                         register u_int size = *(u_int *)addr;
  693 
  694                         if (size > bpf_maxbufsize)
  695                                 *(u_int *)addr = size = bpf_maxbufsize;
  696                         else if (size < BPF_MINBUFSIZE)
  697                                 *(u_int *)addr = size = BPF_MINBUFSIZE;
  698                         d->bd_bufsize = size;
  699                 }
  700                 break;
  701 
  702         /*
  703          * Set link layer read filter.
  704          */
  705         case BIOCSETF:
  706                 error = bpf_setf(d, (struct bpf_program *)addr);
  707                 break;
  708 
  709         /*
  710          * Flush read packet buffer.
  711          */
  712         case BIOCFLUSH:
  713                 BPFD_LOCK(d);
  714                 reset_d(d);
  715                 BPFD_UNLOCK(d);
  716                 break;
  717 
  718         /*
  719          * Put interface into promiscuous mode.
  720          */
  721         case BIOCPROMISC:
  722                 if (d->bd_bif == 0) {
  723                         /*
  724                          * No interface attached yet.
  725                          */
  726                         error = EINVAL;
  727                         break;
  728                 }
  729                 if (d->bd_promisc == 0) {
  730                         mtx_lock(&Giant);
  731                         error = ifpromisc(d->bd_bif->bif_ifp, 1);
  732                         mtx_unlock(&Giant);
  733                         if (error == 0)
  734                                 d->bd_promisc = 1;
  735                 }
  736                 break;
  737 
  738         /*
  739          * Get device parameters.
  740          */
  741         case BIOCGDLT:
  742                 if (d->bd_bif == 0)
  743                         error = EINVAL;
  744                 else
  745                         *(u_int *)addr = d->bd_bif->bif_dlt;
  746                 break;
  747 
  748         /*
  749          * Get interface name.
  750          */
  751         case BIOCGETIF:
  752                 if (d->bd_bif == 0)
  753                         error = EINVAL;
  754                 else {
  755                         struct ifnet *const ifp = d->bd_bif->bif_ifp;
  756                         struct ifreq *const ifr = (struct ifreq *)addr;
  757 
  758                         snprintf(ifr->ifr_name, sizeof(ifr->ifr_name),
  759                             "%s%d", ifp->if_name, ifp->if_unit);
  760                 }
  761                 break;
  762 
  763         /*
  764          * Set interface.
  765          */
  766         case BIOCSETIF:
  767                 error = bpf_setif(d, (struct ifreq *)addr);
  768                 break;
  769 
  770         /*
  771          * Set read timeout.
  772          */
  773         case BIOCSRTIMEOUT:
  774                 {
  775                         struct timeval *tv = (struct timeval *)addr;
  776 
  777                         /*
  778                          * Subtract 1 tick from tvtohz() since this isn't
  779                          * a one-shot timer.
  780                          */
  781                         if ((error = itimerfix(tv)) == 0)
  782                                 d->bd_rtout = tvtohz(tv) - 1;
  783                         break;
  784                 }
  785 
  786         /*
  787          * Get read timeout.
  788          */
  789         case BIOCGRTIMEOUT:
  790                 {
  791                         struct timeval *tv = (struct timeval *)addr;
  792 
  793                         tv->tv_sec = d->bd_rtout / hz;
  794                         tv->tv_usec = (d->bd_rtout % hz) * tick;
  795                         break;
  796                 }
  797 
  798         /*
  799          * Get packet stats.
  800          */
  801         case BIOCGSTATS:
  802                 {
  803                         struct bpf_stat *bs = (struct bpf_stat *)addr;
  804 
  805                         bs->bs_recv = d->bd_rcount;
  806                         bs->bs_drop = d->bd_dcount;
  807                         break;
  808                 }
  809 
  810         /*
  811          * Set immediate mode.
  812          */
  813         case BIOCIMMEDIATE:
  814                 d->bd_immediate = *(u_int *)addr;
  815                 break;
  816 
  817         case BIOCVERSION:
  818                 {
  819                         struct bpf_version *bv = (struct bpf_version *)addr;
  820 
  821                         bv->bv_major = BPF_MAJOR_VERSION;
  822                         bv->bv_minor = BPF_MINOR_VERSION;
  823                         break;
  824                 }
  825 
  826         /*
  827          * Get "header already complete" flag
  828          */
  829         case BIOCGHDRCMPLT:
  830                 *(u_int *)addr = d->bd_hdrcmplt;
  831                 break;
  832 
  833         /*
  834          * Set "header already complete" flag
  835          */
  836         case BIOCSHDRCMPLT:
  837                 d->bd_hdrcmplt = *(u_int *)addr ? 1 : 0;
  838                 break;
  839 
  840         /*
  841          * Get "see sent packets" flag
  842          */
  843         case BIOCGSEESENT:
  844                 *(u_int *)addr = d->bd_seesent;
  845                 break;
  846 
  847         /*
  848          * Set "see sent packets" flag
  849          */
  850         case BIOCSSEESENT:
  851                 d->bd_seesent = *(u_int *)addr;
  852                 break;
  853 
  854         case FIONBIO:           /* Non-blocking I/O */
  855                 break;
  856 
  857         case FIOASYNC:          /* Send signal on receive packets */
  858                 d->bd_async = *(int *)addr;
  859                 break;
  860 
  861         case FIOSETOWN:
  862                 error = fsetown(*(int *)addr, &d->bd_sigio);
  863                 break;
  864 
  865         case FIOGETOWN:
  866                 *(int *)addr = fgetown(&d->bd_sigio);
  867                 break;
  868 
  869         /* This is deprecated, FIOSETOWN should be used instead. */
  870         case TIOCSPGRP:
  871                 error = fsetown(-(*(int *)addr), &d->bd_sigio);
  872                 break;
  873 
  874         /* This is deprecated, FIOGETOWN should be used instead. */
  875         case TIOCGPGRP:
  876                 *(int *)addr = -fgetown(&d->bd_sigio);
  877                 break;
  878 
  879         case BIOCSRSIG:         /* Set receive signal */
  880                 {
  881                         u_int sig;
  882 
  883                         sig = *(u_int *)addr;
  884 
  885                         if (sig >= NSIG)
  886                                 error = EINVAL;
  887                         else
  888                                 d->bd_sig = sig;
  889                         break;
  890                 }
  891         case BIOCGRSIG:
  892                 *(u_int *)addr = d->bd_sig;
  893                 break;
  894         }
  895         return (error);
  896 }
  897 
  898 /*
  899  * Set d's packet filter program to fp.  If this file already has a filter,
  900  * free it and replace it.  Returns EINVAL for bogus requests.
  901  */
  902 static int
  903 bpf_setf(d, fp)
  904         struct bpf_d *d;
  905         struct bpf_program *fp;
  906 {
  907         struct bpf_insn *fcode, *old;
  908         u_int flen, size;
  909 
  910         old = d->bd_filter;
  911         if (fp->bf_insns == 0) {
  912                 if (fp->bf_len != 0)
  913                         return (EINVAL);
  914                 BPFD_LOCK(d);
  915                 d->bd_filter = 0;
  916                 reset_d(d);
  917                 BPFD_UNLOCK(d);
  918                 if (old != 0)
  919                         free((caddr_t)old, M_BPF);
  920                 return (0);
  921         }
  922         flen = fp->bf_len;
  923         if (flen > BPF_MAXINSNS)
  924                 return (EINVAL);
  925 
  926         size = flen * sizeof(*fp->bf_insns);
  927         fcode = (struct bpf_insn *)malloc(size, M_BPF, M_WAITOK);
  928         if (copyin((caddr_t)fp->bf_insns, (caddr_t)fcode, size) == 0 &&
  929             bpf_validate(fcode, (int)flen)) {
  930                 BPFD_LOCK(d);
  931                 d->bd_filter = fcode;
  932                 reset_d(d);
  933                 BPFD_UNLOCK(d);
  934                 if (old != 0)
  935                         free((caddr_t)old, M_BPF);
  936 
  937                 return (0);
  938         }
  939         free((caddr_t)fcode, M_BPF);
  940         return (EINVAL);
  941 }
  942 
  943 /*
  944  * Detach a file from its current interface (if attached at all) and attach
  945  * to the interface indicated by the name stored in ifr.
  946  * Return an errno or 0.
  947  */
  948 static int
  949 bpf_setif(d, ifr)
  950         struct bpf_d *d;
  951         struct ifreq *ifr;
  952 {
  953         struct bpf_if *bp;
  954         int error;
  955         struct ifnet *theywant;
  956 
  957         theywant = ifunit(ifr->ifr_name);
  958         if (theywant == 0)
  959                 return ENXIO;
  960 
  961         /*
  962          * Look through attached interfaces for the named one.
  963          */
  964         mtx_lock(&bpf_mtx);
  965         for (bp = bpf_iflist; bp != 0; bp = bp->bif_next) {
  966                 struct ifnet *ifp = bp->bif_ifp;
  967 
  968                 if (ifp == 0 || ifp != theywant)
  969                         continue;
  970                 /* skip additional entry */
  971                 if (bp->bif_driverp != (struct bpf_if **)&ifp->if_bpf)
  972                         continue;
  973 
  974                 mtx_unlock(&bpf_mtx);
  975                 /*
  976                  * We found the requested interface.
  977                  * If it's not up, return an error.
  978                  * Allocate the packet buffers if we need to.
  979                  * If we're already attached to requested interface,
  980                  * just flush the buffer.
  981                  */
  982                 if ((ifp->if_flags & IFF_UP) == 0)
  983                         return (ENETDOWN);
  984 
  985                 if (d->bd_sbuf == 0) {
  986                         error = bpf_allocbufs(d);
  987                         if (error != 0)
  988                                 return (error);
  989                 }
  990                 if (bp != d->bd_bif) {
  991                         if (d->bd_bif)
  992                                 /*
  993                                  * Detach if attached to something else.
  994                                  */
  995                                 bpf_detachd(d);
  996 
  997                         bpf_attachd(d, bp);
  998                 }
  999                 BPFD_LOCK(d);
 1000                 reset_d(d);
 1001                 BPFD_UNLOCK(d);
 1002                 return (0);
 1003         }
 1004         mtx_unlock(&bpf_mtx);
 1005         /* Not found. */
 1006         return (ENXIO);
 1007 }
 1008 
 1009 /*
 1010  * Support for select() and poll() system calls
 1011  *
 1012  * Return true iff the specific operation will not block indefinitely.
 1013  * Otherwise, return false but make a note that a selwakeup() must be done.
 1014  */
 1015 static int
 1016 bpfpoll(dev, events, td)
 1017         register dev_t dev;
 1018         int events;
 1019         struct thread *td;
 1020 {
 1021         struct bpf_d *d;
 1022         int revents;
 1023 
 1024         d = dev->si_drv1;
 1025         if (d->bd_bif == NULL)
 1026                 return (ENXIO);
 1027 
 1028         revents = events & (POLLOUT | POLLWRNORM);
 1029         BPFD_LOCK(d);
 1030         if (events & (POLLIN | POLLRDNORM)) {
 1031                 /*
 1032                  * An imitation of the FIONREAD ioctl code.
 1033                  * XXX not quite.  An exact imitation:
 1034                  *      if (d->b_slen != 0 ||
 1035                  *          (d->bd_hbuf != NULL && d->bd_hlen != 0)
 1036                  */
 1037                 if (d->bd_hlen != 0 ||
 1038                     ((d->bd_immediate || d->bd_state == BPF_TIMED_OUT) &&
 1039                     d->bd_slen != 0))
 1040                         revents |= events & (POLLIN | POLLRDNORM);
 1041                 else {
 1042                         selrecord(td, &d->bd_sel);
 1043                         /* Start the read timeout if necessary. */
 1044                         if (d->bd_rtout > 0 && d->bd_state == BPF_IDLE) {
 1045                                 callout_reset(&d->bd_callout, d->bd_rtout,
 1046                                     bpf_timed_out, d);
 1047                                 d->bd_state = BPF_WAITING;
 1048                         }
 1049                 }
 1050         }
 1051         BPFD_UNLOCK(d);
 1052         return (revents);
 1053 }
 1054 
 1055 /*
 1056  * Incoming linkage from device drivers.  Process the packet pkt, of length
 1057  * pktlen, which is stored in a contiguous buffer.  The packet is parsed
 1058  * by each process' filter, and if accepted, stashed into the corresponding
 1059  * buffer.
 1060  */
 1061 void
 1062 bpf_tap(bp, pkt, pktlen)
 1063         struct bpf_if *bp;
 1064         register u_char *pkt;
 1065         register u_int pktlen;
 1066 {
 1067         register struct bpf_d *d;
 1068         register u_int slen;
 1069 
 1070         BPFIF_LOCK(bp);
 1071         for (d = bp->bif_dlist; d != 0; d = d->bd_next) {
 1072                 BPFD_LOCK(d);
 1073                 ++d->bd_rcount;
 1074                 slen = bpf_filter(d->bd_filter, pkt, pktlen, pktlen);
 1075                 if (slen != 0) {
 1076 #ifdef MAC
 1077                         if (mac_check_bpfdesc_receive(d, bp->bif_ifp) == 0)
 1078 #endif
 1079                                 catchpacket(d, pkt, pktlen, slen, bcopy);
 1080                 }
 1081                 BPFD_UNLOCK(d);
 1082         }
 1083         BPFIF_UNLOCK(bp);
 1084 }
 1085 
 1086 /*
 1087  * Copy data from an mbuf chain into a buffer.  This code is derived
 1088  * from m_copydata in sys/uipc_mbuf.c.
 1089  */
 1090 static void
 1091 bpf_mcopy(src_arg, dst_arg, len)
 1092         const void *src_arg;
 1093         void *dst_arg;
 1094         register size_t len;
 1095 {
 1096         register const struct mbuf *m;
 1097         register u_int count;
 1098         u_char *dst;
 1099 
 1100         m = src_arg;
 1101         dst = dst_arg;
 1102         while (len > 0) {
 1103                 if (m == 0)
 1104                         panic("bpf_mcopy");
 1105                 count = min(m->m_len, len);
 1106                 bcopy(mtod(m, void *), dst, count);
 1107                 m = m->m_next;
 1108                 dst += count;
 1109                 len -= count;
 1110         }
 1111 }
 1112 
 1113 /*
 1114  * Incoming linkage from device drivers, when packet is in an mbuf chain.
 1115  */
 1116 void
 1117 bpf_mtap(bp, m)
 1118         struct bpf_if *bp;
 1119         struct mbuf *m;
 1120 {
 1121         struct bpf_d *d;
 1122         u_int pktlen, slen;
 1123 
 1124         pktlen = m_length(m, NULL);
 1125         if (pktlen == m->m_len) {
 1126                 bpf_tap(bp, mtod(m, u_char *), pktlen);
 1127                 return;
 1128         }
 1129 
 1130         BPFIF_LOCK(bp);
 1131         for (d = bp->bif_dlist; d != 0; d = d->bd_next) {
 1132                 if (!d->bd_seesent && (m->m_pkthdr.rcvif == NULL))
 1133                         continue;
 1134                 BPFD_LOCK(d);
 1135                 ++d->bd_rcount;
 1136                 slen = bpf_filter(d->bd_filter, (u_char *)m, pktlen, 0);
 1137                 if (slen != 0)
 1138 #ifdef MAC
 1139                         if (mac_check_bpfdesc_receive(d, bp->bif_ifp) == 0)
 1140 #endif
 1141                                 catchpacket(d, (u_char *)m, pktlen, slen,
 1142                                     bpf_mcopy);
 1143                 BPFD_UNLOCK(d);
 1144         }
 1145         BPFIF_UNLOCK(bp);
 1146 }
 1147 
 1148 /*
 1149  * Move the packet data from interface memory (pkt) into the
 1150  * store buffer.  Return 1 if it's time to wakeup a listener (buffer full),
 1151  * otherwise 0.  "copy" is the routine called to do the actual data
 1152  * transfer.  bcopy is passed in to copy contiguous chunks, while
 1153  * bpf_mcopy is passed in to copy mbuf chains.  In the latter case,
 1154  * pkt is really an mbuf.
 1155  */
 1156 static void
 1157 catchpacket(d, pkt, pktlen, snaplen, cpfn)
 1158         register struct bpf_d *d;
 1159         register u_char *pkt;
 1160         register u_int pktlen, snaplen;
 1161         register void (*cpfn)(const void *, void *, size_t);
 1162 {
 1163         register struct bpf_hdr *hp;
 1164         register int totlen, curlen;
 1165         register int hdrlen = d->bd_bif->bif_hdrlen;
 1166         /*
 1167          * Figure out how many bytes to move.  If the packet is
 1168          * greater or equal to the snapshot length, transfer that
 1169          * much.  Otherwise, transfer the whole packet (unless
 1170          * we hit the buffer size limit).
 1171          */
 1172         totlen = hdrlen + min(snaplen, pktlen);
 1173         if (totlen > d->bd_bufsize)
 1174                 totlen = d->bd_bufsize;
 1175 
 1176         /*
 1177          * Round up the end of the previous packet to the next longword.
 1178          */
 1179         curlen = BPF_WORDALIGN(d->bd_slen);
 1180         if (curlen + totlen > d->bd_bufsize) {
 1181                 /*
 1182                  * This packet will overflow the storage buffer.
 1183                  * Rotate the buffers if we can, then wakeup any
 1184                  * pending reads.
 1185                  */
 1186                 if (d->bd_fbuf == 0) {
 1187                         /*
 1188                          * We haven't completed the previous read yet,
 1189                          * so drop the packet.
 1190                          */
 1191                         ++d->bd_dcount;
 1192                         return;
 1193                 }
 1194                 ROTATE_BUFFERS(d);
 1195                 bpf_wakeup(d);
 1196                 curlen = 0;
 1197         }
 1198         else if (d->bd_immediate || d->bd_state == BPF_TIMED_OUT)
 1199                 /*
 1200                  * Immediate mode is set, or the read timeout has
 1201                  * already expired during a select call.  A packet
 1202                  * arrived, so the reader should be woken up.
 1203                  */
 1204                 bpf_wakeup(d);
 1205 
 1206         /*
 1207          * Append the bpf header.
 1208          */
 1209         hp = (struct bpf_hdr *)(d->bd_sbuf + curlen);
 1210         microtime(&hp->bh_tstamp);
 1211         hp->bh_datalen = pktlen;
 1212         hp->bh_hdrlen = hdrlen;
 1213         /*
 1214          * Copy the packet data into the store buffer and update its length.
 1215          */
 1216         (*cpfn)(pkt, (u_char *)hp + hdrlen, (hp->bh_caplen = totlen - hdrlen));
 1217         d->bd_slen = curlen + totlen;
 1218 }
 1219 
 1220 /*
 1221  * Initialize all nonzero fields of a descriptor.
 1222  */
 1223 static int
 1224 bpf_allocbufs(d)
 1225         register struct bpf_d *d;
 1226 {
 1227         d->bd_fbuf = (caddr_t)malloc(d->bd_bufsize, M_BPF, M_WAITOK);
 1228         if (d->bd_fbuf == 0)
 1229                 return (ENOBUFS);
 1230 
 1231         d->bd_sbuf = (caddr_t)malloc(d->bd_bufsize, M_BPF, M_WAITOK);
 1232         if (d->bd_sbuf == 0) {
 1233                 free(d->bd_fbuf, M_BPF);
 1234                 return (ENOBUFS);
 1235         }
 1236         d->bd_slen = 0;
 1237         d->bd_hlen = 0;
 1238         return (0);
 1239 }
 1240 
 1241 /*
 1242  * Free buffers currently in use by a descriptor.
 1243  * Called on close.
 1244  */
 1245 static void
 1246 bpf_freed(d)
 1247         register struct bpf_d *d;
 1248 {
 1249         /*
 1250          * We don't need to lock out interrupts since this descriptor has
 1251          * been detached from its interface and it yet hasn't been marked
 1252          * free.
 1253          */
 1254         if (d->bd_sbuf != 0) {
 1255                 free(d->bd_sbuf, M_BPF);
 1256                 if (d->bd_hbuf != 0)
 1257                         free(d->bd_hbuf, M_BPF);
 1258                 if (d->bd_fbuf != 0)
 1259                         free(d->bd_fbuf, M_BPF);
 1260         }
 1261         if (d->bd_filter)
 1262                 free((caddr_t)d->bd_filter, M_BPF);
 1263         mtx_destroy(&d->bd_mtx);
 1264 }
 1265 
 1266 /*
 1267  * Attach an interface to bpf.  dlt is the link layer type; hdrlen is the
 1268  * fixed size of the link header (variable length headers not yet supported).
 1269  */
 1270 void
 1271 bpfattach(ifp, dlt, hdrlen)
 1272         struct ifnet *ifp;
 1273         u_int dlt, hdrlen;
 1274 {
 1275 
 1276         bpfattach2(ifp, dlt, hdrlen, &ifp->if_bpf);
 1277 }
 1278 
 1279 /*
 1280  * Attach an interface to bpf.  ifp is a pointer to the structure
 1281  * defining the interface to be attached, dlt is the link layer type,
 1282  * and hdrlen is the fixed size of the link header (variable length
 1283  * headers are not yet supporrted).
 1284  */
 1285 void
 1286 bpfattach2(ifp, dlt, hdrlen, driverp)
 1287         struct ifnet *ifp;
 1288         u_int dlt, hdrlen;
 1289         struct bpf_if **driverp;
 1290 {
 1291         struct bpf_if *bp;
 1292         bp = (struct bpf_if *)malloc(sizeof(*bp), M_BPF, M_NOWAIT | M_ZERO);
 1293         if (bp == 0)
 1294                 panic("bpfattach");
 1295 
 1296         bp->bif_dlist = 0;
 1297         bp->bif_driverp = driverp;
 1298         bp->bif_ifp = ifp;
 1299         bp->bif_dlt = dlt;
 1300         mtx_init(&bp->bif_mtx, "bpf interface lock", NULL, MTX_DEF);
 1301 
 1302         mtx_lock(&bpf_mtx);
 1303         bp->bif_next = bpf_iflist;
 1304         bpf_iflist = bp;
 1305         mtx_unlock(&bpf_mtx);
 1306 
 1307         *bp->bif_driverp = 0;
 1308 
 1309         /*
 1310          * Compute the length of the bpf header.  This is not necessarily
 1311          * equal to SIZEOF_BPF_HDR because we want to insert spacing such
 1312          * that the network layer header begins on a longword boundary (for
 1313          * performance reasons and to alleviate alignment restrictions).
 1314          */
 1315         bp->bif_hdrlen = BPF_WORDALIGN(hdrlen + SIZEOF_BPF_HDR) - hdrlen;
 1316 
 1317         if (bootverbose)
 1318                 if_printf(ifp, "bpf attached\n");
 1319 }
 1320 
 1321 /*
 1322  * Detach bpf from an interface.  This involves detaching each descriptor
 1323  * associated with the interface, and leaving bd_bif NULL.  Notify each
 1324  * descriptor as it's detached so that any sleepers wake up and get
 1325  * ENXIO.
 1326  */
 1327 void
 1328 bpfdetach(ifp)
 1329         struct ifnet *ifp;
 1330 {
 1331         struct bpf_if   *bp, *bp_prev;
 1332         struct bpf_d    *d;
 1333 
 1334         mtx_lock(&bpf_mtx);
 1335 
 1336         /* Locate BPF interface information */
 1337         bp_prev = NULL;
 1338         for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
 1339                 if (ifp == bp->bif_ifp)
 1340                         break;
 1341                 bp_prev = bp;
 1342         }
 1343 
 1344         /* Interface wasn't attached */
 1345         if (bp->bif_ifp == NULL) {
 1346                 mtx_unlock(&bpf_mtx);
 1347                 printf("bpfdetach: %s%d was not attached\n", ifp->if_name,
 1348                     ifp->if_unit);
 1349                 return;
 1350         }
 1351 
 1352         if (bp_prev) {
 1353                 bp_prev->bif_next = bp->bif_next;
 1354         } else {
 1355                 bpf_iflist = bp->bif_next;
 1356         }
 1357 
 1358         while ((d = bp->bif_dlist) != NULL) {
 1359                 bpf_detachd(d);
 1360                 BPFD_LOCK(d);
 1361                 bpf_wakeup(d);
 1362                 BPFD_UNLOCK(d);
 1363         }
 1364 
 1365         mtx_destroy(&bp->bif_mtx);
 1366         free(bp, M_BPF);
 1367 
 1368         mtx_unlock(&bpf_mtx);
 1369 }
 1370 
 1371 static void bpf_drvinit(void *unused);
 1372 
 1373 static void bpf_clone(void *arg, char *name, int namelen, dev_t *dev);
 1374 
 1375 static void
 1376 bpf_clone(arg, name, namelen, dev)
 1377         void *arg;
 1378         char *name;
 1379         int namelen;
 1380         dev_t *dev;
 1381 {
 1382         int u;
 1383 
 1384         if (*dev != NODEV)
 1385                 return;
 1386         if (dev_stdclone(name, NULL, "bpf", &u) != 1)
 1387                 return;
 1388         *dev = make_dev(&bpf_cdevsw, unit2minor(u), UID_ROOT, GID_WHEEL, 0600,
 1389             "bpf%d", u);
 1390         (*dev)->si_flags |= SI_CHEAPCLONE;
 1391         return;
 1392 }
 1393 
 1394 static void
 1395 bpf_drvinit(unused)
 1396         void *unused;
 1397 {
 1398 
 1399         mtx_init(&bpf_mtx, "bpf global lock", NULL, MTX_DEF);
 1400         EVENTHANDLER_REGISTER(dev_clone, bpf_clone, 0, 1000);
 1401         cdevsw_add(&bpf_cdevsw);
 1402 }
 1403 
 1404 SYSINIT(bpfdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bpf_drvinit,NULL)
 1405 
 1406 #else /* !DEV_BPF && !NETGRAPH_BPF */
 1407 /*
 1408  * NOP stubs to allow bpf-using drivers to load and function.
 1409  *
 1410  * A 'better' implementation would allow the core bpf functionality
 1411  * to be loaded at runtime.
 1412  */
 1413 
 1414 void
 1415 bpf_tap(bp, pkt, pktlen)
 1416         struct bpf_if *bp;
 1417         register u_char *pkt;
 1418         register u_int pktlen;
 1419 {
 1420 }
 1421 
 1422 void
 1423 bpf_mtap(bp, m)
 1424         struct bpf_if *bp;
 1425         struct mbuf *m;
 1426 {
 1427 }
 1428 
 1429 void
 1430 bpfattach(ifp, dlt, hdrlen)
 1431         struct ifnet *ifp;
 1432         u_int dlt, hdrlen;
 1433 {
 1434 }
 1435 
 1436 void
 1437 bpfdetach(ifp)
 1438         struct ifnet *ifp;
 1439 {
 1440 }
 1441 
 1442 u_int
 1443 bpf_filter(pc, p, wirelen, buflen)
 1444         register const struct bpf_insn *pc;
 1445         register u_char *p;
 1446         u_int wirelen;
 1447         register u_int buflen;
 1448 {
 1449         return -1;      /* "no filter" behaviour */
 1450 }
 1451 
 1452 int
 1453 bpf_validate(f, len)
 1454         const struct bpf_insn *f;
 1455         int len;
 1456 {
 1457         return 0;               /* false */
 1458 }
 1459 
 1460 #endif /* !DEV_BPF && !NETGRAPH_BPF */

Cache object: 574a90dc42415a9dfad22f455fa8da0b


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.