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