sys/net/bpf.c

   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. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  *      @(#)bpf.c       8.2 (Berkeley) 3/28/94
  35  *
  36  * $FreeBSD: src/sys/net/bpf.c,v 1.59.2.12 2002/04/14 21:41:48 luigi Exp $
  37  */
  38
  39 #include "use_bpf.h"
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/conf.h>
  44 #include <sys/device.h>
  45 #include <sys/malloc.h>
  46 #include <sys/mbuf.h>
  47 #include <sys/time.h>
  48 #include <sys/proc.h>
  49 #include <sys/signalvar.h>
  50 #include <sys/filio.h>
  51 #include <sys/sockio.h>
  52 #include <sys/ttycom.h>
  53 #include <sys/filedesc.h>
  54
  55 #include <sys/event.h>
  56
  57 #include <sys/socket.h>
  58 #include <sys/vnode.h>
  59
  60 #include <sys/thread2.h>
  61
  62 #include <net/if.h>
  63 #include <net/bpf.h>
  64 #include <net/bpfdesc.h>
  65 #include <net/netmsg2.h>
  66 #include <net/netisr2.h>
  67
  68 #include <netinet/in.h>
  69 #include <netinet/if_ether.h>
  70 #include <sys/kernel.h>
  71 #include <sys/sysctl.h>
  72
  73 #include <netproto/802_11/ieee80211_dragonfly.h>
  74
  75 #include <sys/devfs.h>
  76
  77 struct netmsg_bpf_output {
  78         struct netmsg_base base;
  79         struct mbuf     *nm_mbuf;
  80         struct ifnet    *nm_ifp;
  81         struct sockaddr *nm_dst;
  82 };
  83
  84 MALLOC_DEFINE(M_BPF, "BPF", "BPF data");
  85 DEVFS_DEFINE_CLONE_BITMAP(bpf);
  86
  87 #if NBPF <= 1
  88 #define BPF_PREALLOCATED_UNITS  4
  89 #else
  90 #define BPF_PREALLOCATED_UNITS  NBPF
  91 #endif
  92
  93 #if NBPF > 0
  94
  95 /*
  96  * The default read buffer size is patchable.
  97  */
  98 static int bpf_bufsize = BPF_DEFAULTBUFSIZE;
  99 SYSCTL_INT(_debug, OID_AUTO, bpf_bufsize, CTLFLAG_RW,
 100    &bpf_bufsize, 0, "Current size of bpf buffer");
 101 int bpf_maxbufsize = BPF_MAXBUFSIZE;
 102 SYSCTL_INT(_debug, OID_AUTO, bpf_maxbufsize, CTLFLAG_RW,
 103    &bpf_maxbufsize, 0, "Maximum size of bpf buffer");
 104
 105 /*
 106  *  bpf_iflist is the list of interfaces; each corresponds to an ifnet
 107  */
 108 static struct bpf_if    *bpf_iflist;
 109
 110 static struct lwkt_token bpf_token = LWKT_TOKEN_INITIALIZER(bpf_token);
 111
 112 static int      bpf_allocbufs(struct bpf_d *);
 113 static void     bpf_attachd(struct bpf_d *d, struct bpf_if *bp);
 114 static void     bpf_detachd(struct bpf_d *d);
 115 static void     bpf_resetd(struct bpf_d *);
 116 static void     bpf_freed(struct bpf_d *);
 117 static void     bpf_mcopy(volatile const void *, volatile void *, size_t);
 118 static int      bpf_movein(struct uio *, int, struct mbuf **,
 119                            struct sockaddr *, int *, struct bpf_insn *);
 120 static int      bpf_setif(struct bpf_d *, struct ifreq *);
 121 static void     bpf_timed_out(void *);
 122 static void     bpf_wakeup(struct bpf_d *);
 123 static void     catchpacket(struct bpf_d *, u_char *, u_int, u_int,
 124                             void (*)(volatile const void *,
 125                                      volatile void *, size_t),
 126                             const struct timeval *);
 127 static int      bpf_setf(struct bpf_d *, struct bpf_program *, u_long cmd);
 128 static int      bpf_getdltlist(struct bpf_d *, struct bpf_dltlist *);
 129 static int      bpf_setdlt(struct bpf_d *, u_int);
 130 static void     bpf_drvinit(void *unused);
 131 static void     bpf_filter_detach(struct knote *kn);
 132 static int      bpf_filter_read(struct knote *kn, long hint);
 133
 134 static d_open_t         bpfopen;
 135 static d_clone_t        bpfclone;
 136 static d_close_t        bpfclose;
 137 static d_read_t         bpfread;
 138 static d_write_t        bpfwrite;
 139 static d_ioctl_t        bpfioctl;
 140 static d_kqfilter_t     bpfkqfilter;
 141
 142 #define CDEV_MAJOR 23
 143 static struct dev_ops bpf_ops = {
 144         { "bpf", 0, D_MPSAFE },
 145         .d_open =       bpfopen,
 146         .d_close =      bpfclose,
 147         .d_read =       bpfread,
 148         .d_write =      bpfwrite,
 149         .d_ioctl =      bpfioctl,
 150         .d_kqfilter =   bpfkqfilter
 151 };
 152
 153
 154 static int
 155 bpf_movein(struct uio *uio, int linktype, struct mbuf **mp,
 156            struct sockaddr *sockp, int *datlen, struct bpf_insn *wfilter)
 157 {
 158         const struct ieee80211_bpf_params *p;
 159         struct mbuf *m;
 160         int error;
 161         int len;
 162         int hlen;
 163         int slen;
 164
 165         *datlen = 0;
 166         *mp = NULL;
 167
 168         /*
 169          * Build a sockaddr based on the data link layer type.
 170          * We do this at this level because the ethernet header
 171          * is copied directly into the data field of the sockaddr.
 172          * In the case of SLIP, there is no header and the packet
 173          * is forwarded as is.
 174          * Also, we are careful to leave room at the front of the mbuf
 175          * for the link level header.
 176          */
 177         switch (linktype) {
 178         case DLT_SLIP:
 179                 sockp->sa_family = AF_INET;
 180                 hlen = 0;
 181                 break;
 182
 183         case DLT_EN10MB:
 184                 sockp->sa_family = AF_UNSPEC;
 185                 /* XXX Would MAXLINKHDR be better? */
 186                 hlen = sizeof(struct ether_header);
 187                 break;
 188
 189         case DLT_RAW:
 190         case DLT_NULL:
 191                 sockp->sa_family = AF_UNSPEC;
 192                 hlen = 0;
 193                 break;
 194
 195         case DLT_ATM_RFC1483:
 196                 /*
 197                  * en atm driver requires 4-byte atm pseudo header.
 198                  * though it isn't standard, vpi:vci needs to be
 199                  * specified anyway.
 200                  */
 201                 sockp->sa_family = AF_UNSPEC;
 202                 hlen = 12;      /* XXX 4(ATM_PH) + 3(LLC) + 5(SNAP) */
 203                 break;
 204
 205         case DLT_PPP:
 206                 sockp->sa_family = AF_UNSPEC;
 207                 hlen = 4;       /* This should match PPP_HDRLEN */
 208                 break;
 209
 210         case DLT_IEEE802_11:            /* IEEE 802.11 wireless */
 211                 sockp->sa_family = AF_IEEE80211;
 212                 hlen = 0;
 213                 break;
 214
 215         case DLT_IEEE802_11_RADIO:      /* IEEE 802.11 wireless w/ phy params */
 216                 sockp->sa_family = AF_IEEE80211;
 217                 sockp->sa_len = 12;     /* XXX != 0 */
 218                 hlen = sizeof(struct ieee80211_bpf_params);
 219                 break;
 220
 221         default:
 222                 return(EIO);
 223         }
 224
 225         len = uio->uio_resid;
 226         *datlen = len - hlen;
 227         if ((unsigned)len > MCLBYTES)
 228                 return(EIO);
 229
 230         m = m_getl(len, M_WAITOK, MT_DATA, M_PKTHDR, NULL);
 231         if (m == NULL)
 232                 return(ENOBUFS);
 233         m->m_pkthdr.len = m->m_len = len;
 234         m->m_pkthdr.rcvif = NULL;
 235         *mp = m;
 236
 237         if (m->m_len < hlen) {
 238                 error = EPERM;
 239                 goto bad;
 240         }
 241
 242         error = uiomove(mtod(m, u_char *), len, uio);
 243         if (error)
 244                 goto bad;
 245
 246         slen = bpf_filter(wfilter, mtod(m, u_char *), len, len);
 247         if (slen == 0) {
 248                 error = EPERM;
 249                 goto bad;
 250         }
 251
 252         /*
 253          * Make room for link header, and copy it to sockaddr.
 254          */
 255         if (hlen != 0) {
 256                 if (sockp->sa_family == AF_IEEE80211) {
 257                         /*
 258                          * Collect true length from the parameter header
 259                          * NB: sockp is known to be zero'd so if we do a
 260                          *     short copy unspecified parameters will be
 261                          *     zero.
 262                          * NB: packet may not be aligned after stripping
 263                          *     bpf params
 264                          * XXX check ibp_vers
 265                          */
 266                         p = mtod(m, const struct ieee80211_bpf_params *);
 267                         hlen = p->ibp_len;
 268                         if (hlen > sizeof(sockp->sa_data)) {
 269                                 error = EINVAL;
 270                                 goto bad;
 271                         }
 272                 }
 273                 bcopy(m->m_data, sockp->sa_data, hlen);
 274                 m->m_pkthdr.len -= hlen;
 275                 m->m_len -= hlen;
 276                 m->m_data += hlen; /* XXX */
 277         }
 278         return (0);
 279 bad:
 280         m_freem(m);
 281         return(error);
 282 }
 283
 284 /*
 285  * Attach file to the bpf interface, i.e. make d listen on bp.
 286  * Must be called at splimp.
 287  */
 288 static void
 289 bpf_attachd(struct bpf_d *d, struct bpf_if *bp)
 290 {
 291         /*
 292          * Point d at bp, and add d to the interface's list of listeners.
 293          * Finally, point the driver's bpf cookie at the interface so
 294          * it will divert packets to bpf.
 295          */
 296         lwkt_gettoken(&bpf_token);
 297         d->bd_bif = bp;
 298         SLIST_INSERT_HEAD(&bp->bif_dlist, d, bd_next);
 299         *bp->bif_driverp = bp;
 300
 301         EVENTHANDLER_INVOKE(bpf_track, bp->bif_ifp, bp->bif_dlt, 1);
 302         lwkt_reltoken(&bpf_token);
 303 }
 304
 305 /*
 306  * Detach a file from its interface.
 307  */
 308 static void
 309 bpf_detachd(struct bpf_d *d)
 310 {
 311         int error;
 312         struct bpf_if *bp;
 313         struct ifnet *ifp;
 314
 315         lwkt_gettoken(&bpf_token);
 316         bp = d->bd_bif;
 317         ifp = bp->bif_ifp;
 318
 319         /* Remove d from the interface's descriptor list. */
 320         SLIST_REMOVE(&bp->bif_dlist, d, bpf_d, bd_next);
 321
 322         if (SLIST_EMPTY(&bp->bif_dlist)) {
 323                 /*
 324                  * Let the driver know that there are no more listeners.
 325                  */
 326                 *bp->bif_driverp = NULL;
 327         }
 328         d->bd_bif = NULL;
 329
 330         EVENTHANDLER_INVOKE(bpf_track, ifp, bp->bif_dlt, 0);
 331
 332         /*
 333          * Check if this descriptor had requested promiscuous mode.
 334          * If so, turn it off.
 335          */
 336         if (d->bd_promisc) {
 337                 d->bd_promisc = 0;
 338                 error = ifpromisc(ifp, 0);
 339                 if (error != 0 && error != ENXIO) {
 340                         /*
 341                          * ENXIO can happen if a pccard is unplugged,
 342                          * Something is really wrong if we were able to put
 343                          * the driver into promiscuous mode, but can't
 344                          * take it out.
 345                          */
 346                         if_printf(ifp, "bpf_detach: ifpromisc failed(%d)\n",
 347                                   error);
 348                 }
 349         }
 350         lwkt_reltoken(&bpf_token);
 351 }
 352
 353 /*
 354  * Open ethernet device.  Returns ENXIO for illegal minor device number,
 355  * EBUSY if file is open by another process.
 356  */
 357 /* ARGSUSED */
 358 static int
 359 bpfopen(struct dev_open_args *ap)
 360 {
 361         cdev_t dev = ap->a_head.a_dev;
 362         struct bpf_d *d;
 363
 364         lwkt_gettoken(&bpf_token);
 365         if (ap->a_cred->cr_prison) {
 366                 lwkt_reltoken(&bpf_token);
 367                 return(EPERM);
 368         }
 369
 370         d = dev->si_drv1;
 371         /*
 372          * Each minor can be opened by only one process.  If the requested
 373          * minor is in use, return EBUSY.
 374          */
 375         if (d != NULL) {
 376                 lwkt_reltoken(&bpf_token);
 377                 return(EBUSY);
 378         }
 379
 380         d = kmalloc(sizeof *d, M_BPF, M_WAITOK | M_ZERO);
 381         dev->si_drv1 = d;
 382         d->bd_bufsize = bpf_bufsize;
 383         d->bd_sig = SIGIO;
 384         d->bd_seesent = 1;
 385         callout_init(&d->bd_callout);
 386         lwkt_reltoken(&bpf_token);
 387
 388         return(0);
 389 }
 390
 391 static int
 392 bpfclone(struct dev_clone_args *ap)
 393 {
 394         int unit;
 395
 396         unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(bpf), 0);
 397         ap->a_dev = make_only_dev(&bpf_ops, unit, 0, 0, 0600, "bpf%d", unit);
 398
 399         return 0;
 400 }
 401
 402 /*
 403  * Close the descriptor by detaching it from its interface,
 404  * deallocating its buffers, and marking it free.
 405  */
 406 /* ARGSUSED */
 407 static int
 408 bpfclose(struct dev_close_args *ap)
 409 {
 410         cdev_t dev = ap->a_head.a_dev;
 411         struct bpf_d *d = dev->si_drv1;
 412
 413         lwkt_gettoken(&bpf_token);
 414         funsetown(&d->bd_sigio);
 415         if (d->bd_state == BPF_WAITING)
 416                 callout_stop(&d->bd_callout);
 417         d->bd_state = BPF_IDLE;
 418         if (d->bd_bif != NULL)
 419                 bpf_detachd(d);
 420         bpf_freed(d);
 421         dev->si_drv1 = NULL;
 422         if (dev->si_uminor >= BPF_PREALLOCATED_UNITS) {
 423                 devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(bpf), dev->si_uminor);
 424                 destroy_dev(dev);
 425         }
 426         kfree(d, M_BPF);
 427         lwkt_reltoken(&bpf_token);
 428
 429         return(0);
 430 }
 431
 432 /*
 433  * Rotate the packet buffers in descriptor d.  Move the store buffer
 434  * into the hold slot, and the free buffer into the store slot.
 435  * Zero the length of the new store buffer.
 436  */
 437 #define ROTATE_BUFFERS(d) \
 438         (d)->bd_hbuf = (d)->bd_sbuf; \
 439         (d)->bd_hlen = (d)->bd_slen; \
 440         (d)->bd_sbuf = (d)->bd_fbuf; \
 441         (d)->bd_slen = 0; \
 442         (d)->bd_fbuf = NULL;
 443 /*
 444  *  bpfread - read next chunk of packets from buffers
 445  */
 446 static int
 447 bpfread(struct dev_read_args *ap)
 448 {
 449         cdev_t dev = ap->a_head.a_dev;
 450         struct bpf_d *d = dev->si_drv1;
 451         int timed_out;
 452         int error;
 453
 454         lwkt_gettoken(&bpf_token);
 455         /*
 456          * Restrict application to use a buffer the same size as
 457          * as kernel buffers.
 458          */
 459         if (ap->a_uio->uio_resid != d->bd_bufsize) {
 460                 lwkt_reltoken(&bpf_token);
 461                 return(EINVAL);
 462         }
 463
 464         if (d->bd_state == BPF_WAITING)
 465                 callout_stop(&d->bd_callout);
 466         timed_out = (d->bd_state == BPF_TIMED_OUT);
 467         d->bd_state = BPF_IDLE;
 468         /*
 469          * If the hold buffer is empty, then do a timed sleep, which
 470          * ends when the timeout expires or when enough packets
 471          * have arrived to fill the store buffer.
 472          */
 473         while (d->bd_hbuf == NULL) {
 474                 if ((d->bd_immediate || (ap->a_ioflag & IO_NDELAY) || timed_out)
 475                     && d->bd_slen != 0) {
 476                         /*
 477                          * A packet(s) either arrived since the previous,
 478                          * We're in immediate mode, or are reading
 479                          * in non-blocking mode, and a packet(s)
 480                          * either arrived since the previous
 481                          * read or arrived while we were asleep.
 482                          * Rotate the buffers and return what's here.
 483                          */
 484                         ROTATE_BUFFERS(d);
 485                         break;
 486                 }
 487
 488                 /*
 489                  * No data is available, check to see if the bpf device
 490                  * is still pointed at a real interface.  If not, return
 491                  * ENXIO so that the userland process knows to rebind
 492                  * it before using it again.
 493                  */
 494                 if (d->bd_bif == NULL) {
 495                         lwkt_reltoken(&bpf_token);
 496                         return(ENXIO);
 497                 }
 498
 499                 if (ap->a_ioflag & IO_NDELAY) {
 500                         lwkt_reltoken(&bpf_token);
 501                         return(EWOULDBLOCK);
 502                 }
 503                 error = tsleep(d, PCATCH, "bpf", d->bd_rtout);
 504                 if (error == EINTR || error == ERESTART) {
 505                         lwkt_reltoken(&bpf_token);
 506                         return(error);
 507                 }
 508                 if (error == EWOULDBLOCK) {
 509                         /*
 510                          * On a timeout, return what's in the buffer,
 511                          * which may be nothing.  If there is something
 512                          * in the store buffer, we can rotate the buffers.
 513                          */
 514                         if (d->bd_hbuf)
 515                                 /*
 516                                  * We filled up the buffer in between
 517                                  * getting the timeout and arriving
 518                                  * here, so we don't need to rotate.
 519                                  */
 520                                 break;
 521
 522                         if (d->bd_slen == 0) {
 523                                 lwkt_reltoken(&bpf_token);
 524                                 return(0);
 525                         }
 526                         ROTATE_BUFFERS(d);
 527                         break;
 528                 }
 529         }
 530         /*
 531          * At this point, we know we have something in the hold slot.
 532          */
 533
 534         /*
 535          * Move data from hold buffer into user space.
 536          * We know the entire buffer is transferred since
 537          * we checked above that the read buffer is bpf_bufsize bytes.
 538          */
 539         error = uiomove(d->bd_hbuf, d->bd_hlen, ap->a_uio);
 540
 541         d->bd_fbuf = d->bd_hbuf;
 542         d->bd_hbuf = NULL;
 543         d->bd_hlen = 0;
 544         lwkt_reltoken(&bpf_token);
 545
 546         return(error);
 547 }
 548
 549
 550 /*
 551  * If there are processes sleeping on this descriptor, wake them up.
 552  */
 553 static void
 554 bpf_wakeup(struct bpf_d *d)
 555 {
 556         if (d->bd_state == BPF_WAITING) {
 557                 callout_stop(&d->bd_callout);
 558                 d->bd_state = BPF_IDLE;
 559         }
 560         wakeup(d);
 561         if (d->bd_async && d->bd_sig && d->bd_sigio)
 562                 pgsigio(d->bd_sigio, d->bd_sig, 0);
 563
 564         KNOTE(&d->bd_kq.ki_note, 0);
 565 }
 566
 567 static void
 568 bpf_timed_out(void *arg)
 569 {
 570         struct bpf_d *d = (struct bpf_d *)arg;
 571
 572         if (d->bd_state == BPF_WAITING) {
 573                 d->bd_state = BPF_TIMED_OUT;
 574                 if (d->bd_slen != 0)
 575                         bpf_wakeup(d);
 576         }
 577 }
 578
 579 static void
 580 bpf_output_dispatch(netmsg_t msg)
 581 {
 582         struct netmsg_bpf_output *bmsg = (struct netmsg_bpf_output *)msg;
 583         struct ifnet *ifp = bmsg->nm_ifp;
 584         int error;
 585
 586         /*
 587          * The driver frees the mbuf.
 588          */
 589         error = ifp->if_output(ifp, bmsg->nm_mbuf, bmsg->nm_dst, NULL);
 590         lwkt_replymsg(&msg->lmsg, error);
 591 }
 592
 593 static int
 594 bpfwrite(struct dev_write_args *ap)
 595 {
 596         cdev_t dev = ap->a_head.a_dev;
 597         struct bpf_d *d = dev->si_drv1;
 598         struct ifnet *ifp;
 599         struct mbuf *m;
 600         int error, ret;
 601         struct sockaddr dst;
 602         int datlen;
 603         struct netmsg_bpf_output bmsg;
 604
 605         lwkt_gettoken(&bpf_token);
 606         if (d->bd_bif == NULL) {
 607                 lwkt_reltoken(&bpf_token);
 608                 return(ENXIO);
 609         }
 610
 611         ifp = d->bd_bif->bif_ifp;
 612
 613         if (ap->a_uio->uio_resid == 0) {
 614                 lwkt_reltoken(&bpf_token);
 615                 return(0);
 616         }
 617
 618         error = bpf_movein(ap->a_uio, (int)d->bd_bif->bif_dlt, &m,
 619                            &dst, &datlen, d->bd_wfilter);
 620         if (error) {
 621                 lwkt_reltoken(&bpf_token);
 622                 return(error);
 623         }
 624
 625         if (datlen > ifp->if_mtu) {
 626                 m_freem(m);
 627                 lwkt_reltoken(&bpf_token);
 628                 return(EMSGSIZE);
 629         }
 630
 631         if (d->bd_hdrcmplt)
 632                 dst.sa_family = pseudo_AF_HDRCMPLT;
 633
 634         netmsg_init(&bmsg.base, NULL, &curthread->td_msgport,
 635                     0, bpf_output_dispatch);
 636         bmsg.nm_mbuf = m;
 637         bmsg.nm_ifp = ifp;
 638         bmsg.nm_dst = &dst;
 639
 640         ret = lwkt_domsg(netisr_cpuport(0), &bmsg.base.lmsg, 0);
 641         lwkt_reltoken(&bpf_token);
 642
 643         return ret;
 644 }
 645
 646 /*
 647  * Reset a descriptor by flushing its packet buffer and clearing the
 648  * receive and drop counts.  Should be called at splimp.
 649  */
 650 static void
 651 bpf_resetd(struct bpf_d *d)
 652 {
 653         if (d->bd_hbuf) {
 654                 /* Free the hold buffer. */
 655                 d->bd_fbuf = d->bd_hbuf;
 656                 d->bd_hbuf = NULL;
 657         }
 658         d->bd_slen = 0;
 659         d->bd_hlen = 0;
 660         d->bd_rcount = 0;
 661         d->bd_dcount = 0;
 662 }
 663
 664 /*
 665  *  FIONREAD            Check for read packet available.
 666  *  SIOCGIFADDR         Get interface address - convenient hook to driver.
 667  *  BIOCGBLEN           Get buffer len [for read()].
 668  *  BIOCSETF            Set ethernet read filter.
 669  *  BIOCSETWF           Set ethernet write filter.
 670  *  BIOCFLUSH           Flush read packet buffer.
 671  *  BIOCPROMISC         Put interface into promiscuous mode.
 672  *  BIOCGDLT            Get link layer type.
 673  *  BIOCGETIF           Get interface name.
 674  *  BIOCSETIF           Set interface.
 675  *  BIOCSRTIMEOUT       Set read timeout.
 676  *  BIOCGRTIMEOUT       Get read timeout.
 677  *  BIOCGSTATS          Get packet stats.
 678  *  BIOCIMMEDIATE       Set immediate mode.
 679  *  BIOCVERSION         Get filter language version.
 680  *  BIOCGHDRCMPLT       Get "header already complete" flag
 681  *  BIOCSHDRCMPLT       Set "header already complete" flag
 682  *  BIOCGSEESENT        Get "see packets sent" flag
 683  *  BIOCSSEESENT        Set "see packets sent" flag
 684  *  BIOCLOCK            Set "locked" flag
 685  */
 686 /* ARGSUSED */
 687 static int
 688 bpfioctl(struct dev_ioctl_args *ap)
 689 {
 690         cdev_t dev = ap->a_head.a_dev;
 691         struct bpf_d *d = dev->si_drv1;
 692         int error = 0;
 693
 694         lwkt_gettoken(&bpf_token);
 695         if (d->bd_state == BPF_WAITING)
 696                 callout_stop(&d->bd_callout);
 697         d->bd_state = BPF_IDLE;
 698
 699         if (d->bd_locked == 1) {
 700                 switch (ap->a_cmd) {
 701                 case BIOCGBLEN:
 702                 case BIOCFLUSH:
 703                 case BIOCGDLT:
 704                 case BIOCGDLTLIST:
 705                 case BIOCGETIF:
 706                 case BIOCGRTIMEOUT:
 707                 case BIOCGSTATS:
 708                 case BIOCVERSION:
 709                 case BIOCGRSIG:
 710                 case BIOCGHDRCMPLT:
 711                 case FIONREAD:
 712                 case BIOCLOCK:
 713                 case BIOCSRTIMEOUT:
 714                 case BIOCIMMEDIATE:
 715                 case TIOCGPGRP:
 716                         break;
 717                 default:
 718                         lwkt_reltoken(&bpf_token);
 719                         return (EPERM);
 720                 }
 721         }
 722         switch (ap->a_cmd) {
 723         default:
 724                 error = EINVAL;
 725                 break;
 726
 727         /*
 728          * Check for read packet available.
 729          */
 730         case FIONREAD:
 731                 {
 732                         int n;
 733
 734                         n = d->bd_slen;
 735                         if (d->bd_hbuf)
 736                                 n += d->bd_hlen;
 737
 738                         *(int *)ap->a_data = n;
 739                         break;
 740                 }
 741
 742         case SIOCGIFADDR:
 743                 {
 744                         struct ifnet *ifp;
 745
 746                         if (d->bd_bif == NULL) {
 747                                 error = EINVAL;
 748                         } else {
 749                                 ifp = d->bd_bif->bif_ifp;
 750                                 ifnet_serialize_all(ifp);
 751                                 error = ifp->if_ioctl(ifp, ap->a_cmd,
 752                                                       ap->a_data, ap->a_cred);
 753                                 ifnet_deserialize_all(ifp);
 754                         }
 755                         break;
 756                 }
 757
 758         /*
 759          * Get buffer len [for read()].
 760          */
 761         case BIOCGBLEN:
 762                 *(u_int *)ap->a_data = d->bd_bufsize;
 763                 break;
 764
 765         /*
 766          * Set buffer length.
 767          */
 768         case BIOCSBLEN:
 769                 if (d->bd_bif != NULL) {
 770                         error = EINVAL;
 771                 } else {
 772                         u_int size = *(u_int *)ap->a_data;
 773
 774                         if (size > bpf_maxbufsize)
 775                                 *(u_int *)ap->a_data = size = bpf_maxbufsize;
 776                         else if (size < BPF_MINBUFSIZE)
 777                                 *(u_int *)ap->a_data = size = BPF_MINBUFSIZE;
 778                         d->bd_bufsize = size;
 779                 }
 780                 break;
 781
 782         /*
 783          * Set link layer read filter.
 784          */
 785         case BIOCSETF:
 786         case BIOCSETWF:
 787                 error = bpf_setf(d, (struct bpf_program *)ap->a_data,
 788                         ap->a_cmd);
 789                 break;
 790
 791         /*
 792          * Flush read packet buffer.
 793          */
 794         case BIOCFLUSH:
 795                 bpf_resetd(d);
 796                 break;
 797
 798         /*
 799          * Put interface into promiscuous mode.
 800          */
 801         case BIOCPROMISC:
 802                 if (d->bd_bif == NULL) {
 803                         /*
 804                          * No interface attached yet.
 805                          */
 806                         error = EINVAL;
 807                         break;
 808                 }
 809                 if (d->bd_promisc == 0) {
 810                         error = ifpromisc(d->bd_bif->bif_ifp, 1);
 811                         if (error == 0)
 812                                 d->bd_promisc = 1;
 813                 }
 814                 break;
 815
 816         /*
 817          * Get device parameters.
 818          */
 819         case BIOCGDLT:
 820                 if (d->bd_bif == NULL)
 821                         error = EINVAL;
 822                 else
 823                         *(u_int *)ap->a_data = d->bd_bif->bif_dlt;
 824                 break;
 825
 826         /*
 827          * Get a list of supported data link types.
 828          */
 829         case BIOCGDLTLIST:
 830                 if (d->bd_bif == NULL) {
 831                         error = EINVAL;
 832                 } else {
 833                         error = bpf_getdltlist(d,
 834                                 (struct bpf_dltlist *)ap->a_data);
 835                 }
 836                 break;
 837
 838         /*
 839          * Set data link type.
 840          */
 841         case BIOCSDLT:
 842                 if (d->bd_bif == NULL)
 843                         error = EINVAL;
 844                 else
 845                         error = bpf_setdlt(d, *(u_int *)ap->a_data);
 846                 break;
 847
 848         /*
 849          * Get interface name.
 850          */
 851         case BIOCGETIF:
 852                 if (d->bd_bif == NULL) {
 853                         error = EINVAL;
 854                 } else {
 855                         struct ifnet *const ifp = d->bd_bif->bif_ifp;
 856                         struct ifreq *const ifr = (struct ifreq *)ap->a_data;
 857
 858                         strlcpy(ifr->ifr_name, ifp->if_xname,
 859                                 sizeof ifr->ifr_name);
 860                 }
 861                 break;
 862
 863         /*
 864          * Set interface.
 865          */
 866         case BIOCSETIF:
 867                 error = bpf_setif(d, (struct ifreq *)ap->a_data);
 868                 break;
 869
 870         /*
 871          * Set read timeout.
 872          */
 873         case BIOCSRTIMEOUT:
 874                 {
 875                         struct timeval *tv = (struct timeval *)ap->a_data;
 876
 877                         /*
 878                          * Subtract 1 tick from tvtohz() since this isn't
 879                          * a one-shot timer.
 880                          */
 881                         if ((error = itimerfix(tv)) == 0)
 882                                 d->bd_rtout = tvtohz_low(tv);
 883                         break;
 884                 }
 885
 886         /*
 887          * Get read timeout.
 888          */
 889         case BIOCGRTIMEOUT:
 890                 {
 891                         struct timeval *tv = (struct timeval *)ap->a_data;
 892
 893                         tv->tv_sec = d->bd_rtout / hz;
 894                         tv->tv_usec = (d->bd_rtout % hz) * ustick;
 895                         break;
 896                 }
 897
 898         /*
 899          * Get packet stats.
 900          */
 901         case BIOCGSTATS:
 902                 {
 903                         struct bpf_stat *bs = (struct bpf_stat *)ap->a_data;
 904
 905                         bs->bs_recv = d->bd_rcount;
 906                         bs->bs_drop = d->bd_dcount;
 907                         break;
 908                 }
 909
 910         /*
 911          * Set immediate mode.
 912          */
 913         case BIOCIMMEDIATE:
 914                 d->bd_immediate = *(u_int *)ap->a_data;
 915                 break;
 916
 917         case BIOCVERSION:
 918                 {
 919                         struct bpf_version *bv = (struct bpf_version *)ap->a_data;
 920
 921                         bv->bv_major = BPF_MAJOR_VERSION;
 922                         bv->bv_minor = BPF_MINOR_VERSION;
 923                         break;
 924                 }
 925
 926         /*
 927          * Get "header already complete" flag
 928          */
 929         case BIOCGHDRCMPLT:
 930                 *(u_int *)ap->a_data = d->bd_hdrcmplt;
 931                 break;
 932
 933         /*
 934          * Set "header already complete" flag
 935          */
 936         case BIOCSHDRCMPLT:
 937                 d->bd_hdrcmplt = *(u_int *)ap->a_data ? 1 : 0;
 938                 break;
 939
 940         /*
 941          * Get "see sent packets" flag
 942          */
 943         case BIOCGSEESENT:
 944                 *(u_int *)ap->a_data = d->bd_seesent;
 945                 break;
 946
 947         /*
 948          * Set "see sent packets" flag
 949          */
 950         case BIOCSSEESENT:
 951                 d->bd_seesent = *(u_int *)ap->a_data;
 952                 break;
 953
 954         case FIOASYNC:          /* Send signal on receive packets */
 955                 d->bd_async = *(int *)ap->a_data;
 956                 break;
 957
 958         case FIOSETOWN:
 959                 error = fsetown(*(int *)ap->a_data, &d->bd_sigio);
 960                 break;
 961
 962         case FIOGETOWN:
 963                 *(int *)ap->a_data = fgetown(&d->bd_sigio);
 964                 break;
 965
 966         /* This is deprecated, FIOSETOWN should be used instead. */
 967         case TIOCSPGRP:
 968                 error = fsetown(-(*(int *)ap->a_data), &d->bd_sigio);
 969                 break;
 970
 971         /* This is deprecated, FIOGETOWN should be used instead. */
 972         case TIOCGPGRP:
 973                 *(int *)ap->a_data = -fgetown(&d->bd_sigio);
 974                 break;
 975
 976         case BIOCSRSIG:         /* Set receive signal */
 977                 {
 978                         u_int sig;
 979
 980                         sig = *(u_int *)ap->a_data;
 981
 982                         if (sig >= NSIG)
 983                                 error = EINVAL;
 984                         else
 985                                 d->bd_sig = sig;
 986                         break;
 987                 }
 988         case BIOCGRSIG:
 989                 *(u_int *)ap->a_data = d->bd_sig;
 990                 break;
 991         case BIOCLOCK:
 992                 d->bd_locked = 1;
 993                 break;
 994         }
 995         lwkt_reltoken(&bpf_token);
 996
 997         return(error);
 998 }
 999
1000 /*
1001  * Set d's packet filter program to fp.  If this file already has a filter,
1002  * free it and replace it.  Returns EINVAL for bogus requests.
1003  */
1004 static int
1005 bpf_setf(struct bpf_d *d, struct bpf_program *fp, u_long cmd)
1006 {
1007         struct bpf_insn *fcode, *old;
1008         u_int wfilter, flen, size;
1009
1010         if (cmd == BIOCSETWF) {
1011                 old = d->bd_wfilter;
1012                 wfilter = 1;
1013         } else {
1014                 wfilter = 0;
1015                 old = d->bd_rfilter;
1016         }
1017         if (fp->bf_insns == NULL) {
1018                 if (fp->bf_len != 0)
1019                         return(EINVAL);
1020                 if (wfilter)
1021                         d->bd_wfilter = NULL;
1022                 else
1023                         d->bd_rfilter = NULL;
1024                 bpf_resetd(d);
1025                 if (old != NULL)
1026                         kfree(old, M_BPF);
1027                 return(0);
1028         }
1029         flen = fp->bf_len;
1030         if (flen > BPF_MAXINSNS)
1031                 return(EINVAL);
1032
1033         size = flen * sizeof *fp->bf_insns;
1034         fcode = (struct bpf_insn *)kmalloc(size, M_BPF, M_WAITOK);
1035         if (copyin(fp->bf_insns, fcode, size) == 0 &&
1036             bpf_validate(fcode, (int)flen)) {
1037                 if (wfilter)
1038                         d->bd_wfilter = fcode;
1039                 else
1040                         d->bd_rfilter = fcode;
1041                 bpf_resetd(d);
1042                 if (old != NULL)
1043                         kfree(old, M_BPF);
1044
1045                 return(0);
1046         }
1047         kfree(fcode, M_BPF);
1048         return(EINVAL);
1049 }
1050
1051 /*
1052  * Detach a file from its current interface (if attached at all) and attach
1053  * to the interface indicated by the name stored in ifr.
1054  * Return an errno or 0.
1055  */
1056 static int
1057 bpf_setif(struct bpf_d *d, struct ifreq *ifr)
1058 {
1059         struct bpf_if *bp;
1060         int error;
1061         struct ifnet *theywant;
1062
1063         ifnet_lock();
1064
1065         theywant = ifunit(ifr->ifr_name);
1066         if (theywant == NULL) {
1067                 ifnet_unlock();
1068                 return(ENXIO);
1069         }
1070
1071         /*
1072          * Look through attached interfaces for the named one.
1073          */
1074         for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1075                 struct ifnet *ifp = bp->bif_ifp;
1076
1077                 if (ifp == NULL || ifp != theywant)
1078                         continue;
1079                 /* skip additional entry */
1080                 if (bp->bif_driverp != &ifp->if_bpf)
1081                         continue;
1082                 /*
1083                  * We found the requested interface.
1084                  * Allocate the packet buffers if we need to.
1085                  * If we're already attached to requested interface,
1086                  * just flush the buffer.
1087                  */
1088                 if (d->bd_sbuf == NULL) {
1089                         error = bpf_allocbufs(d);
1090                         if (error != 0) {
1091                                 ifnet_unlock();
1092                                 return(error);
1093                         }
1094                 }
1095                 if (bp != d->bd_bif) {
1096                         if (d->bd_bif != NULL) {
1097                                 /*
1098                                  * Detach if attached to something else.
1099                                  */
1100                                 bpf_detachd(d);
1101                         }
1102
1103                         bpf_attachd(d, bp);
1104                 }
1105                 bpf_resetd(d);
1106
1107                 ifnet_unlock();
1108                 return(0);
1109         }
1110
1111         ifnet_unlock();
1112
1113         /* Not found. */
1114         return(ENXIO);
1115 }
1116
1117 static struct filterops bpf_read_filtops =
1118         { FILTEROP_ISFD, NULL, bpf_filter_detach, bpf_filter_read };
1119
1120 static int
1121 bpfkqfilter(struct dev_kqfilter_args *ap)
1122 {
1123         cdev_t dev = ap->a_head.a_dev;
1124         struct knote *kn = ap->a_kn;
1125         struct klist *klist;
1126         struct bpf_d *d;
1127
1128         lwkt_gettoken(&bpf_token);
1129         d = dev->si_drv1;
1130         if (d->bd_bif == NULL) {
1131                 ap->a_result = 1;
1132                 lwkt_reltoken(&bpf_token);
1133                 return (0);
1134         }
1135
1136         ap->a_result = 0;
1137         switch (kn->kn_filter) {
1138         case EVFILT_READ:
1139                 kn->kn_fop = &bpf_read_filtops;
1140                 kn->kn_hook = (caddr_t)d;
1141                 break;
1142         default:
1143                 ap->a_result = EOPNOTSUPP;
1144                 lwkt_reltoken(&bpf_token);
1145                 return (0);
1146         }
1147
1148         klist = &d->bd_kq.ki_note;
1149         knote_insert(klist, kn);
1150         lwkt_reltoken(&bpf_token);
1151
1152         return (0);
1153 }
1154
1155 static void
1156 bpf_filter_detach(struct knote *kn)
1157 {
1158         struct klist *klist;
1159         struct bpf_d *d;
1160
1161         d = (struct bpf_d *)kn->kn_hook;
1162         klist = &d->bd_kq.ki_note;
1163         knote_remove(klist, kn);
1164 }
1165
1166 static int
1167 bpf_filter_read(struct knote *kn, long hint)
1168 {
1169         struct bpf_d *d;
1170         int ready = 0;
1171
1172         d = (struct bpf_d *)kn->kn_hook;
1173         if (d->bd_hlen != 0 ||
1174             ((d->bd_immediate || d->bd_state == BPF_TIMED_OUT) &&
1175             d->bd_slen != 0)) {
1176                 ready = 1;
1177         } else {
1178                 /* Start the read timeout if necessary. */
1179                 if (d->bd_rtout > 0 && d->bd_state == BPF_IDLE) {
1180                         callout_reset(&d->bd_callout, d->bd_rtout,
1181                             bpf_timed_out, d);
1182                         d->bd_state = BPF_WAITING;
1183                 }
1184         }
1185
1186         return (ready);
1187 }
1188
1189
1190 /*
1191  * Process the packet pkt of length pktlen.  The packet is parsed
1192  * by each listener's filter, and if accepted, stashed into the
1193  * corresponding buffer.
1194  */
1195 void
1196 bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen)
1197 {
1198         struct bpf_d *d;
1199         struct timeval tv;
1200         int gottime = 0;
1201         u_int slen;
1202
1203         lwkt_gettoken(&bpf_token);
1204         /* Re-check */
1205         if (bp == NULL) {
1206                 lwkt_reltoken(&bpf_token);
1207                 return;
1208         }
1209
1210         /*
1211          * Note that the ipl does not have to be raised at this point.
1212          * The only problem that could arise here is that if two different
1213          * interfaces shared any data.  This is not the case.
1214          */
1215         SLIST_FOREACH(d, &bp->bif_dlist, bd_next) {
1216                 ++d->bd_rcount;
1217                 slen = bpf_filter(d->bd_rfilter, pkt, pktlen, pktlen);
1218                 if (slen != 0) {
1219                         if (!gottime) {
1220                                 microtime(&tv);
1221                                 gottime = 1;
1222                         }
1223                         catchpacket(d, pkt, pktlen, slen, bcopy, &tv);
1224                 }
1225         }
1226         lwkt_reltoken(&bpf_token);
1227 }
1228
1229 /*
1230  * Copy data from an mbuf chain into a buffer.  This code is derived
1231  * from m_copydata in sys/uipc_mbuf.c.
1232  */
1233 static void
1234 bpf_mcopy(volatile const void *src_arg, volatile void *dst_arg, size_t len)
1235 {
1236         volatile const struct mbuf *m;
1237         u_int count;
1238         volatile u_char *dst;
1239
1240         m = src_arg;
1241         dst = dst_arg;
1242         while (len > 0) {
1243                 if (m == NULL)
1244                         panic("bpf_mcopy");
1245                 count = min(m->m_len, len);
1246                 bcopy(mtod(m, void *), dst, count);
1247                 m = m->m_next;
1248                 dst += count;
1249                 len -= count;
1250         }
1251 }
1252
1253 /*
1254  * Process the packet in the mbuf chain m.  The packet is parsed by each
1255  * listener's filter, and if accepted, stashed into the corresponding
1256  * buffer.
1257  */
1258 void
1259 bpf_mtap(struct bpf_if *bp, struct mbuf *m)
1260 {
1261         struct bpf_d *d;
1262         u_int pktlen, slen;
1263         struct timeval tv;
1264         int gottime = 0;
1265
1266         lwkt_gettoken(&bpf_token);
1267         /* Re-check */
1268         if (bp == NULL) {
1269                 lwkt_reltoken(&bpf_token);
1270                 return;
1271         }
1272
1273         /* Don't compute pktlen, if no descriptor is attached. */
1274         if (SLIST_EMPTY(&bp->bif_dlist)) {
1275                 lwkt_reltoken(&bpf_token);
1276                 return;
1277         }
1278
1279         pktlen = m_lengthm(m, NULL);
1280
1281         SLIST_FOREACH(d, &bp->bif_dlist, bd_next) {
1282                 if (!d->bd_seesent && (m->m_pkthdr.rcvif == NULL))
1283                         continue;
1284                 ++d->bd_rcount;
1285                 slen = bpf_filter(d->bd_rfilter, (u_char *)m, pktlen, 0);
1286                 if (slen != 0) {
1287                         if (!gottime) {
1288                                 microtime(&tv);
1289                                 gottime = 1;
1290                         }
1291                         catchpacket(d, (u_char *)m, pktlen, slen, bpf_mcopy,
1292                                     &tv);
1293                 }
1294         }
1295         lwkt_reltoken(&bpf_token);
1296 }
1297
1298 /*
1299  * Incoming linkage from device drivers, where we have a mbuf chain
1300  * but need to prepend some arbitrary header from a linear buffer.
1301  *
1302  * Con up a minimal dummy header to pacify bpf.  Allocate (only) a
1303  * struct m_hdr on the stack.  This is safe as bpf only reads from the
1304  * fields in this header that we initialize, and will not try to free
1305  * it or keep a pointer to it.
1306  */
1307 void
1308 bpf_mtap_hdr(struct bpf_if *arg, caddr_t data, u_int dlen, struct mbuf *m,
1309     u_int direction)
1310 {
1311         struct m_hdr mh;
1312
1313         mh.mh_flags = 0;
1314         mh.mh_next = m;
1315         mh.mh_len = dlen;
1316         mh.mh_data = data;
1317
1318         bpf_mtap(arg, (struct mbuf *) &mh);
1319 }
1320
1321 void
1322 bpf_mtap_family(struct bpf_if *bp, struct mbuf *m, sa_family_t family)
1323 {
1324         u_int family4;
1325
1326         KKASSERT(family != AF_UNSPEC);
1327
1328         family4 = (u_int)family;
1329         bpf_ptap(bp, m, &family4, sizeof(family4));
1330 }
1331
1332 /*
1333  * Process the packet in the mbuf chain m with the header in m prepended.
1334  * The packet is parsed by each listener's filter, and if accepted,
1335  * stashed into the corresponding buffer.
1336  */
1337 void
1338 bpf_ptap(struct bpf_if *bp, struct mbuf *m, const void *data, u_int dlen)
1339 {
1340         struct mbuf mb;
1341
1342         /*
1343          * Craft on-stack mbuf suitable for passing to bpf_mtap.
1344          * Note that we cut corners here; we only setup what's
1345          * absolutely needed--this mbuf should never go anywhere else.
1346          */
1347         mb.m_next = m;
1348         mb.m_data = __DECONST(void *, data); /* LINTED */
1349         mb.m_len = dlen;
1350         mb.m_pkthdr.rcvif = m->m_pkthdr.rcvif;
1351
1352         bpf_mtap(bp, &mb);
1353 }
1354
1355 /*
1356  * Move the packet data from interface memory (pkt) into the
1357  * store buffer.  Return 1 if it's time to wakeup a listener (buffer full),
1358  * otherwise 0.  "copy" is the routine called to do the actual data
1359  * transfer.  bcopy is passed in to copy contiguous chunks, while
1360  * bpf_mcopy is passed in to copy mbuf chains.  In the latter case,
1361  * pkt is really an mbuf.
1362  */
1363 static void
1364 catchpacket(struct bpf_d *d, u_char *pkt, u_int pktlen, u_int snaplen,
1365             void (*cpfn)(volatile const void *, volatile void *, size_t),
1366             const struct timeval *tv)
1367 {
1368         struct bpf_hdr *hp;
1369         int totlen, curlen;
1370         int hdrlen = d->bd_bif->bif_hdrlen;
1371         int wakeup = 0;
1372         /*
1373          * Figure out how many bytes to move.  If the packet is
1374          * greater or equal to the snapshot length, transfer that
1375          * much.  Otherwise, transfer the whole packet (unless
1376          * we hit the buffer size limit).
1377          */
1378         totlen = hdrlen + min(snaplen, pktlen);
1379         if (totlen > d->bd_bufsize)
1380                 totlen = d->bd_bufsize;
1381
1382         /*
1383          * Round up the end of the previous packet to the next longword.
1384          */
1385         curlen = BPF_WORDALIGN(d->bd_slen);
1386         if (curlen + totlen > d->bd_bufsize) {
1387                 /*
1388                  * This packet will overflow the storage buffer.
1389                  * Rotate the buffers if we can, then wakeup any
1390                  * pending reads.
1391                  */
1392                 if (d->bd_fbuf == NULL) {
1393                         /*
1394                          * We haven't completed the previous read yet,
1395                          * so drop the packet.
1396                          */
1397                         ++d->bd_dcount;
1398                         return;
1399                 }
1400                 ROTATE_BUFFERS(d);
1401                 wakeup = 1;
1402                 curlen = 0;
1403         } else if (d->bd_immediate || d->bd_state == BPF_TIMED_OUT) {
1404                 /*
1405                  * Immediate mode is set, or the read timeout has
1406                  * already expired during a select call.  A packet
1407                  * arrived, so the reader should be woken up.
1408                  */
1409                 wakeup = 1;
1410         }
1411
1412         /*
1413          * Append the bpf header.
1414          */
1415         hp = (struct bpf_hdr *)(d->bd_sbuf + curlen);
1416         hp->bh_tstamp = *tv;
1417         hp->bh_datalen = pktlen;
1418         hp->bh_hdrlen = hdrlen;
1419         /*
1420          * Copy the packet data into the store buffer and update its length.
1421          */
1422         (*cpfn)(pkt, (u_char *)hp + hdrlen, (hp->bh_caplen = totlen - hdrlen));
1423         d->bd_slen = curlen + totlen;
1424
1425         if (wakeup)
1426                 bpf_wakeup(d);
1427 }
1428
1429 /*
1430  * Initialize all nonzero fields of a descriptor.
1431  */
1432 static int
1433 bpf_allocbufs(struct bpf_d *d)
1434 {
1435         d->bd_fbuf = kmalloc(d->bd_bufsize, M_BPF, M_WAITOK);
1436         d->bd_sbuf = kmalloc(d->bd_bufsize, M_BPF, M_WAITOK);
1437         d->bd_slen = 0;
1438         d->bd_hlen = 0;
1439         return(0);
1440 }
1441
1442 /*
1443  * Free buffers and packet filter program currently in use by a descriptor.
1444  * Called on close.
1445  */
1446 static void
1447 bpf_freed(struct bpf_d *d)
1448 {
1449         /*
1450          * We don't need to lock out interrupts since this descriptor has
1451          * been detached from its interface and it yet hasn't been marked
1452          * free.
1453          */
1454         if (d->bd_sbuf != NULL) {
1455                 kfree(d->bd_sbuf, M_BPF);
1456                 if (d->bd_hbuf != NULL)
1457                         kfree(d->bd_hbuf, M_BPF);
1458                 if (d->bd_fbuf != NULL)
1459                         kfree(d->bd_fbuf, M_BPF);
1460         }
1461         if (d->bd_rfilter)
1462                 kfree(d->bd_rfilter, M_BPF);
1463         if (d->bd_wfilter)
1464                 kfree(d->bd_wfilter, M_BPF);
1465 }
1466
1467 /*
1468  * Attach an interface to bpf.  ifp is a pointer to the structure
1469  * defining the interface to be attached, dlt is the link layer type,
1470  * and hdrlen is the fixed size of the link header (variable length
1471  * headers are not yet supported).
1472  */
1473 void
1474 bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
1475 {
1476         bpfattach_dlt(ifp, dlt, hdrlen, &ifp->if_bpf);
1477 }
1478
1479 void
1480 bpfattach_dlt(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp)
1481 {
1482         struct bpf_if *bp;
1483
1484         bp = kmalloc(sizeof *bp, M_BPF, M_WAITOK | M_ZERO);
1485
1486         lwkt_gettoken(&bpf_token);
1487
1488         SLIST_INIT(&bp->bif_dlist);
1489         bp->bif_ifp = ifp;
1490         bp->bif_dlt = dlt;
1491         bp->bif_driverp = driverp;
1492         *bp->bif_driverp = NULL;
1493
1494         bp->bif_next = bpf_iflist;
1495         bpf_iflist = bp;
1496
1497         /*
1498          * Compute the length of the bpf header.  This is not necessarily
1499          * equal to SIZEOF_BPF_HDR because we want to insert spacing such
1500          * that the network layer header begins on a longword boundary (for
1501          * performance reasons and to alleviate alignment restrictions).
1502          */
1503         bp->bif_hdrlen = BPF_WORDALIGN(hdrlen + SIZEOF_BPF_HDR) - hdrlen;
1504
1505         lwkt_reltoken(&bpf_token);
1506
1507         if (bootverbose)
1508                 if_printf(ifp, "bpf attached\n");
1509 }
1510
1511 /*
1512  * Detach bpf from an interface.  This involves detaching each descriptor
1513  * associated with the interface, and leaving bd_bif NULL.  Notify each
1514  * descriptor as it's detached so that any sleepers wake up and get
1515  * ENXIO.
1516  */
1517 void
1518 bpfdetach(struct ifnet *ifp)
1519 {
1520         struct bpf_if *bp, *bp_prev;
1521         struct bpf_d *d;
1522
1523         lwkt_gettoken(&bpf_token);
1524
1525         /* Locate BPF interface information */
1526         bp_prev = NULL;
1527         for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1528                 if (ifp == bp->bif_ifp)
1529                         break;
1530                 bp_prev = bp;
1531         }
1532
1533         /* Interface wasn't attached */
1534         if (bp->bif_ifp == NULL) {
1535                 lwkt_reltoken(&bpf_token);
1536                 kprintf("bpfdetach: %s was not attached\n", ifp->if_xname);
1537                 return;
1538         }
1539
1540         while ((d = SLIST_FIRST(&bp->bif_dlist)) != NULL) {
1541                 bpf_detachd(d);
1542                 bpf_wakeup(d);
1543         }
1544
1545         if (bp_prev != NULL)
1546                 bp_prev->bif_next = bp->bif_next;
1547         else
1548                 bpf_iflist = bp->bif_next;
1549
1550         kfree(bp, M_BPF);
1551
1552         lwkt_reltoken(&bpf_token);
1553 }
1554
1555 /*
1556  * Get a list of available data link type of the interface.
1557  */
1558 static int
1559 bpf_getdltlist(struct bpf_d *d, struct bpf_dltlist *bfl)
1560 {
1561         int n, error;
1562         struct ifnet *ifp;
1563         struct bpf_if *bp;
1564
1565         ifp = d->bd_bif->bif_ifp;
1566         n = 0;
1567         error = 0;
1568         for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1569                 if (bp->bif_ifp != ifp)
1570                         continue;
1571                 if (bfl->bfl_list != NULL) {
1572                         if (n >= bfl->bfl_len) {
1573                                 return (ENOMEM);
1574                         }
1575                         error = copyout(&bp->bif_dlt,
1576                             bfl->bfl_list + n, sizeof(u_int));
1577                 }
1578                 n++;
1579         }
1580         bfl->bfl_len = n;
1581         return(error);
1582 }
1583
1584 /*
1585  * Set the data link type of a BPF instance.
1586  */
1587 static int
1588 bpf_setdlt(struct bpf_d *d, u_int dlt)
1589 {
1590         int error, opromisc;
1591         struct ifnet *ifp;
1592         struct bpf_if *bp;
1593
1594         if (d->bd_bif->bif_dlt == dlt)
1595                 return (0);
1596         ifp = d->bd_bif->bif_ifp;
1597         for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) {
1598                 if (bp->bif_ifp == ifp && bp->bif_dlt == dlt)
1599                         break;
1600         }
1601         if (bp != NULL) {
1602                 opromisc = d->bd_promisc;
1603                 bpf_detachd(d);
1604                 bpf_attachd(d, bp);
1605                 bpf_resetd(d);
1606                 if (opromisc) {
1607                         error = ifpromisc(bp->bif_ifp, 1);
1608                         if (error) {
1609                                 if_printf(bp->bif_ifp,
1610                                         "bpf_setdlt: ifpromisc failed (%d)\n",
1611                                         error);
1612                         } else {
1613                                 d->bd_promisc = 1;
1614                         }
1615                 }
1616         }
1617         return(bp == NULL ? EINVAL : 0);
1618 }
1619
1620 void
1621 bpf_gettoken(void)
1622 {
1623         lwkt_gettoken(&bpf_token);
1624 }
1625
1626 void
1627 bpf_reltoken(void)
1628 {
1629         lwkt_reltoken(&bpf_token);
1630 }
1631
1632 static void
1633 bpf_drvinit(void *unused)
1634 {
1635         int i;
1636
1637         make_autoclone_dev(&bpf_ops, &DEVFS_CLONE_BITMAP(bpf),
1638                 bpfclone, 0, 0, 0600, "bpf");
1639         for (i = 0; i < BPF_PREALLOCATED_UNITS; i++) {
1640                 make_dev(&bpf_ops, i, 0, 0, 0600, "bpf%d", i);
1641                 devfs_clone_bitmap_set(&DEVFS_CLONE_BITMAP(bpf), i);
1642         }
1643 }
1644
1645 static void
1646 bpf_drvuninit(void *unused)
1647 {
1648         devfs_clone_handler_del("bpf");
1649         dev_ops_remove_all(&bpf_ops);
1650         devfs_clone_bitmap_uninit(&DEVFS_CLONE_BITMAP(bpf));
1651 }
1652
1653 SYSINIT(bpfdev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE+CDEV_MAJOR, bpf_drvinit, NULL);
1654 SYSUNINIT(bpfdev, SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bpf_drvuninit, NULL);
1655
1656 #else /* !BPF */
1657 /*
1658  * NOP stubs to allow bpf-using drivers to load and function.
1659  *
1660  * A 'better' implementation would allow the core bpf functionality
1661  * to be loaded at runtime.
1662  */
1663
1664 void
1665 bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen)
1666 {
1667 }
1668
1669 void
1670 bpf_mtap(struct bpf_if *bp, struct mbuf *m)
1671 {
1672 }
1673
1674 void
1675 bpf_ptap(struct bpf_if *bp, struct mbuf *m, const void *data, u_int dlen)
1676 {
1677 }
1678
1679 void
1680 bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
1681 {
1682 }
1683
1684 void
1685 bpfattach_dlt(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp)
1686 {
1687 }
1688
1689 void
1690 bpfdetach(struct ifnet *ifp)
1691 {
1692 }
1693
1694 u_int
1695 bpf_filter(const struct bpf_insn *pc, u_char *p, u_int wirelen, u_int buflen)
1696 {
1697         return -1;      /* "no filter" behaviour */
1698 }
1699
1700 void
1701 bpf_gettoken(void)
1702 {
1703 }
1704
1705 void
1706 bpf_reltoken(void)
1707 {
1708 }
1709
1710 #endif /* !BPF */