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 */ 1711