2 * Copyright (c) 1990, 1991, 1993
3 * The Regents of the University of California. All rights reserved.
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
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
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.
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
38 * @(#)bpf.c 8.2 (Berkeley) 3/28/94
40 * $Id: bpf.c,v 1.40 1998/07/29 05:34:59 kjc Exp $
50 #define inline __inline
53 #include <sys/param.h>
54 #include <sys/systm.h>
56 #include <sys/malloc.h>
60 #include <sys/signalvar.h>
61 #include <sys/filio.h>
62 #include <sys/sockio.h>
63 #include <sys/ttycom.h>
65 #if defined(sparc) && BSD < 199103
66 #include <sys/stream.h>
70 #include <sys/socket.h>
71 #include <sys/vnode.h>
75 #include <net/bpfdesc.h>
77 #include <netinet/in.h>
78 #include <netinet/if_ether.h>
79 #include <sys/kernel.h>
80 #include <sys/sysctl.h>
82 #include "opt_devfs.h"
85 #include <sys/devfsext.h>
90 * Older BSDs don't have kernel malloc.
94 static caddr_t bpf_alloc();
95 #include <net/bpf_compat.h>
96 #define BPF_BUFSIZE (MCLBYTES-8)
97 #define UIOMOVE(cp, len, code, uio) uiomove(cp, len, code, uio)
99 #define BPF_BUFSIZE 4096
100 #define UIOMOVE(cp, len, code, uio) uiomove(cp, len, uio)
103 #define PRINET 26 /* interruptible */
106 * The default read buffer size is patchable.
108 static int bpf_bufsize = BPF_BUFSIZE;
109 SYSCTL_INT(_debug, OID_AUTO, bpf_bufsize, CTLFLAG_RW,
110 &bpf_bufsize, 0, "");
113 * bpf_iflist is the list of interfaces; each corresponds to an ifnet
114 * bpf_dtab holds the descriptors, indexed by minor device #
116 static struct bpf_if *bpf_iflist;
117 static struct bpf_d bpf_dtab[NBPFILTER];
118 static int bpf_dtab_init;
120 static int bpf_allocbufs __P((struct bpf_d *));
121 static void bpf_attachd __P((struct bpf_d *d, struct bpf_if *bp));
122 static void bpf_detachd __P((struct bpf_d *d));
123 static void bpf_freed __P((struct bpf_d *));
124 static void bpf_ifname __P((struct ifnet *, struct ifreq *));
125 static void bpf_mcopy __P((const void *, void *, u_int));
126 static int bpf_movein __P((struct uio *, int,
127 struct mbuf **, struct sockaddr *, int *));
128 static int bpf_setif __P((struct bpf_d *, struct ifreq *));
130 bpf_wakeup __P((struct bpf_d *));
131 static void catchpacket __P((struct bpf_d *, u_char *, u_int,
132 u_int, void (*)(const void *, void *, u_int)));
133 static void reset_d __P((struct bpf_d *));
134 static int bpf_setf __P((struct bpf_d *, struct bpf_program *));
136 static d_open_t bpfopen;
137 static d_close_t bpfclose;
138 static d_read_t bpfread;
139 static d_write_t bpfwrite;
140 static d_ioctl_t bpfioctl;
141 static d_poll_t bpfpoll;
143 #define CDEV_MAJOR 23
144 static struct cdevsw bpf_cdevsw =
145 { bpfopen, bpfclose, bpfread, bpfwrite, /*23*/
146 bpfioctl, nostop, nullreset, nodevtotty,/* bpf */
147 bpfpoll, nommap, NULL, "bpf", NULL, -1 };
151 bpf_movein(uio, linktype, mp, sockp, datlen)
152 register struct uio *uio;
153 int linktype, *datlen;
154 register struct mbuf **mp;
155 register struct sockaddr *sockp;
163 * Build a sockaddr based on the data link layer type.
164 * We do this at this level because the ethernet header
165 * is copied directly into the data field of the sockaddr.
166 * In the case of SLIP, there is no header and the packet
167 * is forwarded as is.
168 * Also, we are careful to leave room at the front of the mbuf
169 * for the link level header.
174 sockp->sa_family = AF_INET;
179 sockp->sa_family = AF_UNSPEC;
180 /* XXX Would MAXLINKHDR be better? */
181 hlen = sizeof(struct ether_header);
185 #if defined(__FreeBSD__) || defined(__bsdi__)
186 sockp->sa_family = AF_IMPLINK;
189 sockp->sa_family = AF_UNSPEC;
190 /* XXX 4(FORMAC)+6(dst)+6(src)+3(LLC)+5(SNAP) */
197 sockp->sa_family = AF_UNSPEC;
202 case DLT_ATM_RFC1483:
204 * en atm driver requires 4-byte atm pseudo header.
205 * though it isn't standard, vpi:vci needs to be
208 sockp->sa_family = AF_UNSPEC;
209 hlen = 12; /* XXX 4(ATM_PH) + 3(LLC) + 5(SNAP) */
217 len = uio->uio_resid;
218 *datlen = len - hlen;
219 if ((unsigned)len > MCLBYTES)
222 MGETHDR(m, M_WAIT, MT_DATA);
228 if ((m->m_flags & M_EXT) == 0) {
231 if (m->m_len != MCLBYTES) {
237 m->m_pkthdr.len = m->m_len = len;
238 m->m_pkthdr.rcvif = NULL;
241 * Make room for link header.
244 m->m_pkthdr.len -= hlen;
247 m->m_data += hlen; /* XXX */
251 error = UIOMOVE((caddr_t)sockp->sa_data, hlen, UIO_WRITE, uio);
255 error = UIOMOVE(mtod(m, caddr_t), len - hlen, UIO_WRITE, uio);
264 * Attach file to the bpf interface, i.e. make d listen on bp.
265 * Must be called at splimp.
273 * Point d at bp, and add d to the interface's list of listeners.
274 * Finally, point the driver's bpf cookie at the interface so
275 * it will divert packets to bpf.
278 d->bd_next = bp->bif_dlist;
281 bp->bif_ifp->if_bpf = bp;
285 * Detach a file from its interface.
296 * Check if this descriptor had requested promiscuous mode.
297 * If so, turn it off.
301 if (ifpromisc(bp->bif_ifp, 0))
303 * Something is really wrong if we were able to put
304 * the driver into promiscuous mode, but can't
307 panic("bpf: ifpromisc failed");
309 /* Remove d from the interface's descriptor list. */
314 panic("bpf_detachd: descriptor not in list");
317 if (bp->bif_dlist == 0)
319 * Let the driver know that there are no more listeners.
321 d->bd_bif->bif_ifp->if_bpf = 0;
327 * Mark a descriptor free by making it point to itself.
328 * This is probably cheaper than marking with a constant since
329 * the address should be in a register anyway.
331 #define D_ISFREE(d) ((d) == (d)->bd_next)
332 #define D_MARKFREE(d) ((d)->bd_next = (d))
333 #define D_MARKUSED(d) ((d)->bd_next = 0)
336 * Open ethernet device. Returns ENXIO for illegal minor device number,
337 * EBUSY if file is open by another process.
341 bpfopen(dev, flags, fmt, p)
347 register struct bpf_d *d;
349 if (minor(dev) >= NBPFILTER)
352 * Each minor can be opened by only one process. If the requested
353 * minor is in use, return EBUSY.
355 d = &bpf_dtab[minor(dev)];
359 /* Mark "free" and do most initialization. */
360 bzero((char *)d, sizeof(*d));
361 d->bd_bufsize = bpf_bufsize;
368 * Close the descriptor by detaching it from its interface,
369 * deallocating its buffers, and marking it free.
373 bpfclose(dev, flags, fmt, p)
379 register struct bpf_d *d = &bpf_dtab[minor(dev)];
392 * Support for SunOS, which does not have tsleep.
399 struct bpf_d *d = (struct bpf_d *)arg;
404 #define BPF_SLEEP(chan, pri, s, t) bpf_sleep((struct bpf_d *)chan)
408 register struct bpf_d *d;
410 register int rto = d->bd_rtout;
415 timeout(bpf_timeout, (caddr_t)d, rto);
417 st = sleep((caddr_t)d, PRINET|PCATCH);
419 if (d->bd_timedout == 0)
420 untimeout(bpf_timeout, (caddr_t)d);
424 return (st != 0) ? EINTR : 0;
427 #define BPF_SLEEP tsleep
431 * Rotate the packet buffers in descriptor d. Move the store buffer
432 * into the hold slot, and the free buffer into the store slot.
433 * Zero the length of the new store buffer.
435 #define ROTATE_BUFFERS(d) \
436 (d)->bd_hbuf = (d)->bd_sbuf; \
437 (d)->bd_hlen = (d)->bd_slen; \
438 (d)->bd_sbuf = (d)->bd_fbuf; \
442 * bpfread - read next chunk of packets from buffers
445 bpfread(dev, uio, ioflag)
447 register struct uio *uio;
450 register struct bpf_d *d = &bpf_dtab[minor(dev)];
455 * Restrict application to use a buffer the same size as
458 if (uio->uio_resid != d->bd_bufsize)
463 * If the hold buffer is empty, then do a timed sleep, which
464 * ends when the timeout expires or when enough packets
465 * have arrived to fill the store buffer.
467 while (d->bd_hbuf == 0) {
468 if (d->bd_immediate && d->bd_slen != 0) {
470 * A packet(s) either arrived since the previous
471 * read or arrived while we were asleep.
472 * Rotate the buffers and return what's here.
477 if (ioflag & IO_NDELAY)
480 error = BPF_SLEEP((caddr_t)d, PRINET|PCATCH, "bpf",
482 if (error == EINTR || error == ERESTART) {
486 if (error == EWOULDBLOCK) {
488 * On a timeout, return what's in the buffer,
489 * which may be nothing. If there is something
490 * in the store buffer, we can rotate the buffers.
494 * We filled up the buffer in between
495 * getting the timeout and arriving
496 * here, so we don't need to rotate.
500 if (d->bd_slen == 0) {
509 * At this point, we know we have something in the hold slot.
514 * Move data from hold buffer into user space.
515 * We know the entire buffer is transferred since
516 * we checked above that the read buffer is bpf_bufsize bytes.
518 error = UIOMOVE(d->bd_hbuf, d->bd_hlen, UIO_READ, uio);
521 d->bd_fbuf = d->bd_hbuf;
531 * If there are processes sleeping on this descriptor, wake them up.
535 register struct bpf_d *d;
540 if (d->bd_async && d->bd_sig)
542 gsignal (d->bd_pgid, d->bd_sig);
543 else if (p = pfind (-d->bd_pgid))
544 psignal (p, d->bd_sig);
547 selwakeup(&d->bd_sel);
549 d->bd_sel.si_pid = 0;
552 selwakeup(d->bd_selproc, (int)d->bd_selcoll);
560 bpfwrite(dev, uio, ioflag)
565 register struct bpf_d *d = &bpf_dtab[minor(dev)];
569 static struct sockaddr dst;
575 ifp = d->bd_bif->bif_ifp;
577 if (uio->uio_resid == 0)
580 error = bpf_movein(uio, (int)d->bd_bif->bif_dlt, &m, &dst, &datlen);
584 if (datlen > ifp->if_mtu)
589 error = (*ifp->if_output)(ifp, m, &dst, (struct rtentry *)0);
591 error = (*ifp->if_output)(ifp, m, &dst);
595 * The driver frees the mbuf.
601 * Reset a descriptor by flushing its packet buffer and clearing the
602 * receive and drop counts. Should be called at splimp.
609 /* Free the hold buffer. */
610 d->bd_fbuf = d->bd_hbuf;
620 * FIONREAD Check for read packet available.
621 * SIOCGIFADDR Get interface address - convenient hook to driver.
622 * BIOCGBLEN Get buffer len [for read()].
623 * BIOCSETF Set ethernet read filter.
624 * BIOCFLUSH Flush read packet buffer.
625 * BIOCPROMISC Put interface into promiscuous mode.
626 * BIOCGDLT Get link layer type.
627 * BIOCGETIF Get interface name.
628 * BIOCSETIF Set interface.
629 * BIOCSRTIMEOUT Set read timeout.
630 * BIOCGRTIMEOUT Get read timeout.
631 * BIOCGSTATS Get packet stats.
632 * BIOCIMMEDIATE Set immediate mode.
633 * BIOCVERSION Get filter language version.
637 bpfioctl(dev, cmd, addr, flags, p)
644 register struct bpf_d *d = &bpf_dtab[minor(dev)];
654 * Check for read packet available.
677 ifp = d->bd_bif->bif_ifp;
678 error = (*ifp->if_ioctl)(ifp, cmd, addr);
684 * Get buffer len [for read()].
687 *(u_int *)addr = d->bd_bufsize;
700 register u_int size = *(u_int *)addr;
702 if (size > BPF_MAXBUFSIZE)
703 *(u_int *)addr = size = BPF_MAXBUFSIZE;
704 else if (size < BPF_MINBUFSIZE)
705 *(u_int *)addr = size = BPF_MINBUFSIZE;
706 d->bd_bufsize = size;
712 * Set link layer read filter.
715 error = bpf_setf(d, (struct bpf_program *)addr);
719 * Flush read packet buffer.
728 * Put interface into promiscuous mode.
731 if (d->bd_bif == 0) {
733 * No interface attached yet.
739 if (d->bd_promisc == 0) {
740 error = ifpromisc(d->bd_bif->bif_ifp, 1);
748 * Get device parameters.
754 *(u_int *)addr = d->bd_bif->bif_dlt;
758 * Set interface name.
764 bpf_ifname(d->bd_bif->bif_ifp, (struct ifreq *)addr);
771 error = bpf_setif(d, (struct ifreq *)addr);
779 struct timeval *tv = (struct timeval *)addr;
782 /* Compute number of milliseconds. */
783 msec = tv->tv_sec * 1000 + tv->tv_usec / 1000;
784 /* Scale milliseconds to ticks. Assume hard
785 clock has millisecond or greater resolution
786 (i.e. tick >= 1000). For 10ms hardclock,
787 tick/1000 = 10, so rtout<-msec/10. */
788 d->bd_rtout = msec / (tick / 1000);
797 struct timeval *tv = (struct timeval *)addr;
798 u_long msec = d->bd_rtout;
801 tv->tv_sec = msec / 1000;
802 tv->tv_usec = msec % 1000;
811 struct bpf_stat *bs = (struct bpf_stat *)addr;
813 bs->bs_recv = d->bd_rcount;
814 bs->bs_drop = d->bd_dcount;
819 * Set immediate mode.
822 d->bd_immediate = *(u_int *)addr;
827 struct bpf_version *bv = (struct bpf_version *)addr;
829 bv->bv_major = BPF_MAJOR_VERSION;
830 bv->bv_minor = BPF_MINOR_VERSION;
834 case FIONBIO: /* Non-blocking I/O */
837 case FIOASYNC: /* Send signal on receive packets */
838 d->bd_async = *(int *)addr;
841 /* N.B. ioctl (FIOSETOWN) and fcntl (F_SETOWN) both end up doing the
842 equivalent of a TIOCSPGRP and hence end up here. *However* TIOCSPGRP's arg
843 is a process group if it's positive and a process id if it's negative. This
844 is exactly the opposite of what the other two functions want! Therefore
845 there is code in ioctl and fcntl to negate the arg before calling here. */
847 case TIOCSPGRP: /* Process or group to send signals to */
848 d->bd_pgid = *(int *)addr;
852 *(int *)addr = d->bd_pgid;
855 case BIOCSRSIG: /* Set receive signal */
859 sig = *(u_int *)addr;
868 *(u_int *)addr = d->bd_sig;
875 * Set d's packet filter program to fp. If this file already has a filter,
876 * free it and replace it. Returns EINVAL for bogus requests.
881 struct bpf_program *fp;
883 struct bpf_insn *fcode, *old;
888 if (fp->bf_insns == 0) {
896 free((caddr_t)old, M_DEVBUF);
900 if (flen > BPF_MAXINSNS)
903 size = flen * sizeof(*fp->bf_insns);
904 fcode = (struct bpf_insn *)malloc(size, M_DEVBUF, M_WAITOK);
905 if (copyin((caddr_t)fp->bf_insns, (caddr_t)fcode, size) == 0 &&
906 bpf_validate(fcode, (int)flen)) {
908 d->bd_filter = fcode;
912 free((caddr_t)old, M_DEVBUF);
916 free((caddr_t)fcode, M_DEVBUF);
921 * Detach a file from its current interface (if attached at all) and attach
922 * to the interface indicated by the name stored in ifr.
923 * Return an errno or 0.
932 struct ifnet *theywant;
934 theywant = ifunit(ifr->ifr_name);
939 * Look through attached interfaces for the named one.
941 for (bp = bpf_iflist; bp != 0; bp = bp->bif_next) {
942 struct ifnet *ifp = bp->bif_ifp;
944 if (ifp == 0 || ifp != theywant)
947 * We found the requested interface.
948 * If it's not up, return an error.
949 * Allocate the packet buffers if we need to.
950 * If we're already attached to requested interface,
951 * just flush the buffer.
953 if ((ifp->if_flags & IFF_UP) == 0)
956 if (d->bd_sbuf == 0) {
957 error = bpf_allocbufs(d);
962 if (bp != d->bd_bif) {
965 * Detach if attached to something else.
980 * Convert an interface name plus unit number of an ifp to a single
981 * name which is returned in the ifr.
988 char *s = ifp->if_name;
989 char *d = ifr->ifr_name;
993 d--; /* back to the null */
994 /* XXX Assume that unit number is less than 10. */
995 *d++ = ifp->if_unit + '0';
1000 * Support for select() and poll() system calls
1002 * Return true iff the specific operation will not block indefinitely.
1003 * Otherwise, return false but make a note that a selwakeup() must be done.
1006 bpfpoll(dev, events, p)
1011 register struct bpf_d *d;
1016 * An imitation of the FIONREAD ioctl code.
1018 d = &bpf_dtab[minor(dev)];
1021 if (events & (POLLIN | POLLRDNORM))
1022 if (d->bd_hlen != 0 || (d->bd_immediate && d->bd_slen != 0))
1023 revents |= events & (POLLIN | POLLRDNORM);
1025 selrecord(p, &d->bd_sel);
1032 * Incoming linkage from device drivers. Process the packet pkt, of length
1033 * pktlen, which is stored in a contiguous buffer. The packet is parsed
1034 * by each process' filter, and if accepted, stashed into the corresponding
1038 bpf_tap(ifp, pkt, pktlen)
1040 register u_char *pkt;
1041 register u_int pktlen;
1044 register struct bpf_d *d;
1045 register u_int slen;
1047 * Note that the ipl does not have to be raised at this point.
1048 * The only problem that could arise here is that if two different
1049 * interfaces shared any data. This is not the case.
1052 for (d = bp->bif_dlist; d != 0; d = d->bd_next) {
1054 slen = bpf_filter(d->bd_filter, pkt, pktlen, pktlen);
1056 catchpacket(d, pkt, pktlen, slen, bcopy);
1061 * Copy data from an mbuf chain into a buffer. This code is derived
1062 * from m_copydata in sys/uipc_mbuf.c.
1065 bpf_mcopy(src_arg, dst_arg, len)
1066 const void *src_arg;
1070 register const struct mbuf *m;
1071 register u_int count;
1079 count = min(m->m_len, len);
1080 bcopy(mtod(m, void *), dst, count);
1088 * Incoming linkage from device drivers, when packet is in an mbuf chain.
1095 struct bpf_if *bp = ifp->if_bpf;
1101 for (m0 = m; m0 != 0; m0 = m0->m_next)
1102 pktlen += m0->m_len;
1104 for (d = bp->bif_dlist; d != 0; d = d->bd_next) {
1106 slen = bpf_filter(d->bd_filter, (u_char *)m, pktlen, 0);
1108 catchpacket(d, (u_char *)m, pktlen, slen, bpf_mcopy);
1113 * Move the packet data from interface memory (pkt) into the
1114 * store buffer. Return 1 if it's time to wakeup a listener (buffer full),
1115 * otherwise 0. "copy" is the routine called to do the actual data
1116 * transfer. bcopy is passed in to copy contiguous chunks, while
1117 * bpf_mcopy is passed in to copy mbuf chains. In the latter case,
1118 * pkt is really an mbuf.
1121 catchpacket(d, pkt, pktlen, snaplen, cpfn)
1122 register struct bpf_d *d;
1123 register u_char *pkt;
1124 register u_int pktlen, snaplen;
1125 register void (*cpfn) __P((const void *, void *, u_int));
1127 register struct bpf_hdr *hp;
1128 register int totlen, curlen;
1129 register int hdrlen = d->bd_bif->bif_hdrlen;
1131 * Figure out how many bytes to move. If the packet is
1132 * greater or equal to the snapshot length, transfer that
1133 * much. Otherwise, transfer the whole packet (unless
1134 * we hit the buffer size limit).
1136 totlen = hdrlen + min(snaplen, pktlen);
1137 if (totlen > d->bd_bufsize)
1138 totlen = d->bd_bufsize;
1141 * Round up the end of the previous packet to the next longword.
1143 curlen = BPF_WORDALIGN(d->bd_slen);
1144 if (curlen + totlen > d->bd_bufsize) {
1146 * This packet will overflow the storage buffer.
1147 * Rotate the buffers if we can, then wakeup any
1150 if (d->bd_fbuf == 0) {
1152 * We haven't completed the previous read yet,
1153 * so drop the packet.
1162 else if (d->bd_immediate)
1164 * Immediate mode is set. A packet arrived so any
1165 * reads should be woken up.
1170 * Append the bpf header.
1172 hp = (struct bpf_hdr *)(d->bd_sbuf + curlen);
1174 microtime(&hp->bh_tstamp);
1176 uniqtime(&hp->bh_tstamp);
1178 hp->bh_tstamp = time;
1180 hp->bh_datalen = pktlen;
1181 hp->bh_hdrlen = hdrlen;
1183 * Copy the packet data into the store buffer and update its length.
1185 (*cpfn)(pkt, (u_char *)hp + hdrlen, (hp->bh_caplen = totlen - hdrlen));
1186 d->bd_slen = curlen + totlen;
1190 * Initialize all nonzero fields of a descriptor.
1194 register struct bpf_d *d;
1196 d->bd_fbuf = (caddr_t)malloc(d->bd_bufsize, M_DEVBUF, M_WAITOK);
1197 if (d->bd_fbuf == 0)
1200 d->bd_sbuf = (caddr_t)malloc(d->bd_bufsize, M_DEVBUF, M_WAITOK);
1201 if (d->bd_sbuf == 0) {
1202 free(d->bd_fbuf, M_DEVBUF);
1211 * Free buffers currently in use by a descriptor.
1216 register struct bpf_d *d;
1219 * We don't need to lock out interrupts since this descriptor has
1220 * been detached from its interface and it yet hasn't been marked
1223 if (d->bd_sbuf != 0) {
1224 free(d->bd_sbuf, M_DEVBUF);
1225 if (d->bd_hbuf != 0)
1226 free(d->bd_hbuf, M_DEVBUF);
1227 if (d->bd_fbuf != 0)
1228 free(d->bd_fbuf, M_DEVBUF);
1231 free((caddr_t)d->bd_filter, M_DEVBUF);
1237 * Attach an interface to bpf. driverp is a pointer to a (struct bpf_if *)
1238 * in the driver's softc; dlt is the link layer type; hdrlen is the fixed
1239 * size of the link header (variable length headers not yet supported).
1242 bpfattach(ifp, dlt, hdrlen)
1248 bp = (struct bpf_if *)malloc(sizeof(*bp), M_DEVBUF, M_DONTWAIT);
1256 bp->bif_next = bpf_iflist;
1259 bp->bif_ifp->if_bpf = 0;
1262 * Compute the length of the bpf header. This is not necessarily
1263 * equal to SIZEOF_BPF_HDR because we want to insert spacing such
1264 * that the network layer header begins on a longword boundary (for
1265 * performance reasons and to alleviate alignment restrictions).
1267 bp->bif_hdrlen = BPF_WORDALIGN(hdrlen + SIZEOF_BPF_HDR) - hdrlen;
1270 * Mark all the descriptors free if this hasn't been done.
1272 if (!bpf_dtab_init) {
1273 for (i = 0; i < NBPFILTER; ++i)
1274 D_MARKFREE(&bpf_dtab[i]);
1279 printf("bpf: %s%d attached\n", ifp->if_name, ifp->if_unit);
1283 static void *bpf_devfs_token[NBPFILTER];
1286 static int bpf_devsw_installed;
1288 static void bpf_drvinit __P((void *unused));
1298 if( ! bpf_devsw_installed ) {
1299 dev = makedev(CDEV_MAJOR, 0);
1300 cdevsw_add(&dev,&bpf_cdevsw, NULL);
1301 bpf_devsw_installed = 1;
1304 for ( i = 0 ; i < NBPFILTER ; i++ ) {
1305 bpf_devfs_token[i] =
1306 devfs_add_devswf(&bpf_cdevsw, i, DV_CHR, 0, 0,
1313 SYSINIT(bpfdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bpf_drvinit,NULL)