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_DECLARE_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(const void *, 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 (*)(const void *, 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 callout_init(&d->bd_callout); 385 lwkt_reltoken(&bpf_token); 386 387 return(0); 388 } 389 390 static int 391 bpfclone(struct dev_clone_args *ap) 392 { 393 int unit; 394 395 unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(bpf), 0); 396 ap->a_dev = make_only_dev(&bpf_ops, unit, 0, 0, 0600, "bpf%d", unit); 397 398 return 0; 399 } 400 401 /* 402 * Close the descriptor by detaching it from its interface, 403 * deallocating its buffers, and marking it free. 404 */ 405 /* ARGSUSED */ 406 static int 407 bpfclose(struct dev_close_args *ap) 408 { 409 cdev_t dev = ap->a_head.a_dev; 410 struct bpf_d *d = dev->si_drv1; 411 412 lwkt_gettoken(&bpf_token); 413 funsetown(&d->bd_sigio); 414 if (d->bd_state == BPF_WAITING) 415 callout_stop(&d->bd_callout); 416 d->bd_state = BPF_IDLE; 417 if (d->bd_bif != NULL) 418 bpf_detachd(d); 419 bpf_freed(d); 420 dev->si_drv1 = NULL; 421 if (dev->si_uminor >= BPF_PREALLOCATED_UNITS) { 422 devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(bpf), dev->si_uminor); 423 destroy_dev(dev); 424 } 425 kfree(d, M_BPF); 426 lwkt_reltoken(&bpf_token); 427 428 return(0); 429 } 430 431 /* 432 * Rotate the packet buffers in descriptor d. Move the store buffer 433 * into the hold slot, and the free buffer into the store slot. 434 * Zero the length of the new store buffer. 435 */ 436 #define ROTATE_BUFFERS(d) \ 437 (d)->bd_hbuf = (d)->bd_sbuf; \ 438 (d)->bd_hlen = (d)->bd_slen; \ 439 (d)->bd_sbuf = (d)->bd_fbuf; \ 440 (d)->bd_slen = 0; \ 441 (d)->bd_fbuf = NULL; 442 /* 443 * bpfread - read next chunk of packets from buffers 444 */ 445 static int 446 bpfread(struct dev_read_args *ap) 447 { 448 cdev_t dev = ap->a_head.a_dev; 449 struct bpf_d *d = dev->si_drv1; 450 int timed_out; 451 int error; 452 453 lwkt_gettoken(&bpf_token); 454 /* 455 * Restrict application to use a buffer the same size as 456 * as kernel buffers. 457 */ 458 if (ap->a_uio->uio_resid != d->bd_bufsize) { 459 lwkt_reltoken(&bpf_token); 460 return(EINVAL); 461 } 462 463 if (d->bd_state == BPF_WAITING) 464 callout_stop(&d->bd_callout); 465 timed_out = (d->bd_state == BPF_TIMED_OUT); 466 d->bd_state = BPF_IDLE; 467 /* 468 * If the hold buffer is empty, then do a timed sleep, which 469 * ends when the timeout expires or when enough packets 470 * have arrived to fill the store buffer. 471 */ 472 while (d->bd_hbuf == NULL) { 473 if ((d->bd_immediate || (ap->a_ioflag & IO_NDELAY) || timed_out) 474 && d->bd_slen != 0) { 475 /* 476 * A packet(s) either arrived since the previous, 477 * We're in immediate mode, or are reading 478 * in non-blocking mode, and a packet(s) 479 * either arrived since the previous 480 * read or arrived while we were asleep. 481 * Rotate the buffers and return what's here. 482 */ 483 ROTATE_BUFFERS(d); 484 break; 485 } 486 487 /* 488 * No data is available, check to see if the bpf device 489 * is still pointed at a real interface. If not, return 490 * ENXIO so that the userland process knows to rebind 491 * it before using it again. 492 */ 493 if (d->bd_bif == NULL) { 494 lwkt_reltoken(&bpf_token); 495 return(ENXIO); 496 } 497 498 if (ap->a_ioflag & IO_NDELAY) { 499 lwkt_reltoken(&bpf_token); 500 return(EWOULDBLOCK); 501 } 502 error = tsleep(d, PCATCH, "bpf", d->bd_rtout); 503 if (error == EINTR || error == ERESTART) { 504 lwkt_reltoken(&bpf_token); 505 return(error); 506 } 507 if (error == EWOULDBLOCK) { 508 /* 509 * On a timeout, return what's in the buffer, 510 * which may be nothing. If there is something 511 * in the store buffer, we can rotate the buffers. 512 */ 513 if (d->bd_hbuf) 514 /* 515 * We filled up the buffer in between 516 * getting the timeout and arriving 517 * here, so we don't need to rotate. 518 */ 519 break; 520 521 if (d->bd_slen == 0) { 522 lwkt_reltoken(&bpf_token); 523 return(0); 524 } 525 ROTATE_BUFFERS(d); 526 break; 527 } 528 } 529 /* 530 * At this point, we know we have something in the hold slot. 531 */ 532 533 /* 534 * Move data from hold buffer into user space. 535 * We know the entire buffer is transferred since 536 * we checked above that the read buffer is bpf_bufsize bytes. 537 */ 538 error = uiomove(d->bd_hbuf, d->bd_hlen, ap->a_uio); 539 540 d->bd_fbuf = d->bd_hbuf; 541 d->bd_hbuf = NULL; 542 d->bd_hlen = 0; 543 lwkt_reltoken(&bpf_token); 544 545 return(error); 546 } 547 548 549 /* 550 * If there are processes sleeping on this descriptor, wake them up. 551 */ 552 static void 553 bpf_wakeup(struct bpf_d *d) 554 { 555 if (d->bd_state == BPF_WAITING) { 556 callout_stop(&d->bd_callout); 557 d->bd_state = BPF_IDLE; 558 } 559 wakeup(d); 560 if (d->bd_async && d->bd_sig && d->bd_sigio) 561 pgsigio(d->bd_sigio, d->bd_sig, 0); 562 563 KNOTE(&d->bd_kq.ki_note, 0); 564 } 565 566 static void 567 bpf_timed_out(void *arg) 568 { 569 struct bpf_d *d = (struct bpf_d *)arg; 570 571 if (d->bd_state == BPF_WAITING) { 572 d->bd_state = BPF_TIMED_OUT; 573 if (d->bd_slen != 0) 574 bpf_wakeup(d); 575 } 576 } 577 578 static void 579 bpf_output_dispatch(netmsg_t msg) 580 { 581 struct netmsg_bpf_output *bmsg = (struct netmsg_bpf_output *)msg; 582 struct ifnet *ifp = bmsg->nm_ifp; 583 int error; 584 585 /* 586 * The driver frees the mbuf. 587 */ 588 error = ifp->if_output(ifp, bmsg->nm_mbuf, bmsg->nm_dst, NULL); 589 lwkt_replymsg(&msg->lmsg, error); 590 } 591 592 static int 593 bpfwrite(struct dev_write_args *ap) 594 { 595 cdev_t dev = ap->a_head.a_dev; 596 struct bpf_d *d = dev->si_drv1; 597 struct ifnet *ifp; 598 struct mbuf *m; 599 int error, ret; 600 struct sockaddr dst; 601 int datlen; 602 struct netmsg_bpf_output bmsg; 603 604 lwkt_gettoken(&bpf_token); 605 if (d->bd_bif == NULL) { 606 lwkt_reltoken(&bpf_token); 607 return(ENXIO); 608 } 609 610 ifp = d->bd_bif->bif_ifp; 611 612 if (ap->a_uio->uio_resid == 0) { 613 lwkt_reltoken(&bpf_token); 614 return(0); 615 } 616 617 error = bpf_movein(ap->a_uio, (int)d->bd_bif->bif_dlt, &m, 618 &dst, &datlen, d->bd_wfilter); 619 if (error) { 620 lwkt_reltoken(&bpf_token); 621 return(error); 622 } 623 624 if (datlen > ifp->if_mtu) { 625 m_freem(m); 626 lwkt_reltoken(&bpf_token); 627 return(EMSGSIZE); 628 } 629 630 if (d->bd_hdrcmplt) 631 dst.sa_family = pseudo_AF_HDRCMPLT; 632 633 netmsg_init(&bmsg.base, NULL, &curthread->td_msgport, 634 0, bpf_output_dispatch); 635 bmsg.nm_mbuf = m; 636 bmsg.nm_ifp = ifp; 637 bmsg.nm_dst = &dst; 638 639 ret = lwkt_domsg(netisr_cpuport(0), &bmsg.base.lmsg, 0); 640 lwkt_reltoken(&bpf_token); 641 642 return ret; 643 } 644 645 /* 646 * Reset a descriptor by flushing its packet buffer and clearing the 647 * receive and drop counts. Should be called at splimp. 648 */ 649 static void 650 bpf_resetd(struct bpf_d *d) 651 { 652 if (d->bd_hbuf) { 653 /* Free the hold buffer. */ 654 d->bd_fbuf = d->bd_hbuf; 655 d->bd_hbuf = NULL; 656 } 657 d->bd_slen = 0; 658 d->bd_hlen = 0; 659 d->bd_rcount = 0; 660 d->bd_dcount = 0; 661 } 662 663 /* 664 * FIONREAD Check for read packet available. 665 * SIOCGIFADDR Get interface address - convenient hook to driver. 666 * BIOCGBLEN Get buffer len [for read()]. 667 * BIOCSETF Set ethernet read filter. 668 * BIOCSETWF Set ethernet write filter. 669 * BIOCFLUSH Flush read packet buffer. 670 * BIOCPROMISC Put interface into promiscuous mode. 671 * BIOCGDLT Get link layer type. 672 * BIOCGETIF Get interface name. 673 * BIOCSETIF Set interface. 674 * BIOCSRTIMEOUT Set read timeout. 675 * BIOCGRTIMEOUT Get read timeout. 676 * BIOCGSTATS Get packet stats. 677 * BIOCIMMEDIATE Set immediate mode. 678 * BIOCVERSION Get filter language version. 679 * BIOCGHDRCMPLT Get "header already complete" flag 680 * BIOCSHDRCMPLT Set "header already complete" flag 681 * BIOCGSEESENT Get "see packets sent" flag 682 * BIOCSSEESENT Set "see packets sent" flag 683 * BIOCLOCK Set "locked" flag 684 */ 685 /* ARGSUSED */ 686 static int 687 bpfioctl(struct dev_ioctl_args *ap) 688 { 689 cdev_t dev = ap->a_head.a_dev; 690 struct bpf_d *d = dev->si_drv1; 691 int error = 0; 692 693 lwkt_gettoken(&bpf_token); 694 if (d->bd_state == BPF_WAITING) 695 callout_stop(&d->bd_callout); 696 d->bd_state = BPF_IDLE; 697 698 if (d->bd_locked == 1) { 699 switch (ap->a_cmd) { 700 case BIOCGBLEN: 701 case BIOCFLUSH: 702 case BIOCGDLT: 703 case BIOCGDLTLIST: 704 case BIOCGETIF: 705 case BIOCGRTIMEOUT: 706 case BIOCGSTATS: 707 case BIOCVERSION: 708 case BIOCGRSIG: 709 case BIOCGHDRCMPLT: 710 case FIONREAD: 711 case BIOCLOCK: 712 case BIOCSRTIMEOUT: 713 case BIOCIMMEDIATE: 714 case TIOCGPGRP: 715 break; 716 default: 717 lwkt_reltoken(&bpf_token); 718 return (EPERM); 719 } 720 } 721 switch (ap->a_cmd) { 722 default: 723 error = EINVAL; 724 break; 725 726 /* 727 * Check for read packet available. 728 */ 729 case FIONREAD: 730 { 731 int n; 732 733 n = d->bd_slen; 734 if (d->bd_hbuf) 735 n += d->bd_hlen; 736 737 *(int *)ap->a_data = n; 738 break; 739 } 740 741 case SIOCGIFADDR: 742 { 743 struct ifnet *ifp; 744 745 if (d->bd_bif == NULL) { 746 error = EINVAL; 747 } else { 748 ifp = d->bd_bif->bif_ifp; 749 ifnet_serialize_all(ifp); 750 error = ifp->if_ioctl(ifp, ap->a_cmd, 751 ap->a_data, ap->a_cred); 752 ifnet_deserialize_all(ifp); 753 } 754 break; 755 } 756 757 /* 758 * Get buffer len [for read()]. 759 */ 760 case BIOCGBLEN: 761 *(u_int *)ap->a_data = d->bd_bufsize; 762 break; 763 764 /* 765 * Set buffer length. 766 */ 767 case BIOCSBLEN: 768 if (d->bd_bif != NULL) { 769 error = EINVAL; 770 } else { 771 u_int size = *(u_int *)ap->a_data; 772 773 if (size > bpf_maxbufsize) 774 *(u_int *)ap->a_data = size = bpf_maxbufsize; 775 else if (size < BPF_MINBUFSIZE) 776 *(u_int *)ap->a_data = size = BPF_MINBUFSIZE; 777 d->bd_bufsize = size; 778 } 779 break; 780 781 /* 782 * Set link layer read filter. 783 */ 784 case BIOCSETF: 785 case BIOCSETWF: 786 error = bpf_setf(d, (struct bpf_program *)ap->a_data, 787 ap->a_cmd); 788 break; 789 790 /* 791 * Flush read packet buffer. 792 */ 793 case BIOCFLUSH: 794 bpf_resetd(d); 795 break; 796 797 /* 798 * Put interface into promiscuous mode. 799 */ 800 case BIOCPROMISC: 801 if (d->bd_bif == NULL) { 802 /* 803 * No interface attached yet. 804 */ 805 error = EINVAL; 806 break; 807 } 808 if (d->bd_promisc == 0) { 809 error = ifpromisc(d->bd_bif->bif_ifp, 1); 810 if (error == 0) 811 d->bd_promisc = 1; 812 } 813 break; 814 815 /* 816 * Get device parameters. 817 */ 818 case BIOCGDLT: 819 if (d->bd_bif == NULL) 820 error = EINVAL; 821 else 822 *(u_int *)ap->a_data = d->bd_bif->bif_dlt; 823 break; 824 825 /* 826 * Get a list of supported data link types. 827 */ 828 case BIOCGDLTLIST: 829 if (d->bd_bif == NULL) { 830 error = EINVAL; 831 } else { 832 error = bpf_getdltlist(d, 833 (struct bpf_dltlist *)ap->a_data); 834 } 835 break; 836 837 /* 838 * Set data link type. 839 */ 840 case BIOCSDLT: 841 if (d->bd_bif == NULL) 842 error = EINVAL; 843 else 844 error = bpf_setdlt(d, *(u_int *)ap->a_data); 845 break; 846 847 /* 848 * Get interface name. 849 */ 850 case BIOCGETIF: 851 if (d->bd_bif == NULL) { 852 error = EINVAL; 853 } else { 854 struct ifnet *const ifp = d->bd_bif->bif_ifp; 855 struct ifreq *const ifr = (struct ifreq *)ap->a_data; 856 857 strlcpy(ifr->ifr_name, ifp->if_xname, 858 sizeof ifr->ifr_name); 859 } 860 break; 861 862 /* 863 * Set interface. 864 */ 865 case BIOCSETIF: 866 error = bpf_setif(d, (struct ifreq *)ap->a_data); 867 break; 868 869 /* 870 * Set read timeout. 871 */ 872 case BIOCSRTIMEOUT: 873 { 874 struct timeval *tv = (struct timeval *)ap->a_data; 875 876 /* 877 * Subtract 1 tick from tvtohz() since this isn't 878 * a one-shot timer. 879 */ 880 if ((error = itimerfix(tv)) == 0) 881 d->bd_rtout = tvtohz_low(tv); 882 break; 883 } 884 885 /* 886 * Get read timeout. 887 */ 888 case BIOCGRTIMEOUT: 889 { 890 struct timeval *tv = (struct timeval *)ap->a_data; 891 892 tv->tv_sec = d->bd_rtout / hz; 893 tv->tv_usec = (d->bd_rtout % hz) * ustick; 894 break; 895 } 896 897 /* 898 * Get packet stats. 899 */ 900 case BIOCGSTATS: 901 { 902 struct bpf_stat *bs = (struct bpf_stat *)ap->a_data; 903 904 bs->bs_recv = d->bd_rcount; 905 bs->bs_drop = d->bd_dcount; 906 break; 907 } 908 909 /* 910 * Set immediate mode. 911 */ 912 case BIOCIMMEDIATE: 913 d->bd_immediate = *(u_int *)ap->a_data; 914 break; 915 916 case BIOCVERSION: 917 { 918 struct bpf_version *bv = (struct bpf_version *)ap->a_data; 919 920 bv->bv_major = BPF_MAJOR_VERSION; 921 bv->bv_minor = BPF_MINOR_VERSION; 922 break; 923 } 924 925 /* 926 * Get "header already complete" flag 927 */ 928 case BIOCGHDRCMPLT: 929 *(u_int *)ap->a_data = d->bd_hdrcmplt; 930 break; 931 932 /* 933 * Set "header already complete" flag 934 */ 935 case BIOCSHDRCMPLT: 936 d->bd_hdrcmplt = *(u_int *)ap->a_data ? 1 : 0; 937 break; 938 939 /* 940 * Get "see sent packets" flag 941 */ 942 case BIOCGSEESENT: 943 *(u_int *)ap->a_data = d->bd_seesent; 944 break; 945 946 /* 947 * Set "see sent packets" flag 948 */ 949 case BIOCSSEESENT: 950 d->bd_seesent = *(u_int *)ap->a_data; 951 break; 952 953 case FIOASYNC: /* Send signal on receive packets */ 954 d->bd_async = *(int *)ap->a_data; 955 break; 956 957 case FIOSETOWN: 958 error = fsetown(*(int *)ap->a_data, &d->bd_sigio); 959 break; 960 961 case FIOGETOWN: 962 *(int *)ap->a_data = fgetown(&d->bd_sigio); 963 break; 964 965 /* This is deprecated, FIOSETOWN should be used instead. */ 966 case TIOCSPGRP: 967 error = fsetown(-(*(int *)ap->a_data), &d->bd_sigio); 968 break; 969 970 /* This is deprecated, FIOGETOWN should be used instead. */ 971 case TIOCGPGRP: 972 *(int *)ap->a_data = -fgetown(&d->bd_sigio); 973 break; 974 975 case BIOCSRSIG: /* Set receive signal */ 976 { 977 u_int sig; 978 979 sig = *(u_int *)ap->a_data; 980 981 if (sig >= NSIG) 982 error = EINVAL; 983 else 984 d->bd_sig = sig; 985 break; 986 } 987 case BIOCGRSIG: 988 *(u_int *)ap->a_data = d->bd_sig; 989 break; 990 case BIOCLOCK: 991 d->bd_locked = 1; 992 break; 993 } 994 lwkt_reltoken(&bpf_token); 995 996 return(error); 997 } 998 999 /* 1000 * Set d's packet filter program to fp. If this file already has a filter, 1001 * free it and replace it. Returns EINVAL for bogus requests. 1002 */ 1003 static int 1004 bpf_setf(struct bpf_d *d, struct bpf_program *fp, u_long cmd) 1005 { 1006 struct bpf_insn *fcode, *old; 1007 u_int wfilter, flen, size; 1008 1009 if (cmd == BIOCSETWF) { 1010 old = d->bd_wfilter; 1011 wfilter = 1; 1012 } else { 1013 wfilter = 0; 1014 old = d->bd_rfilter; 1015 } 1016 if (fp->bf_insns == NULL) { 1017 if (fp->bf_len != 0) 1018 return(EINVAL); 1019 if (wfilter) 1020 d->bd_wfilter = NULL; 1021 else 1022 d->bd_rfilter = NULL; 1023 bpf_resetd(d); 1024 if (old != NULL) 1025 kfree(old, M_BPF); 1026 return(0); 1027 } 1028 flen = fp->bf_len; 1029 if (flen > BPF_MAXINSNS) 1030 return(EINVAL); 1031 1032 size = flen * sizeof *fp->bf_insns; 1033 fcode = (struct bpf_insn *)kmalloc(size, M_BPF, M_WAITOK); 1034 if (copyin(fp->bf_insns, fcode, size) == 0 && 1035 bpf_validate(fcode, (int)flen)) { 1036 if (wfilter) 1037 d->bd_wfilter = fcode; 1038 else 1039 d->bd_rfilter = fcode; 1040 bpf_resetd(d); 1041 if (old != NULL) 1042 kfree(old, M_BPF); 1043 1044 return(0); 1045 } 1046 kfree(fcode, M_BPF); 1047 return(EINVAL); 1048 } 1049 1050 /* 1051 * Detach a file from its current interface (if attached at all) and attach 1052 * to the interface indicated by the name stored in ifr. 1053 * Return an errno or 0. 1054 */ 1055 static int 1056 bpf_setif(struct bpf_d *d, struct ifreq *ifr) 1057 { 1058 struct bpf_if *bp; 1059 int error; 1060 struct ifnet *theywant; 1061 1062 ifnet_lock(); 1063 1064 theywant = ifunit(ifr->ifr_name); 1065 if (theywant == NULL) { 1066 ifnet_unlock(); 1067 return(ENXIO); 1068 } 1069 1070 /* 1071 * Look through attached interfaces for the named one. 1072 */ 1073 for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) { 1074 struct ifnet *ifp = bp->bif_ifp; 1075 1076 if (ifp == NULL || ifp != theywant) 1077 continue; 1078 /* skip additional entry */ 1079 if (bp->bif_driverp != &ifp->if_bpf) 1080 continue; 1081 /* 1082 * We found the requested interface. 1083 * Allocate the packet buffers if we need to. 1084 * If we're already attached to requested interface, 1085 * just flush the buffer. 1086 */ 1087 if (d->bd_sbuf == NULL) { 1088 error = bpf_allocbufs(d); 1089 if (error != 0) { 1090 ifnet_unlock(); 1091 return(error); 1092 } 1093 } 1094 if (bp != d->bd_bif) { 1095 if (d->bd_bif != NULL) { 1096 /* 1097 * Detach if attached to something else. 1098 */ 1099 bpf_detachd(d); 1100 } 1101 1102 bpf_attachd(d, bp); 1103 } 1104 bpf_resetd(d); 1105 1106 ifnet_unlock(); 1107 return(0); 1108 } 1109 1110 ifnet_unlock(); 1111 1112 /* Not found. */ 1113 return(ENXIO); 1114 } 1115 1116 static struct filterops bpf_read_filtops = 1117 { FILTEROP_ISFD, NULL, bpf_filter_detach, bpf_filter_read }; 1118 1119 static int 1120 bpfkqfilter(struct dev_kqfilter_args *ap) 1121 { 1122 cdev_t dev = ap->a_head.a_dev; 1123 struct knote *kn = ap->a_kn; 1124 struct klist *klist; 1125 struct bpf_d *d; 1126 1127 lwkt_gettoken(&bpf_token); 1128 d = dev->si_drv1; 1129 if (d->bd_bif == NULL) { 1130 ap->a_result = 1; 1131 lwkt_reltoken(&bpf_token); 1132 return (0); 1133 } 1134 1135 ap->a_result = 0; 1136 switch (kn->kn_filter) { 1137 case EVFILT_READ: 1138 kn->kn_fop = &bpf_read_filtops; 1139 kn->kn_hook = (caddr_t)d; 1140 break; 1141 default: 1142 ap->a_result = EOPNOTSUPP; 1143 lwkt_reltoken(&bpf_token); 1144 return (0); 1145 } 1146 1147 klist = &d->bd_kq.ki_note; 1148 knote_insert(klist, kn); 1149 lwkt_reltoken(&bpf_token); 1150 1151 return (0); 1152 } 1153 1154 static void 1155 bpf_filter_detach(struct knote *kn) 1156 { 1157 struct klist *klist; 1158 struct bpf_d *d; 1159 1160 d = (struct bpf_d *)kn->kn_hook; 1161 klist = &d->bd_kq.ki_note; 1162 knote_remove(klist, kn); 1163 } 1164 1165 static int 1166 bpf_filter_read(struct knote *kn, long hint) 1167 { 1168 struct bpf_d *d; 1169 int ready = 0; 1170 1171 d = (struct bpf_d *)kn->kn_hook; 1172 if (d->bd_hlen != 0 || 1173 ((d->bd_immediate || d->bd_state == BPF_TIMED_OUT) && 1174 d->bd_slen != 0)) { 1175 ready = 1; 1176 } else { 1177 /* Start the read timeout if necessary. */ 1178 if (d->bd_rtout > 0 && d->bd_state == BPF_IDLE) { 1179 callout_reset(&d->bd_callout, d->bd_rtout, 1180 bpf_timed_out, d); 1181 d->bd_state = BPF_WAITING; 1182 } 1183 } 1184 1185 return (ready); 1186 } 1187 1188 1189 /* 1190 * Process the packet pkt of length pktlen. The packet is parsed 1191 * by each listener's filter, and if accepted, stashed into the 1192 * corresponding buffer. 1193 */ 1194 void 1195 bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen) 1196 { 1197 struct bpf_d *d; 1198 struct timeval tv; 1199 int gottime = 0; 1200 u_int slen; 1201 1202 lwkt_gettoken(&bpf_token); 1203 /* Re-check */ 1204 if (bp == NULL) { 1205 lwkt_reltoken(&bpf_token); 1206 return; 1207 } 1208 1209 /* 1210 * Note that the ipl does not have to be raised at this point. 1211 * The only problem that could arise here is that if two different 1212 * interfaces shared any data. This is not the case. 1213 */ 1214 SLIST_FOREACH(d, &bp->bif_dlist, bd_next) { 1215 ++d->bd_rcount; 1216 slen = bpf_filter(d->bd_rfilter, pkt, pktlen, pktlen); 1217 if (slen != 0) { 1218 if (!gottime) { 1219 microtime(&tv); 1220 gottime = 1; 1221 } 1222 catchpacket(d, pkt, pktlen, slen, ovbcopy, &tv); 1223 } 1224 } 1225 lwkt_reltoken(&bpf_token); 1226 } 1227 1228 /* 1229 * Copy data from an mbuf chain into a buffer. This code is derived 1230 * from m_copydata in sys/uipc_mbuf.c. 1231 */ 1232 static void 1233 bpf_mcopy(const void *src_arg, void *dst_arg, size_t len) 1234 { 1235 const struct mbuf *m; 1236 u_int count; 1237 u_char *dst; 1238 1239 m = src_arg; 1240 dst = dst_arg; 1241 while (len > 0) { 1242 if (m == NULL) 1243 panic("bpf_mcopy"); 1244 count = min(m->m_len, len); 1245 bcopy(mtod(m, void *), dst, count); 1246 m = m->m_next; 1247 dst += count; 1248 len -= count; 1249 } 1250 } 1251 1252 /* 1253 * Process the packet in the mbuf chain m. The packet is parsed by each 1254 * listener's filter, and if accepted, stashed into the corresponding 1255 * buffer. 1256 */ 1257 void 1258 bpf_mtap(struct bpf_if *bp, struct mbuf *m) 1259 { 1260 struct bpf_d *d; 1261 u_int pktlen, slen; 1262 struct timeval tv; 1263 int gottime = 0; 1264 1265 lwkt_gettoken(&bpf_token); 1266 /* Re-check */ 1267 if (bp == NULL) { 1268 lwkt_reltoken(&bpf_token); 1269 return; 1270 } 1271 1272 /* Don't compute pktlen, if no descriptor is attached. */ 1273 if (SLIST_EMPTY(&bp->bif_dlist)) { 1274 lwkt_reltoken(&bpf_token); 1275 return; 1276 } 1277 1278 pktlen = m_lengthm(m, NULL); 1279 1280 SLIST_FOREACH(d, &bp->bif_dlist, bd_next) { 1281 if (!d->bd_seesent && (m->m_pkthdr.rcvif == NULL)) 1282 continue; 1283 ++d->bd_rcount; 1284 slen = bpf_filter(d->bd_rfilter, (u_char *)m, pktlen, 0); 1285 if (slen != 0) { 1286 if (!gottime) { 1287 microtime(&tv); 1288 gottime = 1; 1289 } 1290 catchpacket(d, (u_char *)m, pktlen, slen, bpf_mcopy, 1291 &tv); 1292 } 1293 } 1294 lwkt_reltoken(&bpf_token); 1295 } 1296 1297 /* 1298 * Incoming linkage from device drivers, where we have a mbuf chain 1299 * but need to prepend some arbitrary header from a linear buffer. 1300 * 1301 * Con up a minimal dummy header to pacify bpf. Allocate (only) a 1302 * struct m_hdr on the stack. This is safe as bpf only reads from the 1303 * fields in this header that we initialize, and will not try to free 1304 * it or keep a pointer to it. 1305 */ 1306 void 1307 bpf_mtap_hdr(struct bpf_if *arg, caddr_t data, u_int dlen, struct mbuf *m, 1308 u_int direction) 1309 { 1310 struct m_hdr mh; 1311 1312 mh.mh_flags = 0; 1313 mh.mh_next = m; 1314 mh.mh_len = dlen; 1315 mh.mh_data = data; 1316 1317 bpf_mtap(arg, (struct mbuf *) &mh); 1318 } 1319 1320 void 1321 bpf_mtap_family(struct bpf_if *bp, struct mbuf *m, sa_family_t family) 1322 { 1323 u_int family4; 1324 1325 KKASSERT(family != AF_UNSPEC); 1326 1327 family4 = (u_int)family; 1328 bpf_ptap(bp, m, &family4, sizeof(family4)); 1329 } 1330 1331 /* 1332 * Process the packet in the mbuf chain m with the header in m prepended. 1333 * The packet is parsed by each listener's filter, and if accepted, 1334 * stashed into the corresponding buffer. 1335 */ 1336 void 1337 bpf_ptap(struct bpf_if *bp, struct mbuf *m, const void *data, u_int dlen) 1338 { 1339 struct mbuf mb; 1340 1341 /* 1342 * Craft on-stack mbuf suitable for passing to bpf_mtap. 1343 * Note that we cut corners here; we only setup what's 1344 * absolutely needed--this mbuf should never go anywhere else. 1345 */ 1346 mb.m_next = m; 1347 mb.m_data = __DECONST(void *, data); /* LINTED */ 1348 mb.m_len = dlen; 1349 mb.m_pkthdr.rcvif = m->m_pkthdr.rcvif; 1350 1351 bpf_mtap(bp, &mb); 1352 } 1353 1354 /* 1355 * Move the packet data from interface memory (pkt) into the 1356 * store buffer. Return 1 if it's time to wakeup a listener (buffer full), 1357 * otherwise 0. "copy" is the routine called to do the actual data 1358 * transfer. bcopy is passed in to copy contiguous chunks, while 1359 * bpf_mcopy is passed in to copy mbuf chains. In the latter case, 1360 * pkt is really an mbuf. 1361 */ 1362 static void 1363 catchpacket(struct bpf_d *d, u_char *pkt, u_int pktlen, u_int snaplen, 1364 void (*cpfn)(const void *, void *, size_t), 1365 const struct timeval *tv) 1366 { 1367 struct bpf_hdr *hp; 1368 int totlen, curlen; 1369 int hdrlen = d->bd_bif->bif_hdrlen; 1370 int wakeup = 0; 1371 /* 1372 * Figure out how many bytes to move. If the packet is 1373 * greater or equal to the snapshot length, transfer that 1374 * much. Otherwise, transfer the whole packet (unless 1375 * we hit the buffer size limit). 1376 */ 1377 totlen = hdrlen + min(snaplen, pktlen); 1378 if (totlen > d->bd_bufsize) 1379 totlen = d->bd_bufsize; 1380 1381 /* 1382 * Round up the end of the previous packet to the next longword. 1383 */ 1384 curlen = BPF_WORDALIGN(d->bd_slen); 1385 if (curlen + totlen > d->bd_bufsize) { 1386 /* 1387 * This packet will overflow the storage buffer. 1388 * Rotate the buffers if we can, then wakeup any 1389 * pending reads. 1390 */ 1391 if (d->bd_fbuf == NULL) { 1392 /* 1393 * We haven't completed the previous read yet, 1394 * so drop the packet. 1395 */ 1396 ++d->bd_dcount; 1397 return; 1398 } 1399 ROTATE_BUFFERS(d); 1400 wakeup = 1; 1401 curlen = 0; 1402 } else if (d->bd_immediate || d->bd_state == BPF_TIMED_OUT) { 1403 /* 1404 * Immediate mode is set, or the read timeout has 1405 * already expired during a select call. A packet 1406 * arrived, so the reader should be woken up. 1407 */ 1408 wakeup = 1; 1409 } 1410 1411 /* 1412 * Append the bpf header. 1413 */ 1414 hp = (struct bpf_hdr *)(d->bd_sbuf + curlen); 1415 hp->bh_tstamp = *tv; 1416 hp->bh_datalen = pktlen; 1417 hp->bh_hdrlen = hdrlen; 1418 /* 1419 * Copy the packet data into the store buffer and update its length. 1420 */ 1421 (*cpfn)(pkt, (u_char *)hp + hdrlen, (hp->bh_caplen = totlen - hdrlen)); 1422 d->bd_slen = curlen + totlen; 1423 1424 if (wakeup) 1425 bpf_wakeup(d); 1426 } 1427 1428 /* 1429 * Initialize all nonzero fields of a descriptor. 1430 */ 1431 static int 1432 bpf_allocbufs(struct bpf_d *d) 1433 { 1434 d->bd_fbuf = kmalloc(d->bd_bufsize, M_BPF, M_WAITOK); 1435 d->bd_sbuf = kmalloc(d->bd_bufsize, M_BPF, M_WAITOK); 1436 d->bd_slen = 0; 1437 d->bd_hlen = 0; 1438 return(0); 1439 } 1440 1441 /* 1442 * Free buffers and packet filter program currently in use by a descriptor. 1443 * Called on close. 1444 */ 1445 static void 1446 bpf_freed(struct bpf_d *d) 1447 { 1448 /* 1449 * We don't need to lock out interrupts since this descriptor has 1450 * been detached from its interface and it yet hasn't been marked 1451 * free. 1452 */ 1453 if (d->bd_sbuf != NULL) { 1454 kfree(d->bd_sbuf, M_BPF); 1455 if (d->bd_hbuf != NULL) 1456 kfree(d->bd_hbuf, M_BPF); 1457 if (d->bd_fbuf != NULL) 1458 kfree(d->bd_fbuf, M_BPF); 1459 } 1460 if (d->bd_rfilter) 1461 kfree(d->bd_rfilter, M_BPF); 1462 if (d->bd_wfilter) 1463 kfree(d->bd_wfilter, M_BPF); 1464 } 1465 1466 /* 1467 * Attach an interface to bpf. ifp is a pointer to the structure 1468 * defining the interface to be attached, dlt is the link layer type, 1469 * and hdrlen is the fixed size of the link header (variable length 1470 * headers are not yet supported). 1471 */ 1472 void 1473 bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen) 1474 { 1475 bpfattach_dlt(ifp, dlt, hdrlen, &ifp->if_bpf); 1476 } 1477 1478 void 1479 bpfattach_dlt(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp) 1480 { 1481 struct bpf_if *bp; 1482 1483 bp = kmalloc(sizeof *bp, M_BPF, M_WAITOK | M_ZERO); 1484 1485 lwkt_gettoken(&bpf_token); 1486 1487 SLIST_INIT(&bp->bif_dlist); 1488 bp->bif_ifp = ifp; 1489 bp->bif_dlt = dlt; 1490 bp->bif_driverp = driverp; 1491 *bp->bif_driverp = NULL; 1492 1493 bp->bif_next = bpf_iflist; 1494 bpf_iflist = bp; 1495 1496 /* 1497 * Compute the length of the bpf header. This is not necessarily 1498 * equal to SIZEOF_BPF_HDR because we want to insert spacing such 1499 * that the network layer header begins on a longword boundary (for 1500 * performance reasons and to alleviate alignment restrictions). 1501 */ 1502 bp->bif_hdrlen = BPF_WORDALIGN(hdrlen + SIZEOF_BPF_HDR) - hdrlen; 1503 1504 lwkt_reltoken(&bpf_token); 1505 1506 if (bootverbose) 1507 if_printf(ifp, "bpf attached\n"); 1508 } 1509 1510 /* 1511 * Detach bpf from an interface. This involves detaching each descriptor 1512 * associated with the interface, and leaving bd_bif NULL. Notify each 1513 * descriptor as it's detached so that any sleepers wake up and get 1514 * ENXIO. 1515 */ 1516 void 1517 bpfdetach(struct ifnet *ifp) 1518 { 1519 struct bpf_if *bp, *bp_prev; 1520 struct bpf_d *d; 1521 1522 lwkt_gettoken(&bpf_token); 1523 1524 /* Locate BPF interface information */ 1525 bp_prev = NULL; 1526 for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) { 1527 if (ifp == bp->bif_ifp) 1528 break; 1529 bp_prev = bp; 1530 } 1531 1532 /* Interface wasn't attached */ 1533 if (bp->bif_ifp == NULL) { 1534 lwkt_reltoken(&bpf_token); 1535 kprintf("bpfdetach: %s was not attached\n", ifp->if_xname); 1536 return; 1537 } 1538 1539 while ((d = SLIST_FIRST(&bp->bif_dlist)) != NULL) { 1540 bpf_detachd(d); 1541 bpf_wakeup(d); 1542 } 1543 1544 if (bp_prev != NULL) 1545 bp_prev->bif_next = bp->bif_next; 1546 else 1547 bpf_iflist = bp->bif_next; 1548 1549 kfree(bp, M_BPF); 1550 1551 lwkt_reltoken(&bpf_token); 1552 } 1553 1554 /* 1555 * Get a list of available data link type of the interface. 1556 */ 1557 static int 1558 bpf_getdltlist(struct bpf_d *d, struct bpf_dltlist *bfl) 1559 { 1560 int n, error; 1561 struct ifnet *ifp; 1562 struct bpf_if *bp; 1563 1564 ifp = d->bd_bif->bif_ifp; 1565 n = 0; 1566 error = 0; 1567 for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) { 1568 if (bp->bif_ifp != ifp) 1569 continue; 1570 if (bfl->bfl_list != NULL) { 1571 if (n >= bfl->bfl_len) { 1572 return (ENOMEM); 1573 } 1574 error = copyout(&bp->bif_dlt, 1575 bfl->bfl_list + n, sizeof(u_int)); 1576 } 1577 n++; 1578 } 1579 bfl->bfl_len = n; 1580 return(error); 1581 } 1582 1583 /* 1584 * Set the data link type of a BPF instance. 1585 */ 1586 static int 1587 bpf_setdlt(struct bpf_d *d, u_int dlt) 1588 { 1589 int error, opromisc; 1590 struct ifnet *ifp; 1591 struct bpf_if *bp; 1592 1593 if (d->bd_bif->bif_dlt == dlt) 1594 return (0); 1595 ifp = d->bd_bif->bif_ifp; 1596 for (bp = bpf_iflist; bp != NULL; bp = bp->bif_next) { 1597 if (bp->bif_ifp == ifp && bp->bif_dlt == dlt) 1598 break; 1599 } 1600 if (bp != NULL) { 1601 opromisc = d->bd_promisc; 1602 bpf_detachd(d); 1603 bpf_attachd(d, bp); 1604 bpf_resetd(d); 1605 if (opromisc) { 1606 error = ifpromisc(bp->bif_ifp, 1); 1607 if (error) { 1608 if_printf(bp->bif_ifp, 1609 "bpf_setdlt: ifpromisc failed (%d)\n", 1610 error); 1611 } else { 1612 d->bd_promisc = 1; 1613 } 1614 } 1615 } 1616 return(bp == NULL ? EINVAL : 0); 1617 } 1618 1619 void 1620 bpf_gettoken(void) 1621 { 1622 lwkt_gettoken(&bpf_token); 1623 } 1624 1625 void 1626 bpf_reltoken(void) 1627 { 1628 lwkt_reltoken(&bpf_token); 1629 } 1630 1631 static void 1632 bpf_drvinit(void *unused) 1633 { 1634 int i; 1635 1636 make_autoclone_dev(&bpf_ops, &DEVFS_CLONE_BITMAP(bpf), 1637 bpfclone, 0, 0, 0600, "bpf"); 1638 for (i = 0; i < BPF_PREALLOCATED_UNITS; i++) { 1639 make_dev(&bpf_ops, i, 0, 0, 0600, "bpf%d", i); 1640 devfs_clone_bitmap_set(&DEVFS_CLONE_BITMAP(bpf), i); 1641 } 1642 } 1643 1644 static void 1645 bpf_drvuninit(void *unused) 1646 { 1647 devfs_clone_handler_del("bpf"); 1648 dev_ops_remove_all(&bpf_ops); 1649 devfs_clone_bitmap_uninit(&DEVFS_CLONE_BITMAP(bpf)); 1650 } 1651 1652 SYSINIT(bpfdev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE+CDEV_MAJOR, bpf_drvinit, NULL); 1653 SYSUNINIT(bpfdev, SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bpf_drvuninit, NULL); 1654 1655 #else /* !BPF */ 1656 /* 1657 * NOP stubs to allow bpf-using drivers to load and function. 1658 * 1659 * A 'better' implementation would allow the core bpf functionality 1660 * to be loaded at runtime. 1661 */ 1662 1663 void 1664 bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen) 1665 { 1666 } 1667 1668 void 1669 bpf_mtap(struct bpf_if *bp, struct mbuf *m) 1670 { 1671 } 1672 1673 void 1674 bpf_ptap(struct bpf_if *bp, struct mbuf *m, const void *data, u_int dlen) 1675 { 1676 } 1677 1678 void 1679 bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen) 1680 { 1681 } 1682 1683 void 1684 bpfattach_dlt(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp) 1685 { 1686 } 1687 1688 void 1689 bpfdetach(struct ifnet *ifp) 1690 { 1691 } 1692 1693 u_int 1694 bpf_filter(const struct bpf_insn *pc, u_char *p, u_int wirelen, u_int buflen) 1695 { 1696 return -1; /* "no filter" behaviour */ 1697 } 1698 1699 void 1700 bpf_gettoken(void) 1701 { 1702 } 1703 1704 void 1705 bpf_reltoken(void) 1706 { 1707 } 1708 1709 #endif /* !BPF */ 1710