xref: /freebsd/sys/net/bpf.c (revision 74549d4b0fb8869daf20a32efd31db04a07c040e)
1c398230bSWarner Losh /*-
251369649SPedro F. Giffuni  * SPDX-License-Identifier: BSD-3-Clause
351369649SPedro F. Giffuni  *
4df8bae1dSRodney W. Grimes  * Copyright (c) 1990, 1991, 1993
5253a3814SLawrence Stewart  *	The Regents of the University of California.  All rights reserved.
6df8bae1dSRodney W. Grimes  *
7df8bae1dSRodney W. Grimes  * This code is derived from the Stanford/CMU enet packet filter,
8df8bae1dSRodney W. Grimes  * (net/enet.c) distributed as part of 4.3BSD, and code contributed
9df8bae1dSRodney W. Grimes  * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
10df8bae1dSRodney W. Grimes  * Berkeley Laboratory.
11df8bae1dSRodney W. Grimes  *
12df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
13df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
14df8bae1dSRodney W. Grimes  * are met:
15df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
16df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
17df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
18df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
19df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
20fbbd9655SWarner Losh  * 3. Neither the name of the University nor the names of its contributors
21df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
22df8bae1dSRodney W. Grimes  *    without specific prior written permission.
23df8bae1dSRodney W. Grimes  *
24df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
35df8bae1dSRodney W. Grimes  *
364f252c4dSRuslan Ermilov  *      @(#)bpf.c	8.4 (Berkeley) 1/9/95
37df8bae1dSRodney W. Grimes  */
38df8bae1dSRodney W. Grimes 
39c7866007SRobert Watson #include <sys/cdefs.h>
40c7866007SRobert Watson __FBSDID("$FreeBSD$");
41c7866007SRobert Watson 
425bb5f2c9SPeter Wemm #include "opt_bpf.h"
43fc0a61a4SKonstantin Belousov #include "opt_compat.h"
4405fc4164SBjoern A. Zeeb #include "opt_ddb.h"
455bb5f2c9SPeter Wemm #include "opt_netgraph.h"
46df8bae1dSRodney W. Grimes 
4795aab9ccSJohn-Mark Gurney #include <sys/types.h>
48df8bae1dSRodney W. Grimes #include <sys/param.h>
49e4b3229aSAlexander V. Chernikov #include <sys/lock.h>
50e4b3229aSAlexander V. Chernikov #include <sys/rwlock.h>
51df8bae1dSRodney W. Grimes #include <sys/systm.h>
52ce7609a4SBruce Evans #include <sys/conf.h>
53e76eee55SPoul-Henning Kamp #include <sys/fcntl.h>
54ebd8672cSBjoern A. Zeeb #include <sys/jail.h>
554d1d4912SBruce Evans #include <sys/malloc.h>
56df8bae1dSRodney W. Grimes #include <sys/mbuf.h>
57df8bae1dSRodney W. Grimes #include <sys/time.h>
58acd3428bSRobert Watson #include <sys/priv.h>
59df8bae1dSRodney W. Grimes #include <sys/proc.h>
600310c19fSBruce Evans #include <sys/signalvar.h>
61528f627fSBruce Evans #include <sys/filio.h>
62528f627fSBruce Evans #include <sys/sockio.h>
63528f627fSBruce Evans #include <sys/ttycom.h>
64e76eee55SPoul-Henning Kamp #include <sys/uio.h>
65*74549d4bSWojciech Macek #include <sys/sysent.h>
66df8bae1dSRodney W. Grimes 
6795aab9ccSJohn-Mark Gurney #include <sys/event.h>
6895aab9ccSJohn-Mark Gurney #include <sys/file.h>
69243ac7d8SPeter Wemm #include <sys/poll.h>
7095aab9ccSJohn-Mark Gurney #include <sys/proc.h>
71df8bae1dSRodney W. Grimes 
72df8bae1dSRodney W. Grimes #include <sys/socket.h>
73df8bae1dSRodney W. Grimes 
7405fc4164SBjoern A. Zeeb #ifdef DDB
7505fc4164SBjoern A. Zeeb #include <ddb/ddb.h>
7605fc4164SBjoern A. Zeeb #endif
7705fc4164SBjoern A. Zeeb 
78fba9235dSBruce Evans #include <net/if.h>
7976039bc8SGleb Smirnoff #include <net/if_var.h>
804fb3a820SAlexander V. Chernikov #include <net/if_dl.h>
81df8bae1dSRodney W. Grimes #include <net/bpf.h>
824d621040SChristian S.J. Peron #include <net/bpf_buffer.h>
83ae275efcSJung-uk Kim #ifdef BPF_JITTER
84ae275efcSJung-uk Kim #include <net/bpf_jitter.h>
85ae275efcSJung-uk Kim #endif
864d621040SChristian S.J. Peron #include <net/bpf_zerocopy.h>
87df8bae1dSRodney W. Grimes #include <net/bpfdesc.h>
884fb3a820SAlexander V. Chernikov #include <net/route.h>
89530c0060SRobert Watson #include <net/vnet.h>
90df8bae1dSRodney W. Grimes 
91df8bae1dSRodney W. Grimes #include <netinet/in.h>
92df8bae1dSRodney W. Grimes #include <netinet/if_ether.h>
93df8bae1dSRodney W. Grimes #include <sys/kernel.h>
94f708ef1bSPoul-Henning Kamp #include <sys/sysctl.h>
957b778b5eSEivind Eklund 
96246b5467SSam Leffler #include <net80211/ieee80211_freebsd.h>
97246b5467SSam Leffler 
98aed55708SRobert Watson #include <security/mac/mac_framework.h>
99aed55708SRobert Watson 
1004d621040SChristian S.J. Peron MALLOC_DEFINE(M_BPF, "BPF", "BPF data");
10187f6c662SJulian Elischer 
102b23cbbe6SMark Johnston struct bpf_if {
103b23cbbe6SMark Johnston #define	bif_next	bif_ext.bif_next
104b23cbbe6SMark Johnston #define	bif_dlist	bif_ext.bif_dlist
105b23cbbe6SMark Johnston 	struct bpf_if_ext bif_ext;	/* public members */
106b23cbbe6SMark Johnston 	u_int		bif_dlt;	/* link layer type */
107b23cbbe6SMark Johnston 	u_int		bif_hdrlen;	/* length of link header */
108b23cbbe6SMark Johnston 	struct ifnet	*bif_ifp;	/* corresponding interface */
109b23cbbe6SMark Johnston 	struct rwlock	bif_lock;	/* interface lock */
110b23cbbe6SMark Johnston 	LIST_HEAD(, bpf_d) bif_wlist;	/* writer-only list */
111b23cbbe6SMark Johnston 	int		bif_flags;	/* Interface flags */
1129ce40d32SKristof Provost 	struct bpf_if	**bif_bpf;	/* Pointer to pointer to us */
113b23cbbe6SMark Johnston };
114b23cbbe6SMark Johnston 
115b23cbbe6SMark Johnston CTASSERT(offsetof(struct bpf_if, bif_ext) == 0);
116b23cbbe6SMark Johnston 
1175bb5f2c9SPeter Wemm #if defined(DEV_BPF) || defined(NETGRAPH_BPF)
11853ac6efbSJulian Elischer 
119df8bae1dSRodney W. Grimes #define PRINET  26			/* interruptible */
120df8bae1dSRodney W. Grimes 
121547d94bdSJung-uk Kim #define	SIZEOF_BPF_HDR(type)	\
122547d94bdSJung-uk Kim     (offsetof(type, bh_hdrlen) + sizeof(((type *)0)->bh_hdrlen))
123547d94bdSJung-uk Kim 
124fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
125fc0a61a4SKonstantin Belousov #include <sys/mount.h>
126fc0a61a4SKonstantin Belousov #include <compat/freebsd32/freebsd32.h>
127fc0a61a4SKonstantin Belousov #define BPF_ALIGNMENT32 sizeof(int32_t)
128d9c9c81cSPedro F. Giffuni #define	BPF_WORDALIGN32(x) roundup2(x, BPF_ALIGNMENT32)
129fc0a61a4SKonstantin Belousov 
130547d94bdSJung-uk Kim #ifndef BURN_BRIDGES
131fc0a61a4SKonstantin Belousov /*
132fc0a61a4SKonstantin Belousov  * 32-bit version of structure prepended to each packet.  We use this header
133fc0a61a4SKonstantin Belousov  * instead of the standard one for 32-bit streams.  We mark the a stream as
134fc0a61a4SKonstantin Belousov  * 32-bit the first time we see a 32-bit compat ioctl request.
135fc0a61a4SKonstantin Belousov  */
136fc0a61a4SKonstantin Belousov struct bpf_hdr32 {
137fc0a61a4SKonstantin Belousov 	struct timeval32 bh_tstamp;	/* time stamp */
138fc0a61a4SKonstantin Belousov 	uint32_t	bh_caplen;	/* length of captured portion */
139fc0a61a4SKonstantin Belousov 	uint32_t	bh_datalen;	/* original length of packet */
140fc0a61a4SKonstantin Belousov 	uint16_t	bh_hdrlen;	/* length of bpf header (this struct
141fc0a61a4SKonstantin Belousov 					   plus alignment padding) */
142fc0a61a4SKonstantin Belousov };
143253a3814SLawrence Stewart #endif
144fc0a61a4SKonstantin Belousov 
145fc0a61a4SKonstantin Belousov struct bpf_program32 {
146fc0a61a4SKonstantin Belousov 	u_int bf_len;
147fc0a61a4SKonstantin Belousov 	uint32_t bf_insns;
148fc0a61a4SKonstantin Belousov };
149fc0a61a4SKonstantin Belousov 
150fc0a61a4SKonstantin Belousov struct bpf_dltlist32 {
151fc0a61a4SKonstantin Belousov 	u_int	bfl_len;
152fc0a61a4SKonstantin Belousov 	u_int	bfl_list;
153fc0a61a4SKonstantin Belousov };
154fc0a61a4SKonstantin Belousov 
155fc0a61a4SKonstantin Belousov #define	BIOCSETF32	_IOW('B', 103, struct bpf_program32)
156fc0a61a4SKonstantin Belousov #define	BIOCSRTIMEOUT32	_IOW('B', 109, struct timeval32)
157fc0a61a4SKonstantin Belousov #define	BIOCGRTIMEOUT32	_IOR('B', 110, struct timeval32)
158fc0a61a4SKonstantin Belousov #define	BIOCGDLTLIST32	_IOWR('B', 121, struct bpf_dltlist32)
159fc0a61a4SKonstantin Belousov #define	BIOCSETWF32	_IOW('B', 123, struct bpf_program32)
160fc0a61a4SKonstantin Belousov #define	BIOCSETFNR32	_IOW('B', 130, struct bpf_program32)
161253a3814SLawrence Stewart #endif
162fc0a61a4SKonstantin Belousov 
163df8bae1dSRodney W. Grimes /*
164d1a67300SRobert Watson  * bpf_iflist is a list of BPF interface structures, each corresponding to a
165d1a67300SRobert Watson  * specific DLT.  The same network interface might have several BPF interface
166d1a67300SRobert Watson  * structures registered by different layers in the stack (i.e., 802.11
167d1a67300SRobert Watson  * frames, ethernet frames, etc).
168df8bae1dSRodney W. Grimes  */
169f079a0faSAlexander V. Chernikov static LIST_HEAD(, bpf_if)	bpf_iflist, bpf_freelist;
170e7bb21b3SJonathan Lemon static struct mtx	bpf_mtx;		/* bpf global lock */
17169f7644bSChristian S.J. Peron static int		bpf_bpfd_cnt;
172df8bae1dSRodney W. Grimes 
17319ba8395SChristian S.J. Peron static void	bpf_attachd(struct bpf_d *, struct bpf_if *);
17419ba8395SChristian S.J. Peron static void	bpf_detachd(struct bpf_d *);
1756c74ff0eSAlexander V. Chernikov static void	bpf_detachd_locked(struct bpf_d *);
176929ddbbbSAlfred Perlstein static void	bpf_freed(struct bpf_d *);
177cb44b6dfSAndrew Thompson static int	bpf_movein(struct uio *, int, struct ifnet *, struct mbuf **,
1784fb3a820SAlexander V. Chernikov 		    struct sockaddr *, int *, struct bpf_d *);
179929ddbbbSAlfred Perlstein static int	bpf_setif(struct bpf_d *, struct ifreq *);
180929ddbbbSAlfred Perlstein static void	bpf_timed_out(void *);
181e7bb21b3SJonathan Lemon static __inline void
182929ddbbbSAlfred Perlstein 		bpf_wakeup(struct bpf_d *);
1834d621040SChristian S.J. Peron static void	catchpacket(struct bpf_d *, u_char *, u_int, u_int,
1844d621040SChristian S.J. Peron 		    void (*)(struct bpf_d *, caddr_t, u_int, void *, u_int),
185547d94bdSJung-uk Kim 		    struct bintime *);
186929ddbbbSAlfred Perlstein static void	reset_d(struct bpf_d *);
18793e39f0bSChristian S.J. Peron static int	bpf_setf(struct bpf_d *, struct bpf_program *, u_long cmd);
1888eab61f3SSam Leffler static int	bpf_getdltlist(struct bpf_d *, struct bpf_dltlist *);
1898eab61f3SSam Leffler static int	bpf_setdlt(struct bpf_d *, u_int);
19095aab9ccSJohn-Mark Gurney static void	filt_bpfdetach(struct knote *);
19195aab9ccSJohn-Mark Gurney static int	filt_bpfread(struct knote *, long);
192a3272e3cSChristian S.J. Peron static void	bpf_drvinit(void *);
19369f7644bSChristian S.J. Peron static int	bpf_stats_sysctl(SYSCTL_HANDLER_ARGS);
19469f7644bSChristian S.J. Peron 
19569f7644bSChristian S.J. Peron SYSCTL_NODE(_net, OID_AUTO, bpf, CTLFLAG_RW, 0, "bpf sysctl");
19612dc9582SJung-uk Kim int bpf_maxinsns = BPF_MAXINSNS;
19769f7644bSChristian S.J. Peron SYSCTL_INT(_net_bpf, OID_AUTO, maxinsns, CTLFLAG_RW,
19869f7644bSChristian S.J. Peron     &bpf_maxinsns, 0, "Maximum bpf program instructions");
199ffeeb924SChristian S.J. Peron static int bpf_zerocopy_enable = 0;
2004d621040SChristian S.J. Peron SYSCTL_INT(_net_bpf, OID_AUTO, zerocopy_enable, CTLFLAG_RW,
2014d621040SChristian S.J. Peron     &bpf_zerocopy_enable, 0, "Enable new zero-copy BPF buffer sessions");
2026472ac3dSEd Schouten static SYSCTL_NODE(_net_bpf, OID_AUTO, stats, CTLFLAG_MPSAFE | CTLFLAG_RW,
20369f7644bSChristian S.J. Peron     bpf_stats_sysctl, "bpf statistics portal");
204df8bae1dSRodney W. Grimes 
20551ec1eb7SAlexander V. Chernikov static VNET_DEFINE(int, bpf_optimize_writers) = 0;
20651ec1eb7SAlexander V. Chernikov #define	V_bpf_optimize_writers VNET(bpf_optimize_writers)
2076df8a710SGleb Smirnoff SYSCTL_INT(_net_bpf, OID_AUTO, optimize_writers, CTLFLAG_VNET | CTLFLAG_RW,
2086df8a710SGleb Smirnoff     &VNET_NAME(bpf_optimize_writers), 0,
20951ec1eb7SAlexander V. Chernikov     "Do not send packets until BPF program is set");
21051ec1eb7SAlexander V. Chernikov 
21187f6c662SJulian Elischer static	d_open_t	bpfopen;
21287f6c662SJulian Elischer static	d_read_t	bpfread;
21387f6c662SJulian Elischer static	d_write_t	bpfwrite;
21487f6c662SJulian Elischer static	d_ioctl_t	bpfioctl;
215243ac7d8SPeter Wemm static	d_poll_t	bpfpoll;
21695aab9ccSJohn-Mark Gurney static	d_kqfilter_t	bpfkqfilter;
21787f6c662SJulian Elischer 
2184e2f199eSPoul-Henning Kamp static struct cdevsw bpf_cdevsw = {
219dc08ffecSPoul-Henning Kamp 	.d_version =	D_VERSION,
2207ac40f5fSPoul-Henning Kamp 	.d_open =	bpfopen,
2217ac40f5fSPoul-Henning Kamp 	.d_read =	bpfread,
2227ac40f5fSPoul-Henning Kamp 	.d_write =	bpfwrite,
2237ac40f5fSPoul-Henning Kamp 	.d_ioctl =	bpfioctl,
2247ac40f5fSPoul-Henning Kamp 	.d_poll =	bpfpoll,
2257ac40f5fSPoul-Henning Kamp 	.d_name =	"bpf",
22695aab9ccSJohn-Mark Gurney 	.d_kqfilter =	bpfkqfilter,
2274e2f199eSPoul-Henning Kamp };
22887f6c662SJulian Elischer 
229e76d823bSRobert Watson static struct filterops bpfread_filtops = {
230e76d823bSRobert Watson 	.f_isfd = 1,
231e76d823bSRobert Watson 	.f_detach = filt_bpfdetach,
232e76d823bSRobert Watson 	.f_event = filt_bpfread,
233e76d823bSRobert Watson };
23487f6c662SJulian Elischer 
235afa85850SAlexander V. Chernikov eventhandler_tag	bpf_ifdetach_cookie = NULL;
236afa85850SAlexander V. Chernikov 
2374d621040SChristian S.J. Peron /*
2386c74ff0eSAlexander V. Chernikov  * LOCKING MODEL USED BY BPF:
2396c74ff0eSAlexander V. Chernikov  * Locks:
2406c74ff0eSAlexander V. Chernikov  * 1) global lock (BPF_LOCK). Mutex, used to protect interface addition/removal,
2416c74ff0eSAlexander V. Chernikov  * some global counters and every bpf_if reference.
2426c74ff0eSAlexander V. Chernikov  * 2) Interface lock. Rwlock, used to protect list of BPF descriptors and their filters.
243afa85850SAlexander V. Chernikov  * 3) Descriptor lock. Mutex, used to protect BPF buffers and various structure fields
2446c74ff0eSAlexander V. Chernikov  *   used by bpf_mtap code.
2456c74ff0eSAlexander V. Chernikov  *
2466c74ff0eSAlexander V. Chernikov  * Lock order:
2476c74ff0eSAlexander V. Chernikov  *
2486c74ff0eSAlexander V. Chernikov  * Global lock, interface lock, descriptor lock
2496c74ff0eSAlexander V. Chernikov  *
2506c74ff0eSAlexander V. Chernikov  * We have to acquire interface lock before descriptor main lock due to BPF_MTAP[2]
2516c74ff0eSAlexander V. Chernikov  * working model. In many places (like bpf_detachd) we start with BPF descriptor
2526c74ff0eSAlexander V. Chernikov  * (and we need to at least rlock it to get reliable interface pointer). This
2536c74ff0eSAlexander V. Chernikov  * gives us potential LOR. As a result, we use global lock to protect from bpf_if
2546c74ff0eSAlexander V. Chernikov  * change in every such place.
2556c74ff0eSAlexander V. Chernikov  *
2566c74ff0eSAlexander V. Chernikov  * Changing d->bd_bif is protected by 1) global lock, 2) interface lock and
2576c74ff0eSAlexander V. Chernikov  * 3) descriptor main wlock.
2586c74ff0eSAlexander V. Chernikov  * Reading bd_bif can be protected by any of these locks, typically global lock.
2596c74ff0eSAlexander V. Chernikov  *
2606c74ff0eSAlexander V. Chernikov  * Changing read/write BPF filter is protected by the same three locks,
2616c74ff0eSAlexander V. Chernikov  * the same applies for reading.
2626c74ff0eSAlexander V. Chernikov  *
2636c74ff0eSAlexander V. Chernikov  * Sleeping in global lock is not allowed due to bpfdetach() using it.
2646c74ff0eSAlexander V. Chernikov  */
2656c74ff0eSAlexander V. Chernikov 
2666c74ff0eSAlexander V. Chernikov /*
2674d621040SChristian S.J. Peron  * Wrapper functions for various buffering methods.  If the set of buffer
2684d621040SChristian S.J. Peron  * modes expands, we will probably want to introduce a switch data structure
2694d621040SChristian S.J. Peron  * similar to protosw, et.
2704d621040SChristian S.J. Peron  */
2714d621040SChristian S.J. Peron static void
2724d621040SChristian S.J. Peron bpf_append_bytes(struct bpf_d *d, caddr_t buf, u_int offset, void *src,
2734d621040SChristian S.J. Peron     u_int len)
2744d621040SChristian S.J. Peron {
2754d621040SChristian S.J. Peron 
276afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
2774d621040SChristian S.J. Peron 
2784d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
2794d621040SChristian S.J. Peron 	case BPF_BUFMODE_BUFFER:
2804d621040SChristian S.J. Peron 		return (bpf_buffer_append_bytes(d, buf, offset, src, len));
2814d621040SChristian S.J. Peron 
2824d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
2834d621040SChristian S.J. Peron 		d->bd_zcopy++;
2844d621040SChristian S.J. Peron 		return (bpf_zerocopy_append_bytes(d, buf, offset, src, len));
2854d621040SChristian S.J. Peron 
2864d621040SChristian S.J. Peron 	default:
2874d621040SChristian S.J. Peron 		panic("bpf_buf_append_bytes");
2884d621040SChristian S.J. Peron 	}
2894d621040SChristian S.J. Peron }
2904d621040SChristian S.J. Peron 
2914d621040SChristian S.J. Peron static void
2924d621040SChristian S.J. Peron bpf_append_mbuf(struct bpf_d *d, caddr_t buf, u_int offset, void *src,
2934d621040SChristian S.J. Peron     u_int len)
2944d621040SChristian S.J. Peron {
2954d621040SChristian S.J. Peron 
296afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
2974d621040SChristian S.J. Peron 
2984d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
2994d621040SChristian S.J. Peron 	case BPF_BUFMODE_BUFFER:
3004d621040SChristian S.J. Peron 		return (bpf_buffer_append_mbuf(d, buf, offset, src, len));
3014d621040SChristian S.J. Peron 
3024d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
3034d621040SChristian S.J. Peron 		d->bd_zcopy++;
3044d621040SChristian S.J. Peron 		return (bpf_zerocopy_append_mbuf(d, buf, offset, src, len));
3054d621040SChristian S.J. Peron 
3064d621040SChristian S.J. Peron 	default:
3074d621040SChristian S.J. Peron 		panic("bpf_buf_append_mbuf");
3084d621040SChristian S.J. Peron 	}
3094d621040SChristian S.J. Peron }
3104d621040SChristian S.J. Peron 
3114d621040SChristian S.J. Peron /*
31229f612ecSChristian S.J. Peron  * This function gets called when the free buffer is re-assigned.
31329f612ecSChristian S.J. Peron  */
31429f612ecSChristian S.J. Peron static void
31529f612ecSChristian S.J. Peron bpf_buf_reclaimed(struct bpf_d *d)
31629f612ecSChristian S.J. Peron {
31729f612ecSChristian S.J. Peron 
318afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
31929f612ecSChristian S.J. Peron 
32029f612ecSChristian S.J. Peron 	switch (d->bd_bufmode) {
32129f612ecSChristian S.J. Peron 	case BPF_BUFMODE_BUFFER:
32229f612ecSChristian S.J. Peron 		return;
32329f612ecSChristian S.J. Peron 
32429f612ecSChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
32529f612ecSChristian S.J. Peron 		bpf_zerocopy_buf_reclaimed(d);
32629f612ecSChristian S.J. Peron 		return;
32729f612ecSChristian S.J. Peron 
32829f612ecSChristian S.J. Peron 	default:
32929f612ecSChristian S.J. Peron 		panic("bpf_buf_reclaimed");
33029f612ecSChristian S.J. Peron 	}
33129f612ecSChristian S.J. Peron }
33229f612ecSChristian S.J. Peron 
33329f612ecSChristian S.J. Peron /*
3344d621040SChristian S.J. Peron  * If the buffer mechanism has a way to decide that a held buffer can be made
3354d621040SChristian S.J. Peron  * free, then it is exposed via the bpf_canfreebuf() interface.  (1) is
3364d621040SChristian S.J. Peron  * returned if the buffer can be discarded, (0) is returned if it cannot.
3374d621040SChristian S.J. Peron  */
3384d621040SChristian S.J. Peron static int
3394d621040SChristian S.J. Peron bpf_canfreebuf(struct bpf_d *d)
3404d621040SChristian S.J. Peron {
3414d621040SChristian S.J. Peron 
3424d621040SChristian S.J. Peron 	BPFD_LOCK_ASSERT(d);
3434d621040SChristian S.J. Peron 
3444d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
3454d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
3464d621040SChristian S.J. Peron 		return (bpf_zerocopy_canfreebuf(d));
3474d621040SChristian S.J. Peron 	}
3484d621040SChristian S.J. Peron 	return (0);
3494d621040SChristian S.J. Peron }
3504d621040SChristian S.J. Peron 
351a7a91e65SRobert Watson /*
352a7a91e65SRobert Watson  * Allow the buffer model to indicate that the current store buffer is
353a7a91e65SRobert Watson  * immutable, regardless of the appearance of space.  Return (1) if the
354a7a91e65SRobert Watson  * buffer is writable, and (0) if not.
355a7a91e65SRobert Watson  */
356a7a91e65SRobert Watson static int
357a7a91e65SRobert Watson bpf_canwritebuf(struct bpf_d *d)
358a7a91e65SRobert Watson {
359a7a91e65SRobert Watson 	BPFD_LOCK_ASSERT(d);
360a7a91e65SRobert Watson 
361a7a91e65SRobert Watson 	switch (d->bd_bufmode) {
362a7a91e65SRobert Watson 	case BPF_BUFMODE_ZBUF:
363a7a91e65SRobert Watson 		return (bpf_zerocopy_canwritebuf(d));
364a7a91e65SRobert Watson 	}
365a7a91e65SRobert Watson 	return (1);
366a7a91e65SRobert Watson }
367a7a91e65SRobert Watson 
368a7a91e65SRobert Watson /*
369a7a91e65SRobert Watson  * Notify buffer model that an attempt to write to the store buffer has
370a7a91e65SRobert Watson  * resulted in a dropped packet, in which case the buffer may be considered
371a7a91e65SRobert Watson  * full.
372a7a91e65SRobert Watson  */
373a7a91e65SRobert Watson static void
374a7a91e65SRobert Watson bpf_buffull(struct bpf_d *d)
375a7a91e65SRobert Watson {
376a7a91e65SRobert Watson 
377afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
378a7a91e65SRobert Watson 
379a7a91e65SRobert Watson 	switch (d->bd_bufmode) {
380a7a91e65SRobert Watson 	case BPF_BUFMODE_ZBUF:
381a7a91e65SRobert Watson 		bpf_zerocopy_buffull(d);
382a7a91e65SRobert Watson 		break;
383a7a91e65SRobert Watson 	}
384a7a91e65SRobert Watson }
385a7a91e65SRobert Watson 
386a7a91e65SRobert Watson /*
387a7a91e65SRobert Watson  * Notify the buffer model that a buffer has moved into the hold position.
388a7a91e65SRobert Watson  */
3894d621040SChristian S.J. Peron void
3904d621040SChristian S.J. Peron bpf_bufheld(struct bpf_d *d)
3914d621040SChristian S.J. Peron {
3924d621040SChristian S.J. Peron 
393afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
3944d621040SChristian S.J. Peron 
3954d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
3964d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
3974d621040SChristian S.J. Peron 		bpf_zerocopy_bufheld(d);
3984d621040SChristian S.J. Peron 		break;
3994d621040SChristian S.J. Peron 	}
4004d621040SChristian S.J. Peron }
4014d621040SChristian S.J. Peron 
4024d621040SChristian S.J. Peron static void
4034d621040SChristian S.J. Peron bpf_free(struct bpf_d *d)
4044d621040SChristian S.J. Peron {
4054d621040SChristian S.J. Peron 
4064d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
4074d621040SChristian S.J. Peron 	case BPF_BUFMODE_BUFFER:
4084d621040SChristian S.J. Peron 		return (bpf_buffer_free(d));
4094d621040SChristian S.J. Peron 
4104d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
4114d621040SChristian S.J. Peron 		return (bpf_zerocopy_free(d));
4124d621040SChristian S.J. Peron 
4134d621040SChristian S.J. Peron 	default:
4144d621040SChristian S.J. Peron 		panic("bpf_buf_free");
4154d621040SChristian S.J. Peron 	}
4164d621040SChristian S.J. Peron }
4174d621040SChristian S.J. Peron 
4184d621040SChristian S.J. Peron static int
4194d621040SChristian S.J. Peron bpf_uiomove(struct bpf_d *d, caddr_t buf, u_int len, struct uio *uio)
4204d621040SChristian S.J. Peron {
4214d621040SChristian S.J. Peron 
4224d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_BUFFER)
4234d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
4244d621040SChristian S.J. Peron 	return (bpf_buffer_uiomove(d, buf, len, uio));
4254d621040SChristian S.J. Peron }
4264d621040SChristian S.J. Peron 
4274d621040SChristian S.J. Peron static int
4284d621040SChristian S.J. Peron bpf_ioctl_sblen(struct bpf_d *d, u_int *i)
4294d621040SChristian S.J. Peron {
4304d621040SChristian S.J. Peron 
4314d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_BUFFER)
4324d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
4334d621040SChristian S.J. Peron 	return (bpf_buffer_ioctl_sblen(d, i));
4344d621040SChristian S.J. Peron }
4354d621040SChristian S.J. Peron 
4364d621040SChristian S.J. Peron static int
4374d621040SChristian S.J. Peron bpf_ioctl_getzmax(struct thread *td, struct bpf_d *d, size_t *i)
4384d621040SChristian S.J. Peron {
4394d621040SChristian S.J. Peron 
4404d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_ZBUF)
4414d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
4424d621040SChristian S.J. Peron 	return (bpf_zerocopy_ioctl_getzmax(td, d, i));
4434d621040SChristian S.J. Peron }
4444d621040SChristian S.J. Peron 
4454d621040SChristian S.J. Peron static int
4464d621040SChristian S.J. Peron bpf_ioctl_rotzbuf(struct thread *td, struct bpf_d *d, struct bpf_zbuf *bz)
4474d621040SChristian S.J. Peron {
4484d621040SChristian S.J. Peron 
4494d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_ZBUF)
4504d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
4514d621040SChristian S.J. Peron 	return (bpf_zerocopy_ioctl_rotzbuf(td, d, bz));
4524d621040SChristian S.J. Peron }
4534d621040SChristian S.J. Peron 
4544d621040SChristian S.J. Peron static int
4554d621040SChristian S.J. Peron bpf_ioctl_setzbuf(struct thread *td, struct bpf_d *d, struct bpf_zbuf *bz)
4564d621040SChristian S.J. Peron {
4574d621040SChristian S.J. Peron 
4584d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_ZBUF)
4594d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
4604d621040SChristian S.J. Peron 	return (bpf_zerocopy_ioctl_setzbuf(td, d, bz));
4614d621040SChristian S.J. Peron }
4624d621040SChristian S.J. Peron 
4634d621040SChristian S.J. Peron /*
4644d621040SChristian S.J. Peron  * General BPF functions.
4654d621040SChristian S.J. Peron  */
466df8bae1dSRodney W. Grimes static int
467cb44b6dfSAndrew Thompson bpf_movein(struct uio *uio, int linktype, struct ifnet *ifp, struct mbuf **mp,
4684fb3a820SAlexander V. Chernikov     struct sockaddr *sockp, int *hdrlen, struct bpf_d *d)
469df8bae1dSRodney W. Grimes {
470246b5467SSam Leffler 	const struct ieee80211_bpf_params *p;
471cb44b6dfSAndrew Thompson 	struct ether_header *eh;
472df8bae1dSRodney W. Grimes 	struct mbuf *m;
473df8bae1dSRodney W. Grimes 	int error;
474df8bae1dSRodney W. Grimes 	int len;
475df8bae1dSRodney W. Grimes 	int hlen;
47693e39f0bSChristian S.J. Peron 	int slen;
477df8bae1dSRodney W. Grimes 
478df8bae1dSRodney W. Grimes 	/*
479df8bae1dSRodney W. Grimes 	 * Build a sockaddr based on the data link layer type.
480df8bae1dSRodney W. Grimes 	 * We do this at this level because the ethernet header
481df8bae1dSRodney W. Grimes 	 * is copied directly into the data field of the sockaddr.
482df8bae1dSRodney W. Grimes 	 * In the case of SLIP, there is no header and the packet
483df8bae1dSRodney W. Grimes 	 * is forwarded as is.
484df8bae1dSRodney W. Grimes 	 * Also, we are careful to leave room at the front of the mbuf
485df8bae1dSRodney W. Grimes 	 * for the link level header.
486df8bae1dSRodney W. Grimes 	 */
487df8bae1dSRodney W. Grimes 	switch (linktype) {
488df8bae1dSRodney W. Grimes 
489df8bae1dSRodney W. Grimes 	case DLT_SLIP:
490df8bae1dSRodney W. Grimes 		sockp->sa_family = AF_INET;
491df8bae1dSRodney W. Grimes 		hlen = 0;
492df8bae1dSRodney W. Grimes 		break;
493df8bae1dSRodney W. Grimes 
494df8bae1dSRodney W. Grimes 	case DLT_EN10MB:
495df8bae1dSRodney W. Grimes 		sockp->sa_family = AF_UNSPEC;
496df8bae1dSRodney W. Grimes 		/* XXX Would MAXLINKHDR be better? */
497797f247bSMatthew N. Dodd 		hlen = ETHER_HDR_LEN;
498df8bae1dSRodney W. Grimes 		break;
499df8bae1dSRodney W. Grimes 
500df8bae1dSRodney W. Grimes 	case DLT_FDDI:
501d41f24e7SDavid Greenman 		sockp->sa_family = AF_IMPLINK;
502d41f24e7SDavid Greenman 		hlen = 0;
503df8bae1dSRodney W. Grimes 		break;
504df8bae1dSRodney W. Grimes 
50522f05c43SAndrey A. Chernov 	case DLT_RAW:
506df8bae1dSRodney W. Grimes 		sockp->sa_family = AF_UNSPEC;
507df8bae1dSRodney W. Grimes 		hlen = 0;
508df8bae1dSRodney W. Grimes 		break;
509df8bae1dSRodney W. Grimes 
51001399f34SDavid Malone 	case DLT_NULL:
51101399f34SDavid Malone 		/*
51201399f34SDavid Malone 		 * null interface types require a 4 byte pseudo header which
51301399f34SDavid Malone 		 * corresponds to the address family of the packet.
51401399f34SDavid Malone 		 */
51501399f34SDavid Malone 		sockp->sa_family = AF_UNSPEC;
51601399f34SDavid Malone 		hlen = 4;
51701399f34SDavid Malone 		break;
51801399f34SDavid Malone 
5194f53e3ccSKenjiro Cho 	case DLT_ATM_RFC1483:
5204f53e3ccSKenjiro Cho 		/*
5214f53e3ccSKenjiro Cho 		 * en atm driver requires 4-byte atm pseudo header.
5224f53e3ccSKenjiro Cho 		 * though it isn't standard, vpi:vci needs to be
5234f53e3ccSKenjiro Cho 		 * specified anyway.
5244f53e3ccSKenjiro Cho 		 */
5254f53e3ccSKenjiro Cho 		sockp->sa_family = AF_UNSPEC;
5264f53e3ccSKenjiro Cho 		hlen = 12;	/* XXX 4(ATM_PH) + 3(LLC) + 5(SNAP) */
5274f53e3ccSKenjiro Cho 		break;
5284f53e3ccSKenjiro Cho 
52930fa52a6SBrian Somers 	case DLT_PPP:
53030fa52a6SBrian Somers 		sockp->sa_family = AF_UNSPEC;
53130fa52a6SBrian Somers 		hlen = 4;	/* This should match PPP_HDRLEN */
53230fa52a6SBrian Somers 		break;
53330fa52a6SBrian Somers 
534246b5467SSam Leffler 	case DLT_IEEE802_11:		/* IEEE 802.11 wireless */
535246b5467SSam Leffler 		sockp->sa_family = AF_IEEE80211;
536246b5467SSam Leffler 		hlen = 0;
537246b5467SSam Leffler 		break;
538246b5467SSam Leffler 
539246b5467SSam Leffler 	case DLT_IEEE802_11_RADIO:	/* IEEE 802.11 wireless w/ phy params */
540246b5467SSam Leffler 		sockp->sa_family = AF_IEEE80211;
541246b5467SSam Leffler 		sockp->sa_len = 12;	/* XXX != 0 */
542246b5467SSam Leffler 		hlen = sizeof(struct ieee80211_bpf_params);
543246b5467SSam Leffler 		break;
544246b5467SSam Leffler 
545df8bae1dSRodney W. Grimes 	default:
546df8bae1dSRodney W. Grimes 		return (EIO);
547df8bae1dSRodney W. Grimes 	}
548df8bae1dSRodney W. Grimes 
549df8bae1dSRodney W. Grimes 	len = uio->uio_resid;
550ed63043bSGleb Smirnoff 	if (len < hlen || len - hlen > ifp->if_mtu)
55101399f34SDavid Malone 		return (EMSGSIZE);
55201399f34SDavid Malone 
55341a7572bSGleb Smirnoff 	m = m_get2(len, M_WAITOK, MT_DATA, M_PKTHDR);
554ed63043bSGleb Smirnoff 	if (m == NULL)
555df8bae1dSRodney W. Grimes 		return (EIO);
556963e4c2aSGarrett Wollman 	m->m_pkthdr.len = m->m_len = len;
557df8bae1dSRodney W. Grimes 	*mp = m;
55824a229f4SSam Leffler 
55993e39f0bSChristian S.J. Peron 	error = uiomove(mtod(m, u_char *), len, uio);
56093e39f0bSChristian S.J. Peron 	if (error)
56193e39f0bSChristian S.J. Peron 		goto bad;
56293e39f0bSChristian S.J. Peron 
5634fb3a820SAlexander V. Chernikov 	slen = bpf_filter(d->bd_wfilter, mtod(m, u_char *), len, len);
56493e39f0bSChristian S.J. Peron 	if (slen == 0) {
56593e39f0bSChristian S.J. Peron 		error = EPERM;
56693e39f0bSChristian S.J. Peron 		goto bad;
56793e39f0bSChristian S.J. Peron 	}
56893e39f0bSChristian S.J. Peron 
569cb44b6dfSAndrew Thompson 	/* Check for multicast destination */
570cb44b6dfSAndrew Thompson 	switch (linktype) {
571cb44b6dfSAndrew Thompson 	case DLT_EN10MB:
572cb44b6dfSAndrew Thompson 		eh = mtod(m, struct ether_header *);
573cb44b6dfSAndrew Thompson 		if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
574cb44b6dfSAndrew Thompson 			if (bcmp(ifp->if_broadcastaddr, eh->ether_dhost,
575cb44b6dfSAndrew Thompson 			    ETHER_ADDR_LEN) == 0)
576cb44b6dfSAndrew Thompson 				m->m_flags |= M_BCAST;
577cb44b6dfSAndrew Thompson 			else
578cb44b6dfSAndrew Thompson 				m->m_flags |= M_MCAST;
579cb44b6dfSAndrew Thompson 		}
5804fb3a820SAlexander V. Chernikov 		if (d->bd_hdrcmplt == 0) {
5814fb3a820SAlexander V. Chernikov 			memcpy(eh->ether_shost, IF_LLADDR(ifp),
5824fb3a820SAlexander V. Chernikov 			    sizeof(eh->ether_shost));
5834fb3a820SAlexander V. Chernikov 		}
584cb44b6dfSAndrew Thompson 		break;
585cb44b6dfSAndrew Thompson 	}
586cb44b6dfSAndrew Thompson 
587df8bae1dSRodney W. Grimes 	/*
58893e39f0bSChristian S.J. Peron 	 * Make room for link header, and copy it to sockaddr
589df8bae1dSRodney W. Grimes 	 */
590df8bae1dSRodney W. Grimes 	if (hlen != 0) {
591246b5467SSam Leffler 		if (sockp->sa_family == AF_IEEE80211) {
592246b5467SSam Leffler 			/*
593246b5467SSam Leffler 			 * Collect true length from the parameter header
594246b5467SSam Leffler 			 * NB: sockp is known to be zero'd so if we do a
595246b5467SSam Leffler 			 *     short copy unspecified parameters will be
596246b5467SSam Leffler 			 *     zero.
597246b5467SSam Leffler 			 * NB: packet may not be aligned after stripping
598246b5467SSam Leffler 			 *     bpf params
599246b5467SSam Leffler 			 * XXX check ibp_vers
600246b5467SSam Leffler 			 */
601246b5467SSam Leffler 			p = mtod(m, const struct ieee80211_bpf_params *);
602246b5467SSam Leffler 			hlen = p->ibp_len;
603246b5467SSam Leffler 			if (hlen > sizeof(sockp->sa_data)) {
604246b5467SSam Leffler 				error = EINVAL;
605246b5467SSam Leffler 				goto bad;
606246b5467SSam Leffler 			}
607246b5467SSam Leffler 		}
608a09968c4SAdrian Chadd 		bcopy(mtod(m, const void *), sockp->sa_data, hlen);
609df8bae1dSRodney W. Grimes 	}
610560a54e1SJung-uk Kim 	*hdrlen = hlen;
61193e39f0bSChristian S.J. Peron 
612df8bae1dSRodney W. Grimes 	return (0);
613df8bae1dSRodney W. Grimes bad:
614df8bae1dSRodney W. Grimes 	m_freem(m);
615df8bae1dSRodney W. Grimes 	return (error);
616df8bae1dSRodney W. Grimes }
617df8bae1dSRodney W. Grimes 
618df8bae1dSRodney W. Grimes /*
619df8bae1dSRodney W. Grimes  * Attach file to the bpf interface, i.e. make d listen on bp.
620df8bae1dSRodney W. Grimes  */
621df8bae1dSRodney W. Grimes static void
62219ba8395SChristian S.J. Peron bpf_attachd(struct bpf_d *d, struct bpf_if *bp)
623df8bae1dSRodney W. Grimes {
6246c74ff0eSAlexander V. Chernikov 	int op_w;
6256c74ff0eSAlexander V. Chernikov 
6266c74ff0eSAlexander V. Chernikov 	BPF_LOCK_ASSERT();
6276c74ff0eSAlexander V. Chernikov 
6286c74ff0eSAlexander V. Chernikov 	/*
6296c74ff0eSAlexander V. Chernikov 	 * Save sysctl value to protect from sysctl change
6306c74ff0eSAlexander V. Chernikov 	 * between reads
6316c74ff0eSAlexander V. Chernikov 	 */
63271448753SAlexander Motin 	op_w = V_bpf_optimize_writers || d->bd_writer;
6336c74ff0eSAlexander V. Chernikov 
6346c74ff0eSAlexander V. Chernikov 	if (d->bd_bif != NULL)
6356c74ff0eSAlexander V. Chernikov 		bpf_detachd_locked(d);
636df8bae1dSRodney W. Grimes 	/*
63751ec1eb7SAlexander V. Chernikov 	 * Point d at bp, and add d to the interface's list.
638f87e372eSLuiz Otavio O Souza 	 * Since there are many applications using BPF for
63951ec1eb7SAlexander V. Chernikov 	 * sending raw packets only (dhcpd, cdpd are good examples)
64051ec1eb7SAlexander V. Chernikov 	 * we can delay adding d to the list of active listeners until
64151ec1eb7SAlexander V. Chernikov 	 * some filter is configured.
642df8bae1dSRodney W. Grimes 	 */
64351ec1eb7SAlexander V. Chernikov 
64451ec1eb7SAlexander V. Chernikov 	BPFIF_WLOCK(bp);
645afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
64651ec1eb7SAlexander V. Chernikov 
6476c74ff0eSAlexander V. Chernikov 	d->bd_bif = bp;
6486c74ff0eSAlexander V. Chernikov 
6496c74ff0eSAlexander V. Chernikov 	if (op_w != 0) {
65051ec1eb7SAlexander V. Chernikov 		/* Add to writers-only list */
65151ec1eb7SAlexander V. Chernikov 		LIST_INSERT_HEAD(&bp->bif_wlist, d, bd_next);
65251ec1eb7SAlexander V. Chernikov 		/*
65351ec1eb7SAlexander V. Chernikov 		 * We decrement bd_writer on every filter set operation.
65451ec1eb7SAlexander V. Chernikov 		 * First BIOCSETF is done by pcap_open_live() to set up
65551ec1eb7SAlexander V. Chernikov 		 * snap length. After that appliation usually sets its own filter
65651ec1eb7SAlexander V. Chernikov 		 */
65751ec1eb7SAlexander V. Chernikov 		d->bd_writer = 2;
65851ec1eb7SAlexander V. Chernikov 	} else
6594a3feeaaSRobert Watson 		LIST_INSERT_HEAD(&bp->bif_dlist, d, bd_next);
660df8bae1dSRodney W. Grimes 
661afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
662e4b3229aSAlexander V. Chernikov 	BPFIF_WUNLOCK(bp);
663b743c310SSam Leffler 
66451ec1eb7SAlexander V. Chernikov 	bpf_bpfd_cnt++;
66551ec1eb7SAlexander V. Chernikov 
66651ec1eb7SAlexander V. Chernikov 	CTR3(KTR_NET, "%s: bpf_attach called by pid %d, adding to %s list",
66751ec1eb7SAlexander V. Chernikov 	    __func__, d->bd_pid, d->bd_writer ? "writer" : "active");
66851ec1eb7SAlexander V. Chernikov 
6696c74ff0eSAlexander V. Chernikov 	if (op_w == 0)
67051ec1eb7SAlexander V. Chernikov 		EVENTHANDLER_INVOKE(bpf_track, bp->bif_ifp, bp->bif_dlt, 1);
67151ec1eb7SAlexander V. Chernikov }
67251ec1eb7SAlexander V. Chernikov 
67351ec1eb7SAlexander V. Chernikov /*
674402000ffSAlexander V. Chernikov  * Check if we need to upgrade our descriptor @d from write-only mode.
675402000ffSAlexander V. Chernikov  */
676402000ffSAlexander V. Chernikov static int
677402000ffSAlexander V. Chernikov bpf_check_upgrade(u_long cmd, struct bpf_d *d, struct bpf_insn *fcode, int flen)
678402000ffSAlexander V. Chernikov {
679402000ffSAlexander V. Chernikov 	int is_snap, need_upgrade;
680402000ffSAlexander V. Chernikov 
681402000ffSAlexander V. Chernikov 	/*
682402000ffSAlexander V. Chernikov 	 * Check if we've already upgraded or new filter is empty.
683402000ffSAlexander V. Chernikov 	 */
684402000ffSAlexander V. Chernikov 	if (d->bd_writer == 0 || fcode == NULL)
685402000ffSAlexander V. Chernikov 		return (0);
686402000ffSAlexander V. Chernikov 
687402000ffSAlexander V. Chernikov 	need_upgrade = 0;
688402000ffSAlexander V. Chernikov 
689402000ffSAlexander V. Chernikov 	/*
690402000ffSAlexander V. Chernikov 	 * Check if cmd looks like snaplen setting from
691402000ffSAlexander V. Chernikov 	 * pcap_bpf.c:pcap_open_live().
692402000ffSAlexander V. Chernikov 	 * Note we're not checking .k value here:
693caa7e52fSEitan Adler 	 * while pcap_open_live() definitely sets to non-zero value,
694402000ffSAlexander V. Chernikov 	 * we'd prefer to treat k=0 (deny ALL) case the same way: e.g.
695402000ffSAlexander V. Chernikov 	 * do not consider upgrading immediately
696402000ffSAlexander V. Chernikov 	 */
697402000ffSAlexander V. Chernikov 	if (cmd == BIOCSETF && flen == 1 && fcode[0].code == (BPF_RET | BPF_K))
698402000ffSAlexander V. Chernikov 		is_snap = 1;
699402000ffSAlexander V. Chernikov 	else
700402000ffSAlexander V. Chernikov 		is_snap = 0;
701402000ffSAlexander V. Chernikov 
702402000ffSAlexander V. Chernikov 	if (is_snap == 0) {
703402000ffSAlexander V. Chernikov 		/*
704402000ffSAlexander V. Chernikov 		 * We're setting first filter and it doesn't look like
705402000ffSAlexander V. Chernikov 		 * setting snaplen.  We're probably using bpf directly.
706402000ffSAlexander V. Chernikov 		 * Upgrade immediately.
707402000ffSAlexander V. Chernikov 		 */
708402000ffSAlexander V. Chernikov 		need_upgrade = 1;
709402000ffSAlexander V. Chernikov 	} else {
710402000ffSAlexander V. Chernikov 		/*
711402000ffSAlexander V. Chernikov 		 * Do not require upgrade by first BIOCSETF
712402000ffSAlexander V. Chernikov 		 * (used to set snaplen) by pcap_open_live().
713402000ffSAlexander V. Chernikov 		 */
714402000ffSAlexander V. Chernikov 
715402000ffSAlexander V. Chernikov 		if (--d->bd_writer == 0) {
716402000ffSAlexander V. Chernikov 			/*
717402000ffSAlexander V. Chernikov 			 * First snaplen filter has already
718402000ffSAlexander V. Chernikov 			 * been set. This is probably catch-all
719402000ffSAlexander V. Chernikov 			 * filter
720402000ffSAlexander V. Chernikov 			 */
721402000ffSAlexander V. Chernikov 			need_upgrade = 1;
722402000ffSAlexander V. Chernikov 		}
723402000ffSAlexander V. Chernikov 	}
724402000ffSAlexander V. Chernikov 
725402000ffSAlexander V. Chernikov 	CTR5(KTR_NET,
726402000ffSAlexander V. Chernikov 	    "%s: filter function set by pid %d, "
727402000ffSAlexander V. Chernikov 	    "bd_writer counter %d, snap %d upgrade %d",
728402000ffSAlexander V. Chernikov 	    __func__, d->bd_pid, d->bd_writer,
729402000ffSAlexander V. Chernikov 	    is_snap, need_upgrade);
730402000ffSAlexander V. Chernikov 
731402000ffSAlexander V. Chernikov 	return (need_upgrade);
732402000ffSAlexander V. Chernikov }
733402000ffSAlexander V. Chernikov 
734402000ffSAlexander V. Chernikov /*
73551ec1eb7SAlexander V. Chernikov  * Add d to the list of active bp filters.
736f87e372eSLuiz Otavio O Souza  * Requires bpf_attachd() to be called before.
73751ec1eb7SAlexander V. Chernikov  */
73851ec1eb7SAlexander V. Chernikov static void
73951ec1eb7SAlexander V. Chernikov bpf_upgraded(struct bpf_d *d)
74051ec1eb7SAlexander V. Chernikov {
74151ec1eb7SAlexander V. Chernikov 	struct bpf_if *bp;
74251ec1eb7SAlexander V. Chernikov 
7436c74ff0eSAlexander V. Chernikov 	BPF_LOCK_ASSERT();
7446c74ff0eSAlexander V. Chernikov 
74551ec1eb7SAlexander V. Chernikov 	bp = d->bd_bif;
74651ec1eb7SAlexander V. Chernikov 
7476c74ff0eSAlexander V. Chernikov 	/*
7486c74ff0eSAlexander V. Chernikov 	 * Filter can be set several times without specifying interface.
7496c74ff0eSAlexander V. Chernikov 	 * Mark d as reader and exit.
7506c74ff0eSAlexander V. Chernikov 	 */
7516c74ff0eSAlexander V. Chernikov 	if (bp == NULL) {
752afa85850SAlexander V. Chernikov 		BPFD_LOCK(d);
7536c74ff0eSAlexander V. Chernikov 		d->bd_writer = 0;
754afa85850SAlexander V. Chernikov 		BPFD_UNLOCK(d);
7556c74ff0eSAlexander V. Chernikov 		return;
7566c74ff0eSAlexander V. Chernikov 	}
7576c74ff0eSAlexander V. Chernikov 
75851ec1eb7SAlexander V. Chernikov 	BPFIF_WLOCK(bp);
759afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
76051ec1eb7SAlexander V. Chernikov 
76151ec1eb7SAlexander V. Chernikov 	/* Remove from writers-only list */
76251ec1eb7SAlexander V. Chernikov 	LIST_REMOVE(d, bd_next);
76351ec1eb7SAlexander V. Chernikov 	LIST_INSERT_HEAD(&bp->bif_dlist, d, bd_next);
76451ec1eb7SAlexander V. Chernikov 	/* Mark d as reader */
76551ec1eb7SAlexander V. Chernikov 	d->bd_writer = 0;
76651ec1eb7SAlexander V. Chernikov 
767afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
76851ec1eb7SAlexander V. Chernikov 	BPFIF_WUNLOCK(bp);
76951ec1eb7SAlexander V. Chernikov 
77051ec1eb7SAlexander V. Chernikov 	CTR2(KTR_NET, "%s: upgrade required by pid %d", __func__, d->bd_pid);
77151ec1eb7SAlexander V. Chernikov 
7725ce8d970SSam Leffler 	EVENTHANDLER_INVOKE(bpf_track, bp->bif_ifp, bp->bif_dlt, 1);
773df8bae1dSRodney W. Grimes }
774df8bae1dSRodney W. Grimes 
775df8bae1dSRodney W. Grimes /*
776df8bae1dSRodney W. Grimes  * Detach a file from its interface.
777df8bae1dSRodney W. Grimes  */
778df8bae1dSRodney W. Grimes static void
77919ba8395SChristian S.J. Peron bpf_detachd(struct bpf_d *d)
780df8bae1dSRodney W. Grimes {
7816c74ff0eSAlexander V. Chernikov 	BPF_LOCK();
7826c74ff0eSAlexander V. Chernikov 	bpf_detachd_locked(d);
7836c74ff0eSAlexander V. Chernikov 	BPF_UNLOCK();
7846c74ff0eSAlexander V. Chernikov }
7856c74ff0eSAlexander V. Chernikov 
7866c74ff0eSAlexander V. Chernikov static void
7876c74ff0eSAlexander V. Chernikov bpf_detachd_locked(struct bpf_d *d)
7886c74ff0eSAlexander V. Chernikov {
7896e891d64SPoul-Henning Kamp 	int error;
790df8bae1dSRodney W. Grimes 	struct bpf_if *bp;
79146448b5aSRobert Watson 	struct ifnet *ifp;
792df8bae1dSRodney W. Grimes 
79351ec1eb7SAlexander V. Chernikov 	CTR2(KTR_NET, "%s: detach required by pid %d", __func__, d->bd_pid);
79451ec1eb7SAlexander V. Chernikov 
795e4b3229aSAlexander V. Chernikov 	BPF_LOCK_ASSERT();
796e4b3229aSAlexander V. Chernikov 
7976c74ff0eSAlexander V. Chernikov 	/* Check if descriptor is attached */
7986c74ff0eSAlexander V. Chernikov 	if ((bp = d->bd_bif) == NULL)
7996c74ff0eSAlexander V. Chernikov 		return;
8006c74ff0eSAlexander V. Chernikov 
801e4b3229aSAlexander V. Chernikov 	BPFIF_WLOCK(bp);
802afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
80346448b5aSRobert Watson 
80451ec1eb7SAlexander V. Chernikov 	/* Save bd_writer value */
80551ec1eb7SAlexander V. Chernikov 	error = d->bd_writer;
80651ec1eb7SAlexander V. Chernikov 
80746448b5aSRobert Watson 	/*
80846448b5aSRobert Watson 	 * Remove d from the interface's descriptor list.
80946448b5aSRobert Watson 	 */
81046448b5aSRobert Watson 	LIST_REMOVE(d, bd_next);
81146448b5aSRobert Watson 
812e4b3229aSAlexander V. Chernikov 	ifp = bp->bif_ifp;
813572bde2aSRobert Watson 	d->bd_bif = NULL;
814afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
815e4b3229aSAlexander V. Chernikov 	BPFIF_WUNLOCK(bp);
816e4b3229aSAlexander V. Chernikov 
817e4b3229aSAlexander V. Chernikov 	bpf_bpfd_cnt--;
81846448b5aSRobert Watson 
81951ec1eb7SAlexander V. Chernikov 	/* Call event handler iff d is attached */
82051ec1eb7SAlexander V. Chernikov 	if (error == 0)
8215ce8d970SSam Leffler 		EVENTHANDLER_INVOKE(bpf_track, ifp, bp->bif_dlt, 0);
822b743c310SSam Leffler 
823df8bae1dSRodney W. Grimes 	/*
824df8bae1dSRodney W. Grimes 	 * Check if this descriptor had requested promiscuous mode.
825df8bae1dSRodney W. Grimes 	 * If so, turn it off.
826df8bae1dSRodney W. Grimes 	 */
827df8bae1dSRodney W. Grimes 	if (d->bd_promisc) {
828df8bae1dSRodney W. Grimes 		d->bd_promisc = 0;
82997021c24SMarko Zec 		CURVNET_SET(ifp->if_vnet);
83046448b5aSRobert Watson 		error = ifpromisc(ifp, 0);
83197021c24SMarko Zec 		CURVNET_RESTORE();
8326e891d64SPoul-Henning Kamp 		if (error != 0 && error != ENXIO) {
833df8bae1dSRodney W. Grimes 			/*
8346e891d64SPoul-Henning Kamp 			 * ENXIO can happen if a pccard is unplugged
835df8bae1dSRodney W. Grimes 			 * Something is really wrong if we were able to put
836df8bae1dSRodney W. Grimes 			 * the driver into promiscuous mode, but can't
837df8bae1dSRodney W. Grimes 			 * take it out.
838df8bae1dSRodney W. Grimes 			 */
8398eab61f3SSam Leffler 			if_printf(bp->bif_ifp,
8408eab61f3SSam Leffler 				"bpf_detach: ifpromisc failed (%d)\n", error);
8416e891d64SPoul-Henning Kamp 		}
842df8bae1dSRodney W. Grimes 	}
843df8bae1dSRodney W. Grimes }
844df8bae1dSRodney W. Grimes 
845df8bae1dSRodney W. Grimes /*
846136600feSEd Schouten  * Close the descriptor by detaching it from its interface,
847136600feSEd Schouten  * deallocating its buffers, and marking it free.
848136600feSEd Schouten  */
849136600feSEd Schouten static void
850136600feSEd Schouten bpf_dtor(void *data)
851136600feSEd Schouten {
852136600feSEd Schouten 	struct bpf_d *d = data;
853136600feSEd Schouten 
854afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
855136600feSEd Schouten 	if (d->bd_state == BPF_WAITING)
856136600feSEd Schouten 		callout_stop(&d->bd_callout);
857136600feSEd Schouten 	d->bd_state = BPF_IDLE;
858afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
859136600feSEd Schouten 	funsetown(&d->bd_sigio);
860136600feSEd Schouten 	bpf_detachd(d);
861136600feSEd Schouten #ifdef MAC
862136600feSEd Schouten 	mac_bpfdesc_destroy(d);
863136600feSEd Schouten #endif /* MAC */
8646aba400aSAttilio Rao 	seldrain(&d->bd_sel);
865136600feSEd Schouten 	knlist_destroy(&d->bd_sel.si_note);
8669fee1bd1SJung-uk Kim 	callout_drain(&d->bd_callout);
867136600feSEd Schouten 	bpf_freed(d);
868136600feSEd Schouten 	free(d, M_BPF);
869136600feSEd Schouten }
870136600feSEd Schouten 
871136600feSEd Schouten /*
872df8bae1dSRodney W. Grimes  * Open ethernet device.  Returns ENXIO for illegal minor device number,
873df8bae1dSRodney W. Grimes  * EBUSY if file is open by another process.
874df8bae1dSRodney W. Grimes  */
875df8bae1dSRodney W. Grimes /* ARGSUSED */
87687f6c662SJulian Elischer static	int
87719ba8395SChristian S.J. Peron bpfopen(struct cdev *dev, int flags, int fmt, struct thread *td)
878df8bae1dSRodney W. Grimes {
879e7bb21b3SJonathan Lemon 	struct bpf_d *d;
8804f42daa4SLuiz Otavio O Souza 	int error;
881df8bae1dSRodney W. Grimes 
8821ede983cSDag-Erling Smørgrav 	d = malloc(sizeof(*d), M_BPF, M_WAITOK | M_ZERO);
883136600feSEd Schouten 	error = devfs_set_cdevpriv(d, bpf_dtor);
884136600feSEd Schouten 	if (error != 0) {
885136600feSEd Schouten 		free(d, M_BPF);
886136600feSEd Schouten 		return (error);
887136600feSEd Schouten 	}
8884d621040SChristian S.J. Peron 
8894d621040SChristian S.J. Peron 	/*
8904d621040SChristian S.J. Peron 	 * For historical reasons, perform a one-time initialization call to
8914d621040SChristian S.J. Peron 	 * the buffer routines, even though we're not yet committed to a
8924d621040SChristian S.J. Peron 	 * particular buffer method.
8934d621040SChristian S.J. Peron 	 */
8944d621040SChristian S.J. Peron 	bpf_buffer_init(d);
89571448753SAlexander Motin 	if ((flags & FREAD) == 0)
89671448753SAlexander Motin 		d->bd_writer = 2;
8973b3b91e7SGuy Helmer 	d->bd_hbuf_in_use = 0;
8984d621040SChristian S.J. Peron 	d->bd_bufmode = BPF_BUFMODE_BUFFER;
89900a83887SPaul Traina 	d->bd_sig = SIGIO;
900560a54e1SJung-uk Kim 	d->bd_direction = BPF_D_INOUT;
901e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH(d, td);
90282f4445dSRobert Watson #ifdef MAC
90330d239bcSRobert Watson 	mac_bpfdesc_init(d);
90430d239bcSRobert Watson 	mac_bpfdesc_create(td->td_ucred, d);
90582f4445dSRobert Watson #endif
906afa85850SAlexander V. Chernikov 	mtx_init(&d->bd_lock, devtoname(dev), "bpf cdev lock", MTX_DEF);
907afa85850SAlexander V. Chernikov 	callout_init_mtx(&d->bd_callout, &d->bd_lock, 0);
908afa85850SAlexander V. Chernikov 	knlist_init_mtx(&d->bd_sel.si_note, &d->bd_lock);
909df8bae1dSRodney W. Grimes 
910df8bae1dSRodney W. Grimes 	return (0);
911df8bae1dSRodney W. Grimes }
912df8bae1dSRodney W. Grimes 
913df8bae1dSRodney W. Grimes /*
914df8bae1dSRodney W. Grimes  *  bpfread - read next chunk of packets from buffers
915df8bae1dSRodney W. Grimes  */
91687f6c662SJulian Elischer static	int
91719ba8395SChristian S.J. Peron bpfread(struct cdev *dev, struct uio *uio, int ioflag)
918df8bae1dSRodney W. Grimes {
919136600feSEd Schouten 	struct bpf_d *d;
920df8bae1dSRodney W. Grimes 	int error;
9218df67d77SJung-uk Kim 	int non_block;
9228df67d77SJung-uk Kim 	int timed_out;
923df8bae1dSRodney W. Grimes 
924136600feSEd Schouten 	error = devfs_get_cdevpriv((void **)&d);
925136600feSEd Schouten 	if (error != 0)
926136600feSEd Schouten 		return (error);
927136600feSEd Schouten 
928df8bae1dSRodney W. Grimes 	/*
929df8bae1dSRodney W. Grimes 	 * Restrict application to use a buffer the same size as
930df8bae1dSRodney W. Grimes 	 * as kernel buffers.
931df8bae1dSRodney W. Grimes 	 */
932df8bae1dSRodney W. Grimes 	if (uio->uio_resid != d->bd_bufsize)
933df8bae1dSRodney W. Grimes 		return (EINVAL);
934df8bae1dSRodney W. Grimes 
9358df67d77SJung-uk Kim 	non_block = ((ioflag & O_NONBLOCK) != 0);
9368df67d77SJung-uk Kim 
937afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
938e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH_CUR(d);
9394d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_BUFFER) {
940afa85850SAlexander V. Chernikov 		BPFD_UNLOCK(d);
9414d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
9424d621040SChristian S.J. Peron 	}
94381bda851SJohn Polstra 	if (d->bd_state == BPF_WAITING)
94481bda851SJohn Polstra 		callout_stop(&d->bd_callout);
94581bda851SJohn Polstra 	timed_out = (d->bd_state == BPF_TIMED_OUT);
94681bda851SJohn Polstra 	d->bd_state = BPF_IDLE;
947d013d902SGuy Helmer 	while (d->bd_hbuf_in_use) {
948d013d902SGuy Helmer 		error = mtx_sleep(&d->bd_hbuf_in_use, &d->bd_lock,
9493b3b91e7SGuy Helmer 		    PRINET|PCATCH, "bd_hbuf", 0);
950d013d902SGuy Helmer 		if (error != 0) {
951d013d902SGuy Helmer 			BPFD_UNLOCK(d);
952d013d902SGuy Helmer 			return (error);
953d013d902SGuy Helmer 		}
954d013d902SGuy Helmer 	}
955df8bae1dSRodney W. Grimes 	/*
956df8bae1dSRodney W. Grimes 	 * If the hold buffer is empty, then do a timed sleep, which
957df8bae1dSRodney W. Grimes 	 * ends when the timeout expires or when enough packets
958df8bae1dSRodney W. Grimes 	 * have arrived to fill the store buffer.
959df8bae1dSRodney W. Grimes 	 */
960572bde2aSRobert Watson 	while (d->bd_hbuf == NULL) {
9618df67d77SJung-uk Kim 		if (d->bd_slen != 0) {
962df8bae1dSRodney W. Grimes 			/*
963df8bae1dSRodney W. Grimes 			 * A packet(s) either arrived since the previous
964df8bae1dSRodney W. Grimes 			 * read or arrived while we were asleep.
9658df67d77SJung-uk Kim 			 */
9668df67d77SJung-uk Kim 			if (d->bd_immediate || non_block || timed_out) {
9678df67d77SJung-uk Kim 				/*
9688df67d77SJung-uk Kim 				 * Rotate the buffers and return what's here
9698df67d77SJung-uk Kim 				 * if we are in immediate mode, non-blocking
9708df67d77SJung-uk Kim 				 * flag is set, or this descriptor timed out.
971df8bae1dSRodney W. Grimes 				 */
972df8bae1dSRodney W. Grimes 				ROTATE_BUFFERS(d);
973df8bae1dSRodney W. Grimes 				break;
974df8bae1dSRodney W. Grimes 			}
9758df67d77SJung-uk Kim 		}
976de5d9935SRobert Watson 
977de5d9935SRobert Watson 		/*
978de5d9935SRobert Watson 		 * No data is available, check to see if the bpf device
979de5d9935SRobert Watson 		 * is still pointed at a real interface.  If not, return
980de5d9935SRobert Watson 		 * ENXIO so that the userland process knows to rebind
981de5d9935SRobert Watson 		 * it before using it again.
982de5d9935SRobert Watson 		 */
983de5d9935SRobert Watson 		if (d->bd_bif == NULL) {
984afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
985de5d9935SRobert Watson 			return (ENXIO);
986de5d9935SRobert Watson 		}
987de5d9935SRobert Watson 
9888df67d77SJung-uk Kim 		if (non_block) {
989afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
990fba3cfdeSJohn Polstra 			return (EWOULDBLOCK);
991fba3cfdeSJohn Polstra 		}
992afa85850SAlexander V. Chernikov 		error = msleep(d, &d->bd_lock, PRINET|PCATCH,
993e7bb21b3SJonathan Lemon 		     "bpf", d->bd_rtout);
994df8bae1dSRodney W. Grimes 		if (error == EINTR || error == ERESTART) {
995afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
996df8bae1dSRodney W. Grimes 			return (error);
997df8bae1dSRodney W. Grimes 		}
998df8bae1dSRodney W. Grimes 		if (error == EWOULDBLOCK) {
999df8bae1dSRodney W. Grimes 			/*
1000df8bae1dSRodney W. Grimes 			 * On a timeout, return what's in the buffer,
1001df8bae1dSRodney W. Grimes 			 * which may be nothing.  If there is something
1002df8bae1dSRodney W. Grimes 			 * in the store buffer, we can rotate the buffers.
1003df8bae1dSRodney W. Grimes 			 */
1004df8bae1dSRodney W. Grimes 			if (d->bd_hbuf)
1005df8bae1dSRodney W. Grimes 				/*
1006df8bae1dSRodney W. Grimes 				 * We filled up the buffer in between
1007df8bae1dSRodney W. Grimes 				 * getting the timeout and arriving
1008df8bae1dSRodney W. Grimes 				 * here, so we don't need to rotate.
1009df8bae1dSRodney W. Grimes 				 */
1010df8bae1dSRodney W. Grimes 				break;
1011df8bae1dSRodney W. Grimes 
1012df8bae1dSRodney W. Grimes 			if (d->bd_slen == 0) {
1013afa85850SAlexander V. Chernikov 				BPFD_UNLOCK(d);
1014df8bae1dSRodney W. Grimes 				return (0);
1015df8bae1dSRodney W. Grimes 			}
1016df8bae1dSRodney W. Grimes 			ROTATE_BUFFERS(d);
1017df8bae1dSRodney W. Grimes 			break;
1018df8bae1dSRodney W. Grimes 		}
1019df8bae1dSRodney W. Grimes 	}
1020df8bae1dSRodney W. Grimes 	/*
1021df8bae1dSRodney W. Grimes 	 * At this point, we know we have something in the hold slot.
1022df8bae1dSRodney W. Grimes 	 */
10233b3b91e7SGuy Helmer 	d->bd_hbuf_in_use = 1;
1024afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
1025df8bae1dSRodney W. Grimes 
1026df8bae1dSRodney W. Grimes 	/*
1027df8bae1dSRodney W. Grimes 	 * Move data from hold buffer into user space.
1028df8bae1dSRodney W. Grimes 	 * We know the entire buffer is transferred since
1029df8bae1dSRodney W. Grimes 	 * we checked above that the read buffer is bpf_bufsize bytes.
103031b32e6dSRobert Watson   	 *
10313b3b91e7SGuy Helmer 	 * We do not have to worry about simultaneous reads because
10323b3b91e7SGuy Helmer 	 * we waited for sole access to the hold buffer above.
1033df8bae1dSRodney W. Grimes 	 */
10344d621040SChristian S.J. Peron 	error = bpf_uiomove(d, d->bd_hbuf, d->bd_hlen, uio);
1035df8bae1dSRodney W. Grimes 
1036afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
10373b3b91e7SGuy Helmer 	KASSERT(d->bd_hbuf != NULL, ("bpfread: lost bd_hbuf"));
1038df8bae1dSRodney W. Grimes 	d->bd_fbuf = d->bd_hbuf;
1039572bde2aSRobert Watson 	d->bd_hbuf = NULL;
1040df8bae1dSRodney W. Grimes 	d->bd_hlen = 0;
104129f612ecSChristian S.J. Peron 	bpf_buf_reclaimed(d);
10423b3b91e7SGuy Helmer 	d->bd_hbuf_in_use = 0;
10433b3b91e7SGuy Helmer 	wakeup(&d->bd_hbuf_in_use);
1044afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
1045df8bae1dSRodney W. Grimes 
1046df8bae1dSRodney W. Grimes 	return (error);
1047df8bae1dSRodney W. Grimes }
1048df8bae1dSRodney W. Grimes 
1049df8bae1dSRodney W. Grimes /*
1050df8bae1dSRodney W. Grimes  * If there are processes sleeping on this descriptor, wake them up.
1051df8bae1dSRodney W. Grimes  */
1052e7bb21b3SJonathan Lemon static __inline void
105319ba8395SChristian S.J. Peron bpf_wakeup(struct bpf_d *d)
1054df8bae1dSRodney W. Grimes {
1055a3272e3cSChristian S.J. Peron 
1056afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
105781bda851SJohn Polstra 	if (d->bd_state == BPF_WAITING) {
105881bda851SJohn Polstra 		callout_stop(&d->bd_callout);
105981bda851SJohn Polstra 		d->bd_state = BPF_IDLE;
106081bda851SJohn Polstra 	}
1061521f364bSDag-Erling Smørgrav 	wakeup(d);
1062831d27a9SDon Lewis 	if (d->bd_async && d->bd_sig && d->bd_sigio)
1063f1320723SAlfred Perlstein 		pgsigio(&d->bd_sigio, d->bd_sig, 0);
106400a83887SPaul Traina 
1065512824f8SSeigo Tanimura 	selwakeuppri(&d->bd_sel, PRINET);
1066ad3b9257SJohn-Mark Gurney 	KNOTE_LOCKED(&d->bd_sel.si_note, 0);
1067df8bae1dSRodney W. Grimes }
1068df8bae1dSRodney W. Grimes 
106981bda851SJohn Polstra static void
107019ba8395SChristian S.J. Peron bpf_timed_out(void *arg)
107181bda851SJohn Polstra {
107281bda851SJohn Polstra 	struct bpf_d *d = (struct bpf_d *)arg;
107381bda851SJohn Polstra 
1074afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
10759fee1bd1SJung-uk Kim 
10769fee1bd1SJung-uk Kim 	if (callout_pending(&d->bd_callout) || !callout_active(&d->bd_callout))
10779fee1bd1SJung-uk Kim 		return;
107881bda851SJohn Polstra 	if (d->bd_state == BPF_WAITING) {
107981bda851SJohn Polstra 		d->bd_state = BPF_TIMED_OUT;
108081bda851SJohn Polstra 		if (d->bd_slen != 0)
108181bda851SJohn Polstra 			bpf_wakeup(d);
108281bda851SJohn Polstra 	}
108381bda851SJohn Polstra }
108481bda851SJohn Polstra 
108587f6c662SJulian Elischer static int
10864d621040SChristian S.J. Peron bpf_ready(struct bpf_d *d)
10874d621040SChristian S.J. Peron {
10884d621040SChristian S.J. Peron 
1089afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
10904d621040SChristian S.J. Peron 
10914d621040SChristian S.J. Peron 	if (!bpf_canfreebuf(d) && d->bd_hlen != 0)
10924d621040SChristian S.J. Peron 		return (1);
10934d621040SChristian S.J. Peron 	if ((d->bd_immediate || d->bd_state == BPF_TIMED_OUT) &&
10944d621040SChristian S.J. Peron 	    d->bd_slen != 0)
10954d621040SChristian S.J. Peron 		return (1);
10964d621040SChristian S.J. Peron 	return (0);
10974d621040SChristian S.J. Peron }
10984d621040SChristian S.J. Peron 
10994d621040SChristian S.J. Peron static int
110019ba8395SChristian S.J. Peron bpfwrite(struct cdev *dev, struct uio *uio, int ioflag)
1101df8bae1dSRodney W. Grimes {
1102136600feSEd Schouten 	struct bpf_d *d;
1103df8bae1dSRodney W. Grimes 	struct ifnet *ifp;
1104560a54e1SJung-uk Kim 	struct mbuf *m, *mc;
11058240bf1eSRobert Watson 	struct sockaddr dst;
11064fb3a820SAlexander V. Chernikov 	struct route ro;
1107560a54e1SJung-uk Kim 	int error, hlen;
1108df8bae1dSRodney W. Grimes 
1109136600feSEd Schouten 	error = devfs_get_cdevpriv((void **)&d);
1110136600feSEd Schouten 	if (error != 0)
1111136600feSEd Schouten 		return (error);
1112136600feSEd Schouten 
1113e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH_CUR(d);
11144d621040SChristian S.J. Peron 	d->bd_wcount++;
11156c74ff0eSAlexander V. Chernikov 	/* XXX: locking required */
11164d621040SChristian S.J. Peron 	if (d->bd_bif == NULL) {
11174d621040SChristian S.J. Peron 		d->bd_wdcount++;
1118df8bae1dSRodney W. Grimes 		return (ENXIO);
11194d621040SChristian S.J. Peron 	}
1120df8bae1dSRodney W. Grimes 
1121df8bae1dSRodney W. Grimes 	ifp = d->bd_bif->bif_ifp;
1122df8bae1dSRodney W. Grimes 
11234d621040SChristian S.J. Peron 	if ((ifp->if_flags & IFF_UP) == 0) {
11244d621040SChristian S.J. Peron 		d->bd_wdcount++;
11253518d220SSam Leffler 		return (ENETDOWN);
11264d621040SChristian S.J. Peron 	}
11273518d220SSam Leffler 
11284d621040SChristian S.J. Peron 	if (uio->uio_resid == 0) {
11294d621040SChristian S.J. Peron 		d->bd_wdcount++;
1130df8bae1dSRodney W. Grimes 		return (0);
11314d621040SChristian S.J. Peron 	}
1132df8bae1dSRodney W. Grimes 
11338240bf1eSRobert Watson 	bzero(&dst, sizeof(dst));
1134d83e603aSChristian S.J. Peron 	m = NULL;
1135d83e603aSChristian S.J. Peron 	hlen = 0;
11366c74ff0eSAlexander V. Chernikov 	/* XXX: bpf_movein() can sleep */
1137cb44b6dfSAndrew Thompson 	error = bpf_movein(uio, (int)d->bd_bif->bif_dlt, ifp,
11384fb3a820SAlexander V. Chernikov 	    &m, &dst, &hlen, d);
11394d621040SChristian S.J. Peron 	if (error) {
11404d621040SChristian S.J. Peron 		d->bd_wdcount++;
1141df8bae1dSRodney W. Grimes 		return (error);
11424d621040SChristian S.J. Peron 	}
11434d621040SChristian S.J. Peron 	d->bd_wfcount++;
1144114ae644SMike Smith 	if (d->bd_hdrcmplt)
1145114ae644SMike Smith 		dst.sa_family = pseudo_AF_HDRCMPLT;
1146114ae644SMike Smith 
1147560a54e1SJung-uk Kim 	if (d->bd_feedback) {
1148eb1b1807SGleb Smirnoff 		mc = m_dup(m, M_NOWAIT);
1149560a54e1SJung-uk Kim 		if (mc != NULL)
1150560a54e1SJung-uk Kim 			mc->m_pkthdr.rcvif = ifp;
11518cd892f7SJung-uk Kim 		/* Set M_PROMISC for outgoing packets to be discarded. */
11528cd892f7SJung-uk Kim 		if (d->bd_direction == BPF_D_INOUT)
11538cd892f7SJung-uk Kim 			m->m_flags |= M_PROMISC;
1154560a54e1SJung-uk Kim 	} else
1155560a54e1SJung-uk Kim 		mc = NULL;
1156560a54e1SJung-uk Kim 
1157560a54e1SJung-uk Kim 	m->m_pkthdr.len -= hlen;
1158560a54e1SJung-uk Kim 	m->m_len -= hlen;
1159560a54e1SJung-uk Kim 	m->m_data += hlen;	/* XXX */
1160560a54e1SJung-uk Kim 
116121ca7b57SMarko Zec 	CURVNET_SET(ifp->if_vnet);
116282f4445dSRobert Watson #ifdef MAC
1163afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
116430d239bcSRobert Watson 	mac_bpfdesc_create_mbuf(d, m);
1165560a54e1SJung-uk Kim 	if (mc != NULL)
116630d239bcSRobert Watson 		mac_bpfdesc_create_mbuf(d, mc);
1167afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
116882f4445dSRobert Watson #endif
1169560a54e1SJung-uk Kim 
11704fb3a820SAlexander V. Chernikov 	bzero(&ro, sizeof(ro));
11714fb3a820SAlexander V. Chernikov 	if (hlen != 0) {
11724fb3a820SAlexander V. Chernikov 		ro.ro_prepend = (u_char *)&dst.sa_data;
11734fb3a820SAlexander V. Chernikov 		ro.ro_plen = hlen;
11744fb3a820SAlexander V. Chernikov 		ro.ro_flags = RT_HAS_HEADER;
11754fb3a820SAlexander V. Chernikov 	}
11764fb3a820SAlexander V. Chernikov 
11774fb3a820SAlexander V. Chernikov 	error = (*ifp->if_output)(ifp, m, &dst, &ro);
11784d621040SChristian S.J. Peron 	if (error)
11794d621040SChristian S.J. Peron 		d->bd_wdcount++;
1180560a54e1SJung-uk Kim 
1181560a54e1SJung-uk Kim 	if (mc != NULL) {
11820bf686c1SRobert Watson 		if (error == 0)
1183560a54e1SJung-uk Kim 			(*ifp->if_input)(ifp, mc);
11840bf686c1SRobert Watson 		else
1185560a54e1SJung-uk Kim 			m_freem(mc);
1186560a54e1SJung-uk Kim 	}
118721ca7b57SMarko Zec 	CURVNET_RESTORE();
1188560a54e1SJung-uk Kim 
1189df8bae1dSRodney W. Grimes 	return (error);
1190df8bae1dSRodney W. Grimes }
1191df8bae1dSRodney W. Grimes 
1192df8bae1dSRodney W. Grimes /*
1193e82669d9SRobert Watson  * Reset a descriptor by flushing its packet buffer and clearing the receive
1194e82669d9SRobert Watson  * and drop counts.  This is doable for kernel-only buffers, but with
1195e82669d9SRobert Watson  * zero-copy buffers, we can't write to (or rotate) buffers that are
1196e82669d9SRobert Watson  * currently owned by userspace.  It would be nice if we could encapsulate
1197e82669d9SRobert Watson  * this logic in the buffer code rather than here.
1198df8bae1dSRodney W. Grimes  */
1199df8bae1dSRodney W. Grimes static void
120019ba8395SChristian S.J. Peron reset_d(struct bpf_d *d)
1201df8bae1dSRodney W. Grimes {
1202e7bb21b3SJonathan Lemon 
1203afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
1204e82669d9SRobert Watson 
12053b3b91e7SGuy Helmer 	while (d->bd_hbuf_in_use)
12063b3b91e7SGuy Helmer 		mtx_sleep(&d->bd_hbuf_in_use, &d->bd_lock, PRINET,
12073b3b91e7SGuy Helmer 		    "bd_hbuf", 0);
1208e82669d9SRobert Watson 	if ((d->bd_hbuf != NULL) &&
1209e82669d9SRobert Watson 	    (d->bd_bufmode != BPF_BUFMODE_ZBUF || bpf_canfreebuf(d))) {
1210df8bae1dSRodney W. Grimes 		/* Free the hold buffer. */
1211df8bae1dSRodney W. Grimes 		d->bd_fbuf = d->bd_hbuf;
1212572bde2aSRobert Watson 		d->bd_hbuf = NULL;
1213e82669d9SRobert Watson 		d->bd_hlen = 0;
121429f612ecSChristian S.J. Peron 		bpf_buf_reclaimed(d);
1215df8bae1dSRodney W. Grimes 	}
1216e82669d9SRobert Watson 	if (bpf_canwritebuf(d))
1217df8bae1dSRodney W. Grimes 		d->bd_slen = 0;
1218df8bae1dSRodney W. Grimes 	d->bd_rcount = 0;
1219df8bae1dSRodney W. Grimes 	d->bd_dcount = 0;
122069f7644bSChristian S.J. Peron 	d->bd_fcount = 0;
12214d621040SChristian S.J. Peron 	d->bd_wcount = 0;
12224d621040SChristian S.J. Peron 	d->bd_wfcount = 0;
12234d621040SChristian S.J. Peron 	d->bd_wdcount = 0;
12244d621040SChristian S.J. Peron 	d->bd_zcopy = 0;
1225df8bae1dSRodney W. Grimes }
1226df8bae1dSRodney W. Grimes 
1227df8bae1dSRodney W. Grimes /*
1228df8bae1dSRodney W. Grimes  *  FIONREAD		Check for read packet available.
1229df8bae1dSRodney W. Grimes  *  BIOCGBLEN		Get buffer len [for read()].
1230f11c3508SDavid Malone  *  BIOCSETF		Set read filter.
1231f11c3508SDavid Malone  *  BIOCSETFNR		Set read filter without resetting descriptor.
1232f11c3508SDavid Malone  *  BIOCSETWF		Set write filter.
1233df8bae1dSRodney W. Grimes  *  BIOCFLUSH		Flush read packet buffer.
1234df8bae1dSRodney W. Grimes  *  BIOCPROMISC		Put interface into promiscuous mode.
1235df8bae1dSRodney W. Grimes  *  BIOCGDLT		Get link layer type.
1236df8bae1dSRodney W. Grimes  *  BIOCGETIF		Get interface name.
1237df8bae1dSRodney W. Grimes  *  BIOCSETIF		Set interface.
1238df8bae1dSRodney W. Grimes  *  BIOCSRTIMEOUT	Set read timeout.
1239df8bae1dSRodney W. Grimes  *  BIOCGRTIMEOUT	Get read timeout.
1240df8bae1dSRodney W. Grimes  *  BIOCGSTATS		Get packet stats.
1241df8bae1dSRodney W. Grimes  *  BIOCIMMEDIATE	Set immediate mode.
1242df8bae1dSRodney W. Grimes  *  BIOCVERSION		Get filter language version.
1243114ae644SMike Smith  *  BIOCGHDRCMPLT	Get "header already complete" flag
1244114ae644SMike Smith  *  BIOCSHDRCMPLT	Set "header already complete" flag
1245560a54e1SJung-uk Kim  *  BIOCGDIRECTION	Get packet direction flag
1246560a54e1SJung-uk Kim  *  BIOCSDIRECTION	Set packet direction flag
1247547d94bdSJung-uk Kim  *  BIOCGTSTAMP		Get time stamp format and resolution.
1248547d94bdSJung-uk Kim  *  BIOCSTSTAMP		Set time stamp format and resolution.
124993e39f0bSChristian S.J. Peron  *  BIOCLOCK		Set "locked" flag
1250560a54e1SJung-uk Kim  *  BIOCFEEDBACK	Set packet feedback mode.
12514d621040SChristian S.J. Peron  *  BIOCSETZBUF		Set current zero-copy buffer locations.
12524d621040SChristian S.J. Peron  *  BIOCGETZMAX		Get maximum zero-copy buffer size.
12534d621040SChristian S.J. Peron  *  BIOCROTZBUF		Force rotation of zero-copy buffer
12544d621040SChristian S.J. Peron  *  BIOCSETBUFMODE	Set buffer mode.
12554d621040SChristian S.J. Peron  *  BIOCGETBUFMODE	Get current buffer mode.
1256df8bae1dSRodney W. Grimes  */
1257df8bae1dSRodney W. Grimes /* ARGSUSED */
125887f6c662SJulian Elischer static	int
125919ba8395SChristian S.J. Peron bpfioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags,
126019ba8395SChristian S.J. Peron     struct thread *td)
1261df8bae1dSRodney W. Grimes {
1262136600feSEd Schouten 	struct bpf_d *d;
1263136600feSEd Schouten 	int error;
1264136600feSEd Schouten 
1265136600feSEd Schouten 	error = devfs_get_cdevpriv((void **)&d);
1266136600feSEd Schouten 	if (error != 0)
1267136600feSEd Schouten 		return (error);
1268df8bae1dSRodney W. Grimes 
1269b75a24a0SChristian S.J. Peron 	/*
1270b75a24a0SChristian S.J. Peron 	 * Refresh PID associated with this descriptor.
1271b75a24a0SChristian S.J. Peron 	 */
1272afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
1273e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH(d, td);
127481bda851SJohn Polstra 	if (d->bd_state == BPF_WAITING)
127581bda851SJohn Polstra 		callout_stop(&d->bd_callout);
127681bda851SJohn Polstra 	d->bd_state = BPF_IDLE;
1277afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
127881bda851SJohn Polstra 
127993e39f0bSChristian S.J. Peron 	if (d->bd_locked == 1) {
128093e39f0bSChristian S.J. Peron 		switch (cmd) {
128193e39f0bSChristian S.J. Peron 		case BIOCGBLEN:
128293e39f0bSChristian S.J. Peron 		case BIOCFLUSH:
128393e39f0bSChristian S.J. Peron 		case BIOCGDLT:
128493e39f0bSChristian S.J. Peron 		case BIOCGDLTLIST:
1285fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
1286fc0a61a4SKonstantin Belousov 		case BIOCGDLTLIST32:
1287fc0a61a4SKonstantin Belousov #endif
128893e39f0bSChristian S.J. Peron 		case BIOCGETIF:
128993e39f0bSChristian S.J. Peron 		case BIOCGRTIMEOUT:
1290b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1291fc0a61a4SKonstantin Belousov 		case BIOCGRTIMEOUT32:
1292fc0a61a4SKonstantin Belousov #endif
129393e39f0bSChristian S.J. Peron 		case BIOCGSTATS:
129493e39f0bSChristian S.J. Peron 		case BIOCVERSION:
129593e39f0bSChristian S.J. Peron 		case BIOCGRSIG:
129693e39f0bSChristian S.J. Peron 		case BIOCGHDRCMPLT:
1297547d94bdSJung-uk Kim 		case BIOCSTSTAMP:
1298560a54e1SJung-uk Kim 		case BIOCFEEDBACK:
129993e39f0bSChristian S.J. Peron 		case FIONREAD:
130093e39f0bSChristian S.J. Peron 		case BIOCLOCK:
130193e39f0bSChristian S.J. Peron 		case BIOCSRTIMEOUT:
1302b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1303fc0a61a4SKonstantin Belousov 		case BIOCSRTIMEOUT32:
1304fc0a61a4SKonstantin Belousov #endif
130593e39f0bSChristian S.J. Peron 		case BIOCIMMEDIATE:
130693e39f0bSChristian S.J. Peron 		case TIOCGPGRP:
13074d621040SChristian S.J. Peron 		case BIOCROTZBUF:
130893e39f0bSChristian S.J. Peron 			break;
130993e39f0bSChristian S.J. Peron 		default:
131093e39f0bSChristian S.J. Peron 			return (EPERM);
131193e39f0bSChristian S.J. Peron 		}
131293e39f0bSChristian S.J. Peron 	}
1313fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
1314fc0a61a4SKonstantin Belousov 	/*
1315fc0a61a4SKonstantin Belousov 	 * If we see a 32-bit compat ioctl, mark the stream as 32-bit so
1316fc0a61a4SKonstantin Belousov 	 * that it will get 32-bit packet headers.
1317fc0a61a4SKonstantin Belousov 	 */
1318fc0a61a4SKonstantin Belousov 	switch (cmd) {
1319fc0a61a4SKonstantin Belousov 	case BIOCSETF32:
1320fc0a61a4SKonstantin Belousov 	case BIOCSETFNR32:
1321fc0a61a4SKonstantin Belousov 	case BIOCSETWF32:
1322fc0a61a4SKonstantin Belousov 	case BIOCGDLTLIST32:
1323fc0a61a4SKonstantin Belousov 	case BIOCGRTIMEOUT32:
1324fc0a61a4SKonstantin Belousov 	case BIOCSRTIMEOUT32:
1325*74549d4bSWojciech Macek 		if (SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
132697aacec6SAlexander V. Chernikov 			BPFD_LOCK(d);
1327fc0a61a4SKonstantin Belousov 			d->bd_compat32 = 1;
132897aacec6SAlexander V. Chernikov 			BPFD_UNLOCK(d);
1329fc0a61a4SKonstantin Belousov 		}
1330*74549d4bSWojciech Macek 	}
1331fc0a61a4SKonstantin Belousov #endif
1332fc0a61a4SKonstantin Belousov 
133397021c24SMarko Zec 	CURVNET_SET(TD_TO_VNET(td));
1334df8bae1dSRodney W. Grimes 	switch (cmd) {
1335df8bae1dSRodney W. Grimes 
1336df8bae1dSRodney W. Grimes 	default:
1337df8bae1dSRodney W. Grimes 		error = EINVAL;
1338df8bae1dSRodney W. Grimes 		break;
1339df8bae1dSRodney W. Grimes 
1340df8bae1dSRodney W. Grimes 	/*
1341df8bae1dSRodney W. Grimes 	 * Check for read packet available.
1342df8bae1dSRodney W. Grimes 	 */
1343df8bae1dSRodney W. Grimes 	case FIONREAD:
1344df8bae1dSRodney W. Grimes 		{
1345df8bae1dSRodney W. Grimes 			int n;
1346df8bae1dSRodney W. Grimes 
1347afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
1348df8bae1dSRodney W. Grimes 			n = d->bd_slen;
13493b3b91e7SGuy Helmer 			while (d->bd_hbuf_in_use)
13503b3b91e7SGuy Helmer 				mtx_sleep(&d->bd_hbuf_in_use, &d->bd_lock,
13513b3b91e7SGuy Helmer 				    PRINET, "bd_hbuf", 0);
1352df8bae1dSRodney W. Grimes 			if (d->bd_hbuf)
1353df8bae1dSRodney W. Grimes 				n += d->bd_hlen;
1354afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
1355df8bae1dSRodney W. Grimes 
1356df8bae1dSRodney W. Grimes 			*(int *)addr = n;
1357df8bae1dSRodney W. Grimes 			break;
1358df8bae1dSRodney W. Grimes 		}
1359df8bae1dSRodney W. Grimes 
1360df8bae1dSRodney W. Grimes 	/*
1361df8bae1dSRodney W. Grimes 	 * Get buffer len [for read()].
1362df8bae1dSRodney W. Grimes 	 */
1363df8bae1dSRodney W. Grimes 	case BIOCGBLEN:
136497aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1365df8bae1dSRodney W. Grimes 		*(u_int *)addr = d->bd_bufsize;
136697aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1367df8bae1dSRodney W. Grimes 		break;
1368df8bae1dSRodney W. Grimes 
1369df8bae1dSRodney W. Grimes 	/*
1370df8bae1dSRodney W. Grimes 	 * Set buffer length.
1371df8bae1dSRodney W. Grimes 	 */
1372df8bae1dSRodney W. Grimes 	case BIOCSBLEN:
13734d621040SChristian S.J. Peron 		error = bpf_ioctl_sblen(d, (u_int *)addr);
1374df8bae1dSRodney W. Grimes 		break;
1375df8bae1dSRodney W. Grimes 
1376df8bae1dSRodney W. Grimes 	/*
1377df8bae1dSRodney W. Grimes 	 * Set link layer read filter.
1378df8bae1dSRodney W. Grimes 	 */
1379df8bae1dSRodney W. Grimes 	case BIOCSETF:
1380f11c3508SDavid Malone 	case BIOCSETFNR:
138193e39f0bSChristian S.J. Peron 	case BIOCSETWF:
1382fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
1383fc0a61a4SKonstantin Belousov 	case BIOCSETF32:
1384fc0a61a4SKonstantin Belousov 	case BIOCSETFNR32:
1385fc0a61a4SKonstantin Belousov 	case BIOCSETWF32:
1386fc0a61a4SKonstantin Belousov #endif
138793e39f0bSChristian S.J. Peron 		error = bpf_setf(d, (struct bpf_program *)addr, cmd);
1388df8bae1dSRodney W. Grimes 		break;
1389df8bae1dSRodney W. Grimes 
1390df8bae1dSRodney W. Grimes 	/*
1391df8bae1dSRodney W. Grimes 	 * Flush read packet buffer.
1392df8bae1dSRodney W. Grimes 	 */
1393df8bae1dSRodney W. Grimes 	case BIOCFLUSH:
1394afa85850SAlexander V. Chernikov 		BPFD_LOCK(d);
1395df8bae1dSRodney W. Grimes 		reset_d(d);
1396afa85850SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1397df8bae1dSRodney W. Grimes 		break;
1398df8bae1dSRodney W. Grimes 
1399df8bae1dSRodney W. Grimes 	/*
1400df8bae1dSRodney W. Grimes 	 * Put interface into promiscuous mode.
1401df8bae1dSRodney W. Grimes 	 */
1402df8bae1dSRodney W. Grimes 	case BIOCPROMISC:
1403572bde2aSRobert Watson 		if (d->bd_bif == NULL) {
1404df8bae1dSRodney W. Grimes 			/*
1405df8bae1dSRodney W. Grimes 			 * No interface attached yet.
1406df8bae1dSRodney W. Grimes 			 */
1407df8bae1dSRodney W. Grimes 			error = EINVAL;
1408df8bae1dSRodney W. Grimes 			break;
1409df8bae1dSRodney W. Grimes 		}
1410df8bae1dSRodney W. Grimes 		if (d->bd_promisc == 0) {
1411df8bae1dSRodney W. Grimes 			error = ifpromisc(d->bd_bif->bif_ifp, 1);
1412df8bae1dSRodney W. Grimes 			if (error == 0)
1413df8bae1dSRodney W. Grimes 				d->bd_promisc = 1;
1414df8bae1dSRodney W. Grimes 		}
1415df8bae1dSRodney W. Grimes 		break;
1416df8bae1dSRodney W. Grimes 
1417df8bae1dSRodney W. Grimes 	/*
14188eab61f3SSam Leffler 	 * Get current data link type.
1419df8bae1dSRodney W. Grimes 	 */
1420df8bae1dSRodney W. Grimes 	case BIOCGDLT:
142197aacec6SAlexander V. Chernikov 		BPF_LOCK();
1422572bde2aSRobert Watson 		if (d->bd_bif == NULL)
1423df8bae1dSRodney W. Grimes 			error = EINVAL;
1424df8bae1dSRodney W. Grimes 		else
1425df8bae1dSRodney W. Grimes 			*(u_int *)addr = d->bd_bif->bif_dlt;
142697aacec6SAlexander V. Chernikov 		BPF_UNLOCK();
1427df8bae1dSRodney W. Grimes 		break;
1428df8bae1dSRodney W. Grimes 
1429df8bae1dSRodney W. Grimes 	/*
14308eab61f3SSam Leffler 	 * Get a list of supported data link types.
14318eab61f3SSam Leffler 	 */
1432fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
1433fc0a61a4SKonstantin Belousov 	case BIOCGDLTLIST32:
1434fc0a61a4SKonstantin Belousov 		{
1435fc0a61a4SKonstantin Belousov 			struct bpf_dltlist32 *list32;
1436fc0a61a4SKonstantin Belousov 			struct bpf_dltlist dltlist;
1437fc0a61a4SKonstantin Belousov 
1438fc0a61a4SKonstantin Belousov 			list32 = (struct bpf_dltlist32 *)addr;
1439fc0a61a4SKonstantin Belousov 			dltlist.bfl_len = list32->bfl_len;
1440fc0a61a4SKonstantin Belousov 			dltlist.bfl_list = PTRIN(list32->bfl_list);
144197aacec6SAlexander V. Chernikov 			BPF_LOCK();
1442fc0a61a4SKonstantin Belousov 			if (d->bd_bif == NULL)
1443fc0a61a4SKonstantin Belousov 				error = EINVAL;
1444fc0a61a4SKonstantin Belousov 			else {
1445fc0a61a4SKonstantin Belousov 				error = bpf_getdltlist(d, &dltlist);
1446fc0a61a4SKonstantin Belousov 				if (error == 0)
1447fc0a61a4SKonstantin Belousov 					list32->bfl_len = dltlist.bfl_len;
1448fc0a61a4SKonstantin Belousov 			}
144997aacec6SAlexander V. Chernikov 			BPF_UNLOCK();
1450fc0a61a4SKonstantin Belousov 			break;
1451fc0a61a4SKonstantin Belousov 		}
1452fc0a61a4SKonstantin Belousov #endif
1453fc0a61a4SKonstantin Belousov 
14548eab61f3SSam Leffler 	case BIOCGDLTLIST:
145597aacec6SAlexander V. Chernikov 		BPF_LOCK();
1456572bde2aSRobert Watson 		if (d->bd_bif == NULL)
14578eab61f3SSam Leffler 			error = EINVAL;
14588eab61f3SSam Leffler 		else
14598eab61f3SSam Leffler 			error = bpf_getdltlist(d, (struct bpf_dltlist *)addr);
146097aacec6SAlexander V. Chernikov 		BPF_UNLOCK();
14618eab61f3SSam Leffler 		break;
14628eab61f3SSam Leffler 
14638eab61f3SSam Leffler 	/*
14648eab61f3SSam Leffler 	 * Set data link type.
14658eab61f3SSam Leffler 	 */
14668eab61f3SSam Leffler 	case BIOCSDLT:
14676c74ff0eSAlexander V. Chernikov 		BPF_LOCK();
1468572bde2aSRobert Watson 		if (d->bd_bif == NULL)
14698eab61f3SSam Leffler 			error = EINVAL;
14708eab61f3SSam Leffler 		else
14718eab61f3SSam Leffler 			error = bpf_setdlt(d, *(u_int *)addr);
14726c74ff0eSAlexander V. Chernikov 		BPF_UNLOCK();
14738eab61f3SSam Leffler 		break;
14748eab61f3SSam Leffler 
14758eab61f3SSam Leffler 	/*
14761dd0feaaSArchie Cobbs 	 * Get interface name.
1477df8bae1dSRodney W. Grimes 	 */
1478df8bae1dSRodney W. Grimes 	case BIOCGETIF:
147997aacec6SAlexander V. Chernikov 		BPF_LOCK();
1480572bde2aSRobert Watson 		if (d->bd_bif == NULL)
1481df8bae1dSRodney W. Grimes 			error = EINVAL;
14821dd0feaaSArchie Cobbs 		else {
14831dd0feaaSArchie Cobbs 			struct ifnet *const ifp = d->bd_bif->bif_ifp;
14841dd0feaaSArchie Cobbs 			struct ifreq *const ifr = (struct ifreq *)addr;
14851dd0feaaSArchie Cobbs 
14869bf40edeSBrooks Davis 			strlcpy(ifr->ifr_name, ifp->if_xname,
14879bf40edeSBrooks Davis 			    sizeof(ifr->ifr_name));
14881dd0feaaSArchie Cobbs 		}
148997aacec6SAlexander V. Chernikov 		BPF_UNLOCK();
1490df8bae1dSRodney W. Grimes 		break;
1491df8bae1dSRodney W. Grimes 
1492df8bae1dSRodney W. Grimes 	/*
1493df8bae1dSRodney W. Grimes 	 * Set interface.
1494df8bae1dSRodney W. Grimes 	 */
1495df8bae1dSRodney W. Grimes 	case BIOCSETIF:
14964f42daa4SLuiz Otavio O Souza 		{
14974f42daa4SLuiz Otavio O Souza 			int alloc_buf, size;
14984f42daa4SLuiz Otavio O Souza 
14994f42daa4SLuiz Otavio O Souza 			/*
15004f42daa4SLuiz Otavio O Souza 			 * Behavior here depends on the buffering model.  If
15014f42daa4SLuiz Otavio O Souza 			 * we're using kernel memory buffers, then we can
15024f42daa4SLuiz Otavio O Souza 			 * allocate them here.  If we're using zero-copy,
15034f42daa4SLuiz Otavio O Souza 			 * then the user process must have registered buffers
15044f42daa4SLuiz Otavio O Souza 			 * by the time we get here.
15054f42daa4SLuiz Otavio O Souza 			 */
15064f42daa4SLuiz Otavio O Souza 			alloc_buf = 0;
15074f42daa4SLuiz Otavio O Souza 			BPFD_LOCK(d);
15084f42daa4SLuiz Otavio O Souza 			if (d->bd_bufmode == BPF_BUFMODE_BUFFER &&
15094f42daa4SLuiz Otavio O Souza 			    d->bd_sbuf == NULL)
15104f42daa4SLuiz Otavio O Souza 				alloc_buf = 1;
15114f42daa4SLuiz Otavio O Souza 			BPFD_UNLOCK(d);
15124f42daa4SLuiz Otavio O Souza 			if (alloc_buf) {
15134f42daa4SLuiz Otavio O Souza 				size = d->bd_bufsize;
15144f42daa4SLuiz Otavio O Souza 				error = bpf_buffer_ioctl_sblen(d, &size);
15154f42daa4SLuiz Otavio O Souza 				if (error != 0)
15164f42daa4SLuiz Otavio O Souza 					break;
15174f42daa4SLuiz Otavio O Souza 			}
15186c74ff0eSAlexander V. Chernikov 			BPF_LOCK();
1519df8bae1dSRodney W. Grimes 			error = bpf_setif(d, (struct ifreq *)addr);
15206c74ff0eSAlexander V. Chernikov 			BPF_UNLOCK();
1521df8bae1dSRodney W. Grimes 			break;
15224f42daa4SLuiz Otavio O Souza 		}
1523df8bae1dSRodney W. Grimes 
1524df8bae1dSRodney W. Grimes 	/*
1525df8bae1dSRodney W. Grimes 	 * Set read timeout.
1526df8bae1dSRodney W. Grimes 	 */
1527df8bae1dSRodney W. Grimes 	case BIOCSRTIMEOUT:
1528b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1529fc0a61a4SKonstantin Belousov 	case BIOCSRTIMEOUT32:
1530fc0a61a4SKonstantin Belousov #endif
1531df8bae1dSRodney W. Grimes 		{
1532df8bae1dSRodney W. Grimes 			struct timeval *tv = (struct timeval *)addr;
15339624d947SJuli Mallett #if defined(COMPAT_FREEBSD32) && !defined(__mips__)
1534fc0a61a4SKonstantin Belousov 			struct timeval32 *tv32;
1535fc0a61a4SKonstantin Belousov 			struct timeval tv64;
1536fc0a61a4SKonstantin Belousov 
1537fc0a61a4SKonstantin Belousov 			if (cmd == BIOCSRTIMEOUT32) {
1538fc0a61a4SKonstantin Belousov 				tv32 = (struct timeval32 *)addr;
1539fc0a61a4SKonstantin Belousov 				tv = &tv64;
1540fc0a61a4SKonstantin Belousov 				tv->tv_sec = tv32->tv_sec;
1541fc0a61a4SKonstantin Belousov 				tv->tv_usec = tv32->tv_usec;
1542fc0a61a4SKonstantin Belousov 			} else
1543fc0a61a4SKonstantin Belousov #endif
1544fc0a61a4SKonstantin Belousov 				tv = (struct timeval *)addr;
1545df8bae1dSRodney W. Grimes 
1546bdc2cdc5SAlexander Langer 			/*
1547bdc2cdc5SAlexander Langer 			 * Subtract 1 tick from tvtohz() since this isn't
1548bdc2cdc5SAlexander Langer 			 * a one-shot timer.
1549bdc2cdc5SAlexander Langer 			 */
1550bdc2cdc5SAlexander Langer 			if ((error = itimerfix(tv)) == 0)
1551bdc2cdc5SAlexander Langer 				d->bd_rtout = tvtohz(tv) - 1;
1552df8bae1dSRodney W. Grimes 			break;
1553df8bae1dSRodney W. Grimes 		}
1554df8bae1dSRodney W. Grimes 
1555df8bae1dSRodney W. Grimes 	/*
1556df8bae1dSRodney W. Grimes 	 * Get read timeout.
1557df8bae1dSRodney W. Grimes 	 */
1558df8bae1dSRodney W. Grimes 	case BIOCGRTIMEOUT:
1559b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1560fc0a61a4SKonstantin Belousov 	case BIOCGRTIMEOUT32:
1561fc0a61a4SKonstantin Belousov #endif
1562df8bae1dSRodney W. Grimes 		{
1563fc0a61a4SKonstantin Belousov 			struct timeval *tv;
1564b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1565fc0a61a4SKonstantin Belousov 			struct timeval32 *tv32;
1566fc0a61a4SKonstantin Belousov 			struct timeval tv64;
1567fc0a61a4SKonstantin Belousov 
1568fc0a61a4SKonstantin Belousov 			if (cmd == BIOCGRTIMEOUT32)
1569fc0a61a4SKonstantin Belousov 				tv = &tv64;
1570fc0a61a4SKonstantin Belousov 			else
1571fc0a61a4SKonstantin Belousov #endif
1572fc0a61a4SKonstantin Belousov 				tv = (struct timeval *)addr;
1573df8bae1dSRodney W. Grimes 
1574bdc2cdc5SAlexander Langer 			tv->tv_sec = d->bd_rtout / hz;
1575bdc2cdc5SAlexander Langer 			tv->tv_usec = (d->bd_rtout % hz) * tick;
1576b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1577fc0a61a4SKonstantin Belousov 			if (cmd == BIOCGRTIMEOUT32) {
1578fc0a61a4SKonstantin Belousov 				tv32 = (struct timeval32 *)addr;
1579fc0a61a4SKonstantin Belousov 				tv32->tv_sec = tv->tv_sec;
1580fc0a61a4SKonstantin Belousov 				tv32->tv_usec = tv->tv_usec;
1581fc0a61a4SKonstantin Belousov 			}
1582fc0a61a4SKonstantin Belousov #endif
1583fc0a61a4SKonstantin Belousov 
1584df8bae1dSRodney W. Grimes 			break;
1585df8bae1dSRodney W. Grimes 		}
1586df8bae1dSRodney W. Grimes 
1587df8bae1dSRodney W. Grimes 	/*
1588df8bae1dSRodney W. Grimes 	 * Get packet stats.
1589df8bae1dSRodney W. Grimes 	 */
1590df8bae1dSRodney W. Grimes 	case BIOCGSTATS:
1591df8bae1dSRodney W. Grimes 		{
1592df8bae1dSRodney W. Grimes 			struct bpf_stat *bs = (struct bpf_stat *)addr;
1593df8bae1dSRodney W. Grimes 
15944d621040SChristian S.J. Peron 			/* XXXCSJP overflow */
1595df8bae1dSRodney W. Grimes 			bs->bs_recv = d->bd_rcount;
1596df8bae1dSRodney W. Grimes 			bs->bs_drop = d->bd_dcount;
1597df8bae1dSRodney W. Grimes 			break;
1598df8bae1dSRodney W. Grimes 		}
1599df8bae1dSRodney W. Grimes 
1600df8bae1dSRodney W. Grimes 	/*
1601df8bae1dSRodney W. Grimes 	 * Set immediate mode.
1602df8bae1dSRodney W. Grimes 	 */
1603df8bae1dSRodney W. Grimes 	case BIOCIMMEDIATE:
160497aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1605df8bae1dSRodney W. Grimes 		d->bd_immediate = *(u_int *)addr;
160697aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1607df8bae1dSRodney W. Grimes 		break;
1608df8bae1dSRodney W. Grimes 
1609df8bae1dSRodney W. Grimes 	case BIOCVERSION:
1610df8bae1dSRodney W. Grimes 		{
1611df8bae1dSRodney W. Grimes 			struct bpf_version *bv = (struct bpf_version *)addr;
1612df8bae1dSRodney W. Grimes 
1613df8bae1dSRodney W. Grimes 			bv->bv_major = BPF_MAJOR_VERSION;
1614df8bae1dSRodney W. Grimes 			bv->bv_minor = BPF_MINOR_VERSION;
1615df8bae1dSRodney W. Grimes 			break;
1616df8bae1dSRodney W. Grimes 		}
161700a83887SPaul Traina 
1618114ae644SMike Smith 	/*
1619114ae644SMike Smith 	 * Get "header already complete" flag
1620114ae644SMike Smith 	 */
1621114ae644SMike Smith 	case BIOCGHDRCMPLT:
162297aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1623114ae644SMike Smith 		*(u_int *)addr = d->bd_hdrcmplt;
162497aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1625114ae644SMike Smith 		break;
1626114ae644SMike Smith 
1627114ae644SMike Smith 	/*
1628114ae644SMike Smith 	 * Set "header already complete" flag
1629114ae644SMike Smith 	 */
1630114ae644SMike Smith 	case BIOCSHDRCMPLT:
163197aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1632114ae644SMike Smith 		d->bd_hdrcmplt = *(u_int *)addr ? 1 : 0;
163397aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1634114ae644SMike Smith 		break;
1635114ae644SMike Smith 
16368ed3828cSRobert Watson 	/*
1637560a54e1SJung-uk Kim 	 * Get packet direction flag
16388ed3828cSRobert Watson 	 */
1639560a54e1SJung-uk Kim 	case BIOCGDIRECTION:
164097aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1641560a54e1SJung-uk Kim 		*(u_int *)addr = d->bd_direction;
164297aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
16438ed3828cSRobert Watson 		break;
16448ed3828cSRobert Watson 
16458ed3828cSRobert Watson 	/*
1646560a54e1SJung-uk Kim 	 * Set packet direction flag
16478ed3828cSRobert Watson 	 */
1648560a54e1SJung-uk Kim 	case BIOCSDIRECTION:
1649560a54e1SJung-uk Kim 		{
1650560a54e1SJung-uk Kim 			u_int	direction;
1651560a54e1SJung-uk Kim 
1652560a54e1SJung-uk Kim 			direction = *(u_int *)addr;
1653560a54e1SJung-uk Kim 			switch (direction) {
1654560a54e1SJung-uk Kim 			case BPF_D_IN:
1655560a54e1SJung-uk Kim 			case BPF_D_INOUT:
1656560a54e1SJung-uk Kim 			case BPF_D_OUT:
165797aacec6SAlexander V. Chernikov 				BPFD_LOCK(d);
1658560a54e1SJung-uk Kim 				d->bd_direction = direction;
165997aacec6SAlexander V. Chernikov 				BPFD_UNLOCK(d);
1660560a54e1SJung-uk Kim 				break;
1661560a54e1SJung-uk Kim 			default:
1662560a54e1SJung-uk Kim 				error = EINVAL;
1663560a54e1SJung-uk Kim 			}
1664560a54e1SJung-uk Kim 		}
1665560a54e1SJung-uk Kim 		break;
1666560a54e1SJung-uk Kim 
1667547d94bdSJung-uk Kim 	/*
1668d0d7bcdfSJung-uk Kim 	 * Get packet timestamp format and resolution.
1669547d94bdSJung-uk Kim 	 */
1670547d94bdSJung-uk Kim 	case BIOCGTSTAMP:
167197aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1672547d94bdSJung-uk Kim 		*(u_int *)addr = d->bd_tstamp;
167397aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1674547d94bdSJung-uk Kim 		break;
1675547d94bdSJung-uk Kim 
1676547d94bdSJung-uk Kim 	/*
1677547d94bdSJung-uk Kim 	 * Set packet timestamp format and resolution.
1678547d94bdSJung-uk Kim 	 */
1679547d94bdSJung-uk Kim 	case BIOCSTSTAMP:
1680547d94bdSJung-uk Kim 		{
1681547d94bdSJung-uk Kim 			u_int	func;
1682547d94bdSJung-uk Kim 
1683547d94bdSJung-uk Kim 			func = *(u_int *)addr;
1684547d94bdSJung-uk Kim 			if (BPF_T_VALID(func))
1685547d94bdSJung-uk Kim 				d->bd_tstamp = func;
1686547d94bdSJung-uk Kim 			else
1687547d94bdSJung-uk Kim 				error = EINVAL;
1688547d94bdSJung-uk Kim 		}
1689547d94bdSJung-uk Kim 		break;
1690547d94bdSJung-uk Kim 
1691560a54e1SJung-uk Kim 	case BIOCFEEDBACK:
169297aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1693560a54e1SJung-uk Kim 		d->bd_feedback = *(u_int *)addr;
169497aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1695560a54e1SJung-uk Kim 		break;
1696560a54e1SJung-uk Kim 
1697560a54e1SJung-uk Kim 	case BIOCLOCK:
169897aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1699560a54e1SJung-uk Kim 		d->bd_locked = 1;
170097aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
17018ed3828cSRobert Watson 		break;
17028ed3828cSRobert Watson 
170300a83887SPaul Traina 	case FIONBIO:		/* Non-blocking I/O */
170400a83887SPaul Traina 		break;
170500a83887SPaul Traina 
170600a83887SPaul Traina 	case FIOASYNC:		/* Send signal on receive packets */
170797aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
170800a83887SPaul Traina 		d->bd_async = *(int *)addr;
170997aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
171000a83887SPaul Traina 		break;
171100a83887SPaul Traina 
1712831d27a9SDon Lewis 	case FIOSETOWN:
171397aacec6SAlexander V. Chernikov 		/*
171497aacec6SAlexander V. Chernikov 		 * XXX: Add some sort of locking here?
171597aacec6SAlexander V. Chernikov 		 * fsetown() can sleep.
171697aacec6SAlexander V. Chernikov 		 */
1717831d27a9SDon Lewis 		error = fsetown(*(int *)addr, &d->bd_sigio);
171800a83887SPaul Traina 		break;
171900a83887SPaul Traina 
1720831d27a9SDon Lewis 	case FIOGETOWN:
172197aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
172291e97a82SDon Lewis 		*(int *)addr = fgetown(&d->bd_sigio);
172397aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1724831d27a9SDon Lewis 		break;
1725831d27a9SDon Lewis 
1726831d27a9SDon Lewis 	/* This is deprecated, FIOSETOWN should be used instead. */
1727831d27a9SDon Lewis 	case TIOCSPGRP:
1728831d27a9SDon Lewis 		error = fsetown(-(*(int *)addr), &d->bd_sigio);
1729831d27a9SDon Lewis 		break;
1730831d27a9SDon Lewis 
1731831d27a9SDon Lewis 	/* This is deprecated, FIOGETOWN should be used instead. */
173200a83887SPaul Traina 	case TIOCGPGRP:
173391e97a82SDon Lewis 		*(int *)addr = -fgetown(&d->bd_sigio);
173400a83887SPaul Traina 		break;
173500a83887SPaul Traina 
173600a83887SPaul Traina 	case BIOCSRSIG:		/* Set receive signal */
173700a83887SPaul Traina 		{
173800a83887SPaul Traina 			u_int sig;
173900a83887SPaul Traina 
174000a83887SPaul Traina 			sig = *(u_int *)addr;
174100a83887SPaul Traina 
174200a83887SPaul Traina 			if (sig >= NSIG)
174300a83887SPaul Traina 				error = EINVAL;
174497aacec6SAlexander V. Chernikov 			else {
174597aacec6SAlexander V. Chernikov 				BPFD_LOCK(d);
174600a83887SPaul Traina 				d->bd_sig = sig;
174797aacec6SAlexander V. Chernikov 				BPFD_UNLOCK(d);
174897aacec6SAlexander V. Chernikov 			}
174900a83887SPaul Traina 			break;
175000a83887SPaul Traina 		}
175100a83887SPaul Traina 	case BIOCGRSIG:
175297aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
175300a83887SPaul Traina 		*(u_int *)addr = d->bd_sig;
175497aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
175500a83887SPaul Traina 		break;
17564d621040SChristian S.J. Peron 
17574d621040SChristian S.J. Peron 	case BIOCGETBUFMODE:
175897aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
17594d621040SChristian S.J. Peron 		*(u_int *)addr = d->bd_bufmode;
176097aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
17614d621040SChristian S.J. Peron 		break;
17624d621040SChristian S.J. Peron 
17634d621040SChristian S.J. Peron 	case BIOCSETBUFMODE:
17644d621040SChristian S.J. Peron 		/*
17654d621040SChristian S.J. Peron 		 * Allow the buffering mode to be changed as long as we
17664d621040SChristian S.J. Peron 		 * haven't yet committed to a particular mode.  Our
17674d621040SChristian S.J. Peron 		 * definition of commitment, for now, is whether or not a
17684d621040SChristian S.J. Peron 		 * buffer has been allocated or an interface attached, since
17694d621040SChristian S.J. Peron 		 * that's the point where things get tricky.
17704d621040SChristian S.J. Peron 		 */
17714d621040SChristian S.J. Peron 		switch (*(u_int *)addr) {
17724d621040SChristian S.J. Peron 		case BPF_BUFMODE_BUFFER:
17734d621040SChristian S.J. Peron 			break;
17744d621040SChristian S.J. Peron 
17754d621040SChristian S.J. Peron 		case BPF_BUFMODE_ZBUF:
17764d621040SChristian S.J. Peron 			if (bpf_zerocopy_enable)
17774d621040SChristian S.J. Peron 				break;
17784d621040SChristian S.J. Peron 			/* FALLSTHROUGH */
17794d621040SChristian S.J. Peron 
17804d621040SChristian S.J. Peron 		default:
17811b610a74SBjoern A. Zeeb 			CURVNET_RESTORE();
17824d621040SChristian S.J. Peron 			return (EINVAL);
17834d621040SChristian S.J. Peron 		}
17844d621040SChristian S.J. Peron 
1785afa85850SAlexander V. Chernikov 		BPFD_LOCK(d);
17864d621040SChristian S.J. Peron 		if (d->bd_sbuf != NULL || d->bd_hbuf != NULL ||
17874d621040SChristian S.J. Peron 		    d->bd_fbuf != NULL || d->bd_bif != NULL) {
1788afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
17891b610a74SBjoern A. Zeeb 			CURVNET_RESTORE();
17904d621040SChristian S.J. Peron 			return (EBUSY);
17914d621040SChristian S.J. Peron 		}
17924d621040SChristian S.J. Peron 		d->bd_bufmode = *(u_int *)addr;
1793afa85850SAlexander V. Chernikov 		BPFD_UNLOCK(d);
17944d621040SChristian S.J. Peron 		break;
17954d621040SChristian S.J. Peron 
17964d621040SChristian S.J. Peron 	case BIOCGETZMAX:
17971b610a74SBjoern A. Zeeb 		error = bpf_ioctl_getzmax(td, d, (size_t *)addr);
17981b610a74SBjoern A. Zeeb 		break;
17994d621040SChristian S.J. Peron 
18004d621040SChristian S.J. Peron 	case BIOCSETZBUF:
18011b610a74SBjoern A. Zeeb 		error = bpf_ioctl_setzbuf(td, d, (struct bpf_zbuf *)addr);
18021b610a74SBjoern A. Zeeb 		break;
18034d621040SChristian S.J. Peron 
18044d621040SChristian S.J. Peron 	case BIOCROTZBUF:
18051b610a74SBjoern A. Zeeb 		error = bpf_ioctl_rotzbuf(td, d, (struct bpf_zbuf *)addr);
18061b610a74SBjoern A. Zeeb 		break;
1807df8bae1dSRodney W. Grimes 	}
180897021c24SMarko Zec 	CURVNET_RESTORE();
1809df8bae1dSRodney W. Grimes 	return (error);
1810df8bae1dSRodney W. Grimes }
1811df8bae1dSRodney W. Grimes 
1812df8bae1dSRodney W. Grimes /*
1813df8bae1dSRodney W. Grimes  * Set d's packet filter program to fp.  If this file already has a filter,
1814df8bae1dSRodney W. Grimes  * free it and replace it.  Returns EINVAL for bogus requests.
1815784292f8SAlexander V. Chernikov  *
1816784292f8SAlexander V. Chernikov  * Note we need global lock here to serialize bpf_setf() and bpf_setif() calls
1817784292f8SAlexander V. Chernikov  * since reading d->bd_bif can't be protected by d or interface lock due to
1818784292f8SAlexander V. Chernikov  * lock order.
1819784292f8SAlexander V. Chernikov  *
1820784292f8SAlexander V. Chernikov  * Additionally, we have to acquire interface write lock due to bpf_mtap() uses
1821784292f8SAlexander V. Chernikov  * interface read lock to read all filers.
1822784292f8SAlexander V. Chernikov  *
1823df8bae1dSRodney W. Grimes  */
1824f708ef1bSPoul-Henning Kamp static int
182519ba8395SChristian S.J. Peron bpf_setf(struct bpf_d *d, struct bpf_program *fp, u_long cmd)
1826df8bae1dSRodney W. Grimes {
18279b7d4a7fSJung-uk Kim #ifdef COMPAT_FREEBSD32
18289b7d4a7fSJung-uk Kim 	struct bpf_program fp_swab;
18299b7d4a7fSJung-uk Kim 	struct bpf_program32 *fp32;
18309b7d4a7fSJung-uk Kim #endif
1831df8bae1dSRodney W. Grimes 	struct bpf_insn *fcode, *old;
1832293c06a1SRuslan Ermilov #ifdef BPF_JITTER
1833a86227d1SAlexander V. Chernikov 	bpf_jit_filter *jfunc, *ofunc;
1834ae275efcSJung-uk Kim #endif
18358b04b48aSJung-uk Kim 	size_t size;
18368b04b48aSJung-uk Kim 	u_int flen;
18379431cc16SAlexander V. Chernikov 	int need_upgrade;
1838df8bae1dSRodney W. Grimes 
18399b7d4a7fSJung-uk Kim #ifdef COMPAT_FREEBSD32
18406f731135SJung-uk Kim 	switch (cmd) {
18416f731135SJung-uk Kim 	case BIOCSETF32:
18426f731135SJung-uk Kim 	case BIOCSETWF32:
18436f731135SJung-uk Kim 	case BIOCSETFNR32:
1844fc0a61a4SKonstantin Belousov 		fp32 = (struct bpf_program32 *)fp;
1845fc0a61a4SKonstantin Belousov 		fp_swab.bf_len = fp32->bf_len;
1846fc0a61a4SKonstantin Belousov 		fp_swab.bf_insns = (struct bpf_insn *)(uintptr_t)fp32->bf_insns;
1847fc0a61a4SKonstantin Belousov 		fp = &fp_swab;
18486f731135SJung-uk Kim 		switch (cmd) {
18496f731135SJung-uk Kim 		case BIOCSETF32:
18506f731135SJung-uk Kim 			cmd = BIOCSETF;
18516f731135SJung-uk Kim 			break;
18526f731135SJung-uk Kim 		case BIOCSETWF32:
1853fc0a61a4SKonstantin Belousov 			cmd = BIOCSETWF;
18546f731135SJung-uk Kim 			break;
18556f731135SJung-uk Kim 		}
18566f731135SJung-uk Kim 		break;
1857fc0a61a4SKonstantin Belousov 	}
1858fc0a61a4SKonstantin Belousov #endif
18598b04b48aSJung-uk Kim 
18608b04b48aSJung-uk Kim 	fcode = NULL;
18618b04b48aSJung-uk Kim #ifdef BPF_JITTER
18628b04b48aSJung-uk Kim 	jfunc = ofunc = NULL;
18638b04b48aSJung-uk Kim #endif
18649b7d4a7fSJung-uk Kim 	need_upgrade = 0;
18658b04b48aSJung-uk Kim 
18666c74ff0eSAlexander V. Chernikov 	/*
18676c74ff0eSAlexander V. Chernikov 	 * Check new filter validness before acquiring any locks.
18686c74ff0eSAlexander V. Chernikov 	 * Allocate memory for new filter, if needed.
18696c74ff0eSAlexander V. Chernikov 	 */
18706c74ff0eSAlexander V. Chernikov 	flen = fp->bf_len;
18719b7d4a7fSJung-uk Kim 	if (flen > bpf_maxinsns || (fp->bf_insns == NULL && flen != 0))
18726c74ff0eSAlexander V. Chernikov 		return (EINVAL);
18736c74ff0eSAlexander V. Chernikov 	size = flen * sizeof(*fp->bf_insns);
1874a86227d1SAlexander V. Chernikov 	if (size > 0) {
18759b7d4a7fSJung-uk Kim 		/* We're setting up new filter.  Copy and check actual data. */
18769b7d4a7fSJung-uk Kim 		fcode = malloc(size, M_BPF, M_WAITOK);
18779b7d4a7fSJung-uk Kim 		if (copyin(fp->bf_insns, fcode, size) != 0 ||
18789b7d4a7fSJung-uk Kim 		    !bpf_validate(fcode, flen)) {
1879a86227d1SAlexander V. Chernikov 			free(fcode, M_BPF);
1880a86227d1SAlexander V. Chernikov 			return (EINVAL);
1881a86227d1SAlexander V. Chernikov 		}
1882c7b0200eSAlexander V. Chernikov #ifdef BPF_JITTER
18839b7d4a7fSJung-uk Kim 		/* Filter is copied inside fcode and is perfectly valid. */
1884c7b0200eSAlexander V. Chernikov 		jfunc = bpf_jitter(fcode, flen);
1885c7b0200eSAlexander V. Chernikov #endif
18868b04b48aSJung-uk Kim 	}
1887c7b0200eSAlexander V. Chernikov 
18886c74ff0eSAlexander V. Chernikov 	BPF_LOCK();
18896c74ff0eSAlexander V. Chernikov 
1890e4b3229aSAlexander V. Chernikov 	/*
1891a86227d1SAlexander V. Chernikov 	 * Set up new filter.
18929b7d4a7fSJung-uk Kim 	 * Protect filter change by interface lock.
18936c74ff0eSAlexander V. Chernikov 	 * Additionally, we are protected by global lock here.
1894e4b3229aSAlexander V. Chernikov 	 */
18956c74ff0eSAlexander V. Chernikov 	if (d->bd_bif != NULL)
1896e4b3229aSAlexander V. Chernikov 		BPFIF_WLOCK(d->bd_bif);
1897afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
18988b04b48aSJung-uk Kim 	if (cmd == BIOCSETWF) {
18998b04b48aSJung-uk Kim 		old = d->bd_wfilter;
190093e39f0bSChristian S.J. Peron 		d->bd_wfilter = fcode;
19018b04b48aSJung-uk Kim 	} else {
19028b04b48aSJung-uk Kim 		old = d->bd_rfilter;
190393e39f0bSChristian S.J. Peron 		d->bd_rfilter = fcode;
1904293c06a1SRuslan Ermilov #ifdef BPF_JITTER
19058b04b48aSJung-uk Kim 		ofunc = d->bd_bfilter;
1906c7b0200eSAlexander V. Chernikov 		d->bd_bfilter = jfunc;
1907ae275efcSJung-uk Kim #endif
1908f11c3508SDavid Malone 		if (cmd == BIOCSETF)
1909df8bae1dSRodney W. Grimes 			reset_d(d);
191051ec1eb7SAlexander V. Chernikov 
1911402000ffSAlexander V. Chernikov 		need_upgrade = bpf_check_upgrade(cmd, d, fcode, flen);
19128b04b48aSJung-uk Kim 	}
1913afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
19146c74ff0eSAlexander V. Chernikov 	if (d->bd_bif != NULL)
1915e4b3229aSAlexander V. Chernikov 		BPFIF_WUNLOCK(d->bd_bif);
1916572bde2aSRobert Watson 	if (old != NULL)
19179b7d4a7fSJung-uk Kim 		free(old, M_BPF);
1918293c06a1SRuslan Ermilov #ifdef BPF_JITTER
1919ae275efcSJung-uk Kim 	if (ofunc != NULL)
1920ae275efcSJung-uk Kim 		bpf_destroy_jit_filter(ofunc);
1921ae275efcSJung-uk Kim #endif
1922df8bae1dSRodney W. Grimes 
19239b7d4a7fSJung-uk Kim 	/* Move d to active readers list. */
1924402000ffSAlexander V. Chernikov 	if (need_upgrade != 0)
192551ec1eb7SAlexander V. Chernikov 		bpf_upgraded(d);
192651ec1eb7SAlexander V. Chernikov 
19276c74ff0eSAlexander V. Chernikov 	BPF_UNLOCK();
1928df8bae1dSRodney W. Grimes 	return (0);
1929df8bae1dSRodney W. Grimes }
1930df8bae1dSRodney W. Grimes 
1931df8bae1dSRodney W. Grimes /*
1932df8bae1dSRodney W. Grimes  * Detach a file from its current interface (if attached at all) and attach
1933df8bae1dSRodney W. Grimes  * to the interface indicated by the name stored in ifr.
1934df8bae1dSRodney W. Grimes  * Return an errno or 0.
1935df8bae1dSRodney W. Grimes  */
1936df8bae1dSRodney W. Grimes static int
193719ba8395SChristian S.J. Peron bpf_setif(struct bpf_d *d, struct ifreq *ifr)
1938df8bae1dSRodney W. Grimes {
1939df8bae1dSRodney W. Grimes 	struct bpf_if *bp;
19409b44ff22SGarrett Wollman 	struct ifnet *theywant;
1941df8bae1dSRodney W. Grimes 
19426c74ff0eSAlexander V. Chernikov 	BPF_LOCK_ASSERT();
19436c74ff0eSAlexander V. Chernikov 
19449b44ff22SGarrett Wollman 	theywant = ifunit(ifr->ifr_name);
194516d878ccSChristian S.J. Peron 	if (theywant == NULL || theywant->if_bpf == NULL)
194616d878ccSChristian S.J. Peron 		return (ENXIO);
19479b44ff22SGarrett Wollman 
194816d878ccSChristian S.J. Peron 	bp = theywant->if_bpf;
19494d621040SChristian S.J. Peron 
1950afa85850SAlexander V. Chernikov 	/* Check if interface is not being detached from BPF */
1951afa85850SAlexander V. Chernikov 	BPFIF_RLOCK(bp);
1952b23cbbe6SMark Johnston 	if (bp->bif_flags & BPFIF_FLAG_DYING) {
1953afa85850SAlexander V. Chernikov 		BPFIF_RUNLOCK(bp);
1954afa85850SAlexander V. Chernikov 		return (ENXIO);
1955afa85850SAlexander V. Chernikov 	}
1956afa85850SAlexander V. Chernikov 	BPFIF_RUNLOCK(bp);
1957afa85850SAlexander V. Chernikov 
1958df8bae1dSRodney W. Grimes 	/*
19594f42daa4SLuiz Otavio O Souza 	 * At this point, we expect the buffer is already allocated.  If not,
19604f42daa4SLuiz Otavio O Souza 	 * return an error.
1961df8bae1dSRodney W. Grimes 	 */
19624d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
19634d621040SChristian S.J. Peron 	case BPF_BUFMODE_BUFFER:
19644d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
19654d621040SChristian S.J. Peron 		if (d->bd_sbuf == NULL)
19664d621040SChristian S.J. Peron 			return (EINVAL);
19674d621040SChristian S.J. Peron 		break;
19684d621040SChristian S.J. Peron 
19694d621040SChristian S.J. Peron 	default:
19704d621040SChristian S.J. Peron 		panic("bpf_setif: bufmode %d", d->bd_bufmode);
19714d621040SChristian S.J. Peron 	}
19726c74ff0eSAlexander V. Chernikov 	if (bp != d->bd_bif)
1973df8bae1dSRodney W. Grimes 		bpf_attachd(d, bp);
1974afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
1975df8bae1dSRodney W. Grimes 	reset_d(d);
1976afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
1977df8bae1dSRodney W. Grimes 	return (0);
1978df8bae1dSRodney W. Grimes }
1979df8bae1dSRodney W. Grimes 
1980df8bae1dSRodney W. Grimes /*
1981243ac7d8SPeter Wemm  * Support for select() and poll() system calls
1982df8bae1dSRodney W. Grimes  *
1983df8bae1dSRodney W. Grimes  * Return true iff the specific operation will not block indefinitely.
1984df8bae1dSRodney W. Grimes  * Otherwise, return false but make a note that a selwakeup() must be done.
1985df8bae1dSRodney W. Grimes  */
198637c84183SPoul-Henning Kamp static int
198719ba8395SChristian S.J. Peron bpfpoll(struct cdev *dev, int events, struct thread *td)
1988df8bae1dSRodney W. Grimes {
1989e7bb21b3SJonathan Lemon 	struct bpf_d *d;
19900832fc64SGarance A Drosehn 	int revents;
1991df8bae1dSRodney W. Grimes 
1992136600feSEd Schouten 	if (devfs_get_cdevpriv((void **)&d) != 0 || d->bd_bif == NULL)
1993136600feSEd Schouten 		return (events &
1994136600feSEd Schouten 		    (POLLHUP|POLLIN|POLLRDNORM|POLLOUT|POLLWRNORM));
1995de5d9935SRobert Watson 
1996b75a24a0SChristian S.J. Peron 	/*
1997b75a24a0SChristian S.J. Peron 	 * Refresh PID associated with this descriptor.
1998b75a24a0SChristian S.J. Peron 	 */
19990832fc64SGarance A Drosehn 	revents = events & (POLLOUT | POLLWRNORM);
2000afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
2001e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH(d, td);
200275c13541SPoul-Henning Kamp 	if (events & (POLLIN | POLLRDNORM)) {
200395aab9ccSJohn-Mark Gurney 		if (bpf_ready(d))
2004243ac7d8SPeter Wemm 			revents |= events & (POLLIN | POLLRDNORM);
200581bda851SJohn Polstra 		else {
2006ed01445dSJohn Baldwin 			selrecord(td, &d->bd_sel);
200781bda851SJohn Polstra 			/* Start the read timeout if necessary. */
200881bda851SJohn Polstra 			if (d->bd_rtout > 0 && d->bd_state == BPF_IDLE) {
200981bda851SJohn Polstra 				callout_reset(&d->bd_callout, d->bd_rtout,
201081bda851SJohn Polstra 				    bpf_timed_out, d);
201181bda851SJohn Polstra 				d->bd_state = BPF_WAITING;
201281bda851SJohn Polstra 			}
201381bda851SJohn Polstra 		}
201475c13541SPoul-Henning Kamp 	}
2015afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
2016243ac7d8SPeter Wemm 	return (revents);
2017df8bae1dSRodney W. Grimes }
2018df8bae1dSRodney W. Grimes 
2019df8bae1dSRodney W. Grimes /*
202095aab9ccSJohn-Mark Gurney  * Support for kevent() system call.  Register EVFILT_READ filters and
202195aab9ccSJohn-Mark Gurney  * reject all others.
202295aab9ccSJohn-Mark Gurney  */
202395aab9ccSJohn-Mark Gurney int
202419ba8395SChristian S.J. Peron bpfkqfilter(struct cdev *dev, struct knote *kn)
202595aab9ccSJohn-Mark Gurney {
2026136600feSEd Schouten 	struct bpf_d *d;
202795aab9ccSJohn-Mark Gurney 
2028136600feSEd Schouten 	if (devfs_get_cdevpriv((void **)&d) != 0 ||
2029136600feSEd Schouten 	    kn->kn_filter != EVFILT_READ)
203095aab9ccSJohn-Mark Gurney 		return (1);
203195aab9ccSJohn-Mark Gurney 
2032b75a24a0SChristian S.J. Peron 	/*
2033b75a24a0SChristian S.J. Peron 	 * Refresh PID associated with this descriptor.
2034b75a24a0SChristian S.J. Peron 	 */
2035afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
2036e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH_CUR(d);
203795aab9ccSJohn-Mark Gurney 	kn->kn_fop = &bpfread_filtops;
203895aab9ccSJohn-Mark Gurney 	kn->kn_hook = d;
20394b19419eSChristian S.J. Peron 	knlist_add(&d->bd_sel.si_note, kn, 1);
2040afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
204195aab9ccSJohn-Mark Gurney 
204295aab9ccSJohn-Mark Gurney 	return (0);
204395aab9ccSJohn-Mark Gurney }
204495aab9ccSJohn-Mark Gurney 
204595aab9ccSJohn-Mark Gurney static void
204619ba8395SChristian S.J. Peron filt_bpfdetach(struct knote *kn)
204795aab9ccSJohn-Mark Gurney {
204895aab9ccSJohn-Mark Gurney 	struct bpf_d *d = (struct bpf_d *)kn->kn_hook;
204995aab9ccSJohn-Mark Gurney 
2050ad3b9257SJohn-Mark Gurney 	knlist_remove(&d->bd_sel.si_note, kn, 0);
205195aab9ccSJohn-Mark Gurney }
205295aab9ccSJohn-Mark Gurney 
205395aab9ccSJohn-Mark Gurney static int
205419ba8395SChristian S.J. Peron filt_bpfread(struct knote *kn, long hint)
205595aab9ccSJohn-Mark Gurney {
205695aab9ccSJohn-Mark Gurney 	struct bpf_d *d = (struct bpf_d *)kn->kn_hook;
205795aab9ccSJohn-Mark Gurney 	int ready;
205895aab9ccSJohn-Mark Gurney 
2059afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
206095aab9ccSJohn-Mark Gurney 	ready = bpf_ready(d);
206195aab9ccSJohn-Mark Gurney 	if (ready) {
206295aab9ccSJohn-Mark Gurney 		kn->kn_data = d->bd_slen;
206392242172SLuiz Otavio O Souza 		/*
206492242172SLuiz Otavio O Souza 		 * Ignore the hold buffer if it is being copied to user space.
206592242172SLuiz Otavio O Souza 		 */
206692242172SLuiz Otavio O Souza 		if (!d->bd_hbuf_in_use && d->bd_hbuf)
206795aab9ccSJohn-Mark Gurney 			kn->kn_data += d->bd_hlen;
20685d7af3a1SJung-uk Kim 	} else if (d->bd_rtout > 0 && d->bd_state == BPF_IDLE) {
206995aab9ccSJohn-Mark Gurney 		callout_reset(&d->bd_callout, d->bd_rtout,
207095aab9ccSJohn-Mark Gurney 		    bpf_timed_out, d);
207195aab9ccSJohn-Mark Gurney 		d->bd_state = BPF_WAITING;
207295aab9ccSJohn-Mark Gurney 	}
207395aab9ccSJohn-Mark Gurney 
207495aab9ccSJohn-Mark Gurney 	return (ready);
207595aab9ccSJohn-Mark Gurney }
207695aab9ccSJohn-Mark Gurney 
2077253a3814SLawrence Stewart #define	BPF_TSTAMP_NONE		0
2078253a3814SLawrence Stewart #define	BPF_TSTAMP_FAST		1
2079253a3814SLawrence Stewart #define	BPF_TSTAMP_NORMAL	2
2080253a3814SLawrence Stewart #define	BPF_TSTAMP_EXTERN	3
2081253a3814SLawrence Stewart 
2082253a3814SLawrence Stewart static int
2083253a3814SLawrence Stewart bpf_ts_quality(int tstype)
2084253a3814SLawrence Stewart {
2085253a3814SLawrence Stewart 
2086253a3814SLawrence Stewart 	if (tstype == BPF_T_NONE)
2087253a3814SLawrence Stewart 		return (BPF_TSTAMP_NONE);
2088253a3814SLawrence Stewart 	if ((tstype & BPF_T_FAST) != 0)
2089253a3814SLawrence Stewart 		return (BPF_TSTAMP_FAST);
2090253a3814SLawrence Stewart 
2091253a3814SLawrence Stewart 	return (BPF_TSTAMP_NORMAL);
2092253a3814SLawrence Stewart }
2093253a3814SLawrence Stewart 
2094253a3814SLawrence Stewart static int
2095253a3814SLawrence Stewart bpf_gettime(struct bintime *bt, int tstype, struct mbuf *m)
2096253a3814SLawrence Stewart {
2097253a3814SLawrence Stewart 	struct m_tag *tag;
2098253a3814SLawrence Stewart 	int quality;
2099253a3814SLawrence Stewart 
2100253a3814SLawrence Stewart 	quality = bpf_ts_quality(tstype);
2101253a3814SLawrence Stewart 	if (quality == BPF_TSTAMP_NONE)
2102253a3814SLawrence Stewart 		return (quality);
2103253a3814SLawrence Stewart 
2104253a3814SLawrence Stewart 	if (m != NULL) {
2105253a3814SLawrence Stewart 		tag = m_tag_locate(m, MTAG_BPF, MTAG_BPF_TIMESTAMP, NULL);
2106253a3814SLawrence Stewart 		if (tag != NULL) {
2107253a3814SLawrence Stewart 			*bt = *(struct bintime *)(tag + 1);
2108253a3814SLawrence Stewart 			return (BPF_TSTAMP_EXTERN);
2109253a3814SLawrence Stewart 		}
2110253a3814SLawrence Stewart 	}
2111253a3814SLawrence Stewart 	if (quality == BPF_TSTAMP_NORMAL)
2112253a3814SLawrence Stewart 		binuptime(bt);
2113253a3814SLawrence Stewart 	else
2114253a3814SLawrence Stewart 		getbinuptime(bt);
2115253a3814SLawrence Stewart 
2116253a3814SLawrence Stewart 	return (quality);
2117253a3814SLawrence Stewart }
2118253a3814SLawrence Stewart 
211995aab9ccSJohn-Mark Gurney /*
2120df8bae1dSRodney W. Grimes  * Incoming linkage from device drivers.  Process the packet pkt, of length
2121df8bae1dSRodney W. Grimes  * pktlen, which is stored in a contiguous buffer.  The packet is parsed
2122df8bae1dSRodney W. Grimes  * by each process' filter, and if accepted, stashed into the corresponding
2123df8bae1dSRodney W. Grimes  * buffer.
2124df8bae1dSRodney W. Grimes  */
2125df8bae1dSRodney W. Grimes void
212619ba8395SChristian S.J. Peron bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen)
2127df8bae1dSRodney W. Grimes {
2128547d94bdSJung-uk Kim 	struct bintime bt;
21298994a245SDag-Erling Smørgrav 	struct bpf_d *d;
2130a36599ccSJung-uk Kim #ifdef BPF_JITTER
2131a36599ccSJung-uk Kim 	bpf_jit_filter *bf;
2132a36599ccSJung-uk Kim #endif
2133253a3814SLawrence Stewart 	u_int slen;
2134253a3814SLawrence Stewart 	int gottime;
2135e7bb21b3SJonathan Lemon 
2136253a3814SLawrence Stewart 	gottime = BPF_TSTAMP_NONE;
2137e4b3229aSAlexander V. Chernikov 
2138e4b3229aSAlexander V. Chernikov 	BPFIF_RLOCK(bp);
2139e4b3229aSAlexander V. Chernikov 
21404a3feeaaSRobert Watson 	LIST_FOREACH(d, &bp->bif_dlist, bd_next) {
2141e4b3229aSAlexander V. Chernikov 		/*
2142e4b3229aSAlexander V. Chernikov 		 * We are not using any locks for d here because:
2143e4b3229aSAlexander V. Chernikov 		 * 1) any filter change is protected by interface
2144e4b3229aSAlexander V. Chernikov 		 * write lock
2145e4b3229aSAlexander V. Chernikov 		 * 2) destroying/detaching d is protected by interface
2146e4b3229aSAlexander V. Chernikov 		 * write lock, too
2147e4b3229aSAlexander V. Chernikov 		 */
2148e4b3229aSAlexander V. Chernikov 
2149e4b3229aSAlexander V. Chernikov 		/* XXX: Do not protect counter for the sake of performance. */
2150df8bae1dSRodney W. Grimes 		++d->bd_rcount;
2151a05cf8c6SChristian S.J. Peron 		/*
2152a05cf8c6SChristian S.J. Peron 		 * NB: We dont call BPF_CHECK_DIRECTION() here since there is no
2153a05cf8c6SChristian S.J. Peron 		 * way for the caller to indiciate to us whether this packet
2154a05cf8c6SChristian S.J. Peron 		 * is inbound or outbound.  In the bpf_mtap() routines, we use
2155a05cf8c6SChristian S.J. Peron 		 * the interface pointers on the mbuf to figure it out.
2156a05cf8c6SChristian S.J. Peron 		 */
2157ae275efcSJung-uk Kim #ifdef BPF_JITTER
2158a36599ccSJung-uk Kim 		bf = bpf_jitter_enable != 0 ? d->bd_bfilter : NULL;
2159a36599ccSJung-uk Kim 		if (bf != NULL)
2160a36599ccSJung-uk Kim 			slen = (*(bf->func))(pkt, pktlen, pktlen);
2161ae275efcSJung-uk Kim 		else
2162ae275efcSJung-uk Kim #endif
216393e39f0bSChristian S.J. Peron 		slen = bpf_filter(d->bd_rfilter, pkt, pktlen, pktlen);
2164ec272d87SRobert Watson 		if (slen != 0) {
2165e4b3229aSAlexander V. Chernikov 			/*
2166e4b3229aSAlexander V. Chernikov 			 * Filter matches. Let's to acquire write lock.
2167e4b3229aSAlexander V. Chernikov 			 */
2168afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
2169e4b3229aSAlexander V. Chernikov 
217069f7644bSChristian S.J. Peron 			d->bd_fcount++;
2171253a3814SLawrence Stewart 			if (gottime < bpf_ts_quality(d->bd_tstamp))
2172253a3814SLawrence Stewart 				gottime = bpf_gettime(&bt, d->bd_tstamp, NULL);
2173ec272d87SRobert Watson #ifdef MAC
217430d239bcSRobert Watson 			if (mac_bpfdesc_check_receive(d, bp->bif_ifp) == 0)
2175ec272d87SRobert Watson #endif
21764d621040SChristian S.J. Peron 				catchpacket(d, pkt, pktlen, slen,
2177547d94bdSJung-uk Kim 				    bpf_append_bytes, &bt);
2178afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
2179ec272d87SRobert Watson 		}
2180df8bae1dSRodney W. Grimes 	}
2181e4b3229aSAlexander V. Chernikov 	BPFIF_RUNLOCK(bp);
2182df8bae1dSRodney W. Grimes }
2183df8bae1dSRodney W. Grimes 
2184f81a2a49SJung-uk Kim #define	BPF_CHECK_DIRECTION(d, r, i)				\
2185f81a2a49SJung-uk Kim 	    (((d)->bd_direction == BPF_D_IN && (r) != (i)) ||	\
2186f81a2a49SJung-uk Kim 	    ((d)->bd_direction == BPF_D_OUT && (r) == (i)))
2187560a54e1SJung-uk Kim 
2188df8bae1dSRodney W. Grimes /*
2189df8bae1dSRodney W. Grimes  * Incoming linkage from device drivers, when packet is in an mbuf chain.
2190e4b3229aSAlexander V. Chernikov  * Locking model is explained in bpf_tap().
2191df8bae1dSRodney W. Grimes  */
2192df8bae1dSRodney W. Grimes void
219319ba8395SChristian S.J. Peron bpf_mtap(struct bpf_if *bp, struct mbuf *m)
2194df8bae1dSRodney W. Grimes {
2195547d94bdSJung-uk Kim 	struct bintime bt;
2196df8bae1dSRodney W. Grimes 	struct bpf_d *d;
2197a36599ccSJung-uk Kim #ifdef BPF_JITTER
2198a36599ccSJung-uk Kim 	bpf_jit_filter *bf;
2199a36599ccSJung-uk Kim #endif
2200253a3814SLawrence Stewart 	u_int pktlen, slen;
2201253a3814SLawrence Stewart 	int gottime;
220291433904SDavid Malone 
22038cd892f7SJung-uk Kim 	/* Skip outgoing duplicate packets. */
22048cd892f7SJung-uk Kim 	if ((m->m_flags & M_PROMISC) != 0 && m->m_pkthdr.rcvif == NULL) {
22058cd892f7SJung-uk Kim 		m->m_flags &= ~M_PROMISC;
22068cd892f7SJung-uk Kim 		return;
22078cd892f7SJung-uk Kim 	}
22088cd892f7SJung-uk Kim 
2209f0e2422bSPoul-Henning Kamp 	pktlen = m_length(m, NULL);
2210253a3814SLawrence Stewart 	gottime = BPF_TSTAMP_NONE;
2211e4b3229aSAlexander V. Chernikov 
2212e4b3229aSAlexander V. Chernikov 	BPFIF_RLOCK(bp);
2213e4b3229aSAlexander V. Chernikov 
22144a3feeaaSRobert Watson 	LIST_FOREACH(d, &bp->bif_dlist, bd_next) {
2215f81a2a49SJung-uk Kim 		if (BPF_CHECK_DIRECTION(d, m->m_pkthdr.rcvif, bp->bif_ifp))
22168ed3828cSRobert Watson 			continue;
2217df8bae1dSRodney W. Grimes 		++d->bd_rcount;
2218ae275efcSJung-uk Kim #ifdef BPF_JITTER
2219a36599ccSJung-uk Kim 		bf = bpf_jitter_enable != 0 ? d->bd_bfilter : NULL;
2220ae275efcSJung-uk Kim 		/* XXX We cannot handle multiple mbufs. */
2221a36599ccSJung-uk Kim 		if (bf != NULL && m->m_next == NULL)
2222a36599ccSJung-uk Kim 			slen = (*(bf->func))(mtod(m, u_char *), pktlen, pktlen);
2223ae275efcSJung-uk Kim 		else
2224ae275efcSJung-uk Kim #endif
222593e39f0bSChristian S.J. Peron 		slen = bpf_filter(d->bd_rfilter, (u_char *)m, pktlen, 0);
22264ddfb531SChristian S.J. Peron 		if (slen != 0) {
2227afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
2228e4b3229aSAlexander V. Chernikov 
222969f7644bSChristian S.J. Peron 			d->bd_fcount++;
2230253a3814SLawrence Stewart 			if (gottime < bpf_ts_quality(d->bd_tstamp))
2231253a3814SLawrence Stewart 				gottime = bpf_gettime(&bt, d->bd_tstamp, m);
22320c7fb534SRobert Watson #ifdef MAC
223330d239bcSRobert Watson 			if (mac_bpfdesc_check_receive(d, bp->bif_ifp) == 0)
22340c7fb534SRobert Watson #endif
22350c7fb534SRobert Watson 				catchpacket(d, (u_char *)m, pktlen, slen,
2236547d94bdSJung-uk Kim 				    bpf_append_mbuf, &bt);
2237afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
22384ddfb531SChristian S.J. Peron 		}
2239df8bae1dSRodney W. Grimes 	}
2240e4b3229aSAlexander V. Chernikov 	BPFIF_RUNLOCK(bp);
2241df8bae1dSRodney W. Grimes }
2242df8bae1dSRodney W. Grimes 
2243df8bae1dSRodney W. Grimes /*
2244437ffe18SSam Leffler  * Incoming linkage from device drivers, when packet is in
2245437ffe18SSam Leffler  * an mbuf chain and to be prepended by a contiguous header.
2246437ffe18SSam Leffler  */
2247437ffe18SSam Leffler void
224819ba8395SChristian S.J. Peron bpf_mtap2(struct bpf_if *bp, void *data, u_int dlen, struct mbuf *m)
2249437ffe18SSam Leffler {
2250547d94bdSJung-uk Kim 	struct bintime bt;
2251437ffe18SSam Leffler 	struct mbuf mb;
2252437ffe18SSam Leffler 	struct bpf_d *d;
2253253a3814SLawrence Stewart 	u_int pktlen, slen;
2254253a3814SLawrence Stewart 	int gottime;
225591433904SDavid Malone 
22568cd892f7SJung-uk Kim 	/* Skip outgoing duplicate packets. */
22578cd892f7SJung-uk Kim 	if ((m->m_flags & M_PROMISC) != 0 && m->m_pkthdr.rcvif == NULL) {
22588cd892f7SJung-uk Kim 		m->m_flags &= ~M_PROMISC;
22598cd892f7SJung-uk Kim 		return;
22608cd892f7SJung-uk Kim 	}
22618cd892f7SJung-uk Kim 
2262437ffe18SSam Leffler 	pktlen = m_length(m, NULL);
2263437ffe18SSam Leffler 	/*
2264437ffe18SSam Leffler 	 * Craft on-stack mbuf suitable for passing to bpf_filter.
2265437ffe18SSam Leffler 	 * Note that we cut corners here; we only setup what's
2266437ffe18SSam Leffler 	 * absolutely needed--this mbuf should never go anywhere else.
2267437ffe18SSam Leffler 	 */
2268437ffe18SSam Leffler 	mb.m_next = m;
2269437ffe18SSam Leffler 	mb.m_data = data;
2270437ffe18SSam Leffler 	mb.m_len = dlen;
2271437ffe18SSam Leffler 	pktlen += dlen;
2272437ffe18SSam Leffler 
2273253a3814SLawrence Stewart 	gottime = BPF_TSTAMP_NONE;
2274e4b3229aSAlexander V. Chernikov 
2275e4b3229aSAlexander V. Chernikov 	BPFIF_RLOCK(bp);
2276e4b3229aSAlexander V. Chernikov 
22774a3feeaaSRobert Watson 	LIST_FOREACH(d, &bp->bif_dlist, bd_next) {
2278f81a2a49SJung-uk Kim 		if (BPF_CHECK_DIRECTION(d, m->m_pkthdr.rcvif, bp->bif_ifp))
2279437ffe18SSam Leffler 			continue;
2280437ffe18SSam Leffler 		++d->bd_rcount;
228193e39f0bSChristian S.J. Peron 		slen = bpf_filter(d->bd_rfilter, (u_char *)&mb, pktlen, 0);
22824ddfb531SChristian S.J. Peron 		if (slen != 0) {
2283afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
2284e4b3229aSAlexander V. Chernikov 
228569f7644bSChristian S.J. Peron 			d->bd_fcount++;
2286253a3814SLawrence Stewart 			if (gottime < bpf_ts_quality(d->bd_tstamp))
2287253a3814SLawrence Stewart 				gottime = bpf_gettime(&bt, d->bd_tstamp, m);
2288437ffe18SSam Leffler #ifdef MAC
228930d239bcSRobert Watson 			if (mac_bpfdesc_check_receive(d, bp->bif_ifp) == 0)
2290437ffe18SSam Leffler #endif
2291437ffe18SSam Leffler 				catchpacket(d, (u_char *)&mb, pktlen, slen,
2292547d94bdSJung-uk Kim 				    bpf_append_mbuf, &bt);
2293afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
22944ddfb531SChristian S.J. Peron 		}
2295437ffe18SSam Leffler 	}
2296e4b3229aSAlexander V. Chernikov 	BPFIF_RUNLOCK(bp);
2297437ffe18SSam Leffler }
2298437ffe18SSam Leffler 
2299560a54e1SJung-uk Kim #undef	BPF_CHECK_DIRECTION
2300560a54e1SJung-uk Kim 
2301253a3814SLawrence Stewart #undef	BPF_TSTAMP_NONE
2302253a3814SLawrence Stewart #undef	BPF_TSTAMP_FAST
2303253a3814SLawrence Stewart #undef	BPF_TSTAMP_NORMAL
2304253a3814SLawrence Stewart #undef	BPF_TSTAMP_EXTERN
2305253a3814SLawrence Stewart 
2306547d94bdSJung-uk Kim static int
2307547d94bdSJung-uk Kim bpf_hdrlen(struct bpf_d *d)
2308547d94bdSJung-uk Kim {
2309547d94bdSJung-uk Kim 	int hdrlen;
2310547d94bdSJung-uk Kim 
2311547d94bdSJung-uk Kim 	hdrlen = d->bd_bif->bif_hdrlen;
2312547d94bdSJung-uk Kim #ifndef BURN_BRIDGES
2313547d94bdSJung-uk Kim 	if (d->bd_tstamp == BPF_T_NONE ||
2314547d94bdSJung-uk Kim 	    BPF_T_FORMAT(d->bd_tstamp) == BPF_T_MICROTIME)
2315547d94bdSJung-uk Kim #ifdef COMPAT_FREEBSD32
2316547d94bdSJung-uk Kim 		if (d->bd_compat32)
2317547d94bdSJung-uk Kim 			hdrlen += SIZEOF_BPF_HDR(struct bpf_hdr32);
2318547d94bdSJung-uk Kim 		else
2319547d94bdSJung-uk Kim #endif
2320547d94bdSJung-uk Kim 			hdrlen += SIZEOF_BPF_HDR(struct bpf_hdr);
2321547d94bdSJung-uk Kim 	else
2322547d94bdSJung-uk Kim #endif
2323547d94bdSJung-uk Kim 		hdrlen += SIZEOF_BPF_HDR(struct bpf_xhdr);
2324547d94bdSJung-uk Kim #ifdef COMPAT_FREEBSD32
2325547d94bdSJung-uk Kim 	if (d->bd_compat32)
2326547d94bdSJung-uk Kim 		hdrlen = BPF_WORDALIGN32(hdrlen);
2327547d94bdSJung-uk Kim 	else
2328547d94bdSJung-uk Kim #endif
2329547d94bdSJung-uk Kim 		hdrlen = BPF_WORDALIGN(hdrlen);
2330547d94bdSJung-uk Kim 
2331547d94bdSJung-uk Kim 	return (hdrlen - d->bd_bif->bif_hdrlen);
2332547d94bdSJung-uk Kim }
2333547d94bdSJung-uk Kim 
2334547d94bdSJung-uk Kim static void
2335547d94bdSJung-uk Kim bpf_bintime2ts(struct bintime *bt, struct bpf_ts *ts, int tstype)
2336547d94bdSJung-uk Kim {
2337584b675eSKonstantin Belousov 	struct bintime bt2, boottimebin;
2338547d94bdSJung-uk Kim 	struct timeval tsm;
2339547d94bdSJung-uk Kim 	struct timespec tsn;
2340547d94bdSJung-uk Kim 
2341253a3814SLawrence Stewart 	if ((tstype & BPF_T_MONOTONIC) == 0) {
2342253a3814SLawrence Stewart 		bt2 = *bt;
2343584b675eSKonstantin Belousov 		getboottimebin(&boottimebin);
2344253a3814SLawrence Stewart 		bintime_add(&bt2, &boottimebin);
2345253a3814SLawrence Stewart 		bt = &bt2;
2346253a3814SLawrence Stewart 	}
2347547d94bdSJung-uk Kim 	switch (BPF_T_FORMAT(tstype)) {
2348547d94bdSJung-uk Kim 	case BPF_T_MICROTIME:
2349547d94bdSJung-uk Kim 		bintime2timeval(bt, &tsm);
2350547d94bdSJung-uk Kim 		ts->bt_sec = tsm.tv_sec;
2351547d94bdSJung-uk Kim 		ts->bt_frac = tsm.tv_usec;
2352547d94bdSJung-uk Kim 		break;
2353547d94bdSJung-uk Kim 	case BPF_T_NANOTIME:
2354547d94bdSJung-uk Kim 		bintime2timespec(bt, &tsn);
2355547d94bdSJung-uk Kim 		ts->bt_sec = tsn.tv_sec;
2356547d94bdSJung-uk Kim 		ts->bt_frac = tsn.tv_nsec;
2357547d94bdSJung-uk Kim 		break;
2358547d94bdSJung-uk Kim 	case BPF_T_BINTIME:
2359547d94bdSJung-uk Kim 		ts->bt_sec = bt->sec;
2360547d94bdSJung-uk Kim 		ts->bt_frac = bt->frac;
2361547d94bdSJung-uk Kim 		break;
2362547d94bdSJung-uk Kim 	}
2363547d94bdSJung-uk Kim }
2364547d94bdSJung-uk Kim 
2365437ffe18SSam Leffler /*
2366df8bae1dSRodney W. Grimes  * Move the packet data from interface memory (pkt) into the
23679e610888SDag-Erling Smørgrav  * store buffer.  "cpfn" is the routine called to do the actual data
2368df8bae1dSRodney W. Grimes  * transfer.  bcopy is passed in to copy contiguous chunks, while
23694d621040SChristian S.J. Peron  * bpf_append_mbuf is passed in to copy mbuf chains.  In the latter case,
2370df8bae1dSRodney W. Grimes  * pkt is really an mbuf.
2371df8bae1dSRodney W. Grimes  */
2372df8bae1dSRodney W. Grimes static void
237319ba8395SChristian S.J. Peron catchpacket(struct bpf_d *d, u_char *pkt, u_int pktlen, u_int snaplen,
23744d621040SChristian S.J. Peron     void (*cpfn)(struct bpf_d *, caddr_t, u_int, void *, u_int),
2375547d94bdSJung-uk Kim     struct bintime *bt)
2376df8bae1dSRodney W. Grimes {
2377547d94bdSJung-uk Kim 	struct bpf_xhdr hdr;
2378547d94bdSJung-uk Kim #ifndef BURN_BRIDGES
2379547d94bdSJung-uk Kim 	struct bpf_hdr hdr_old;
2380fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
2381547d94bdSJung-uk Kim 	struct bpf_hdr32 hdr32_old;
2382fc0a61a4SKonstantin Belousov #endif
2383547d94bdSJung-uk Kim #endif
2384547d94bdSJung-uk Kim 	int caplen, curlen, hdrlen, totlen;
23857819da79SJohn-Mark Gurney 	int do_wakeup = 0;
2386547d94bdSJung-uk Kim 	int do_timestamp;
2387547d94bdSJung-uk Kim 	int tstype;
23889e610888SDag-Erling Smørgrav 
2389afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
23904d621040SChristian S.J. Peron 
23914d621040SChristian S.J. Peron 	/*
23924d621040SChristian S.J. Peron 	 * Detect whether user space has released a buffer back to us, and if
23934d621040SChristian S.J. Peron 	 * so, move it from being a hold buffer to a free buffer.  This may
23944d621040SChristian S.J. Peron 	 * not be the best place to do it (for example, we might only want to
23954d621040SChristian S.J. Peron 	 * run this check if we need the space), but for now it's a reliable
23964d621040SChristian S.J. Peron 	 * spot to do it.
23974d621040SChristian S.J. Peron 	 */
2398fa0c2b34SRobert Watson 	if (d->bd_fbuf == NULL && bpf_canfreebuf(d)) {
23994d621040SChristian S.J. Peron 		d->bd_fbuf = d->bd_hbuf;
24004d621040SChristian S.J. Peron 		d->bd_hbuf = NULL;
24014d621040SChristian S.J. Peron 		d->bd_hlen = 0;
240229f612ecSChristian S.J. Peron 		bpf_buf_reclaimed(d);
24034d621040SChristian S.J. Peron 	}
24044d621040SChristian S.J. Peron 
2405df8bae1dSRodney W. Grimes 	/*
2406df8bae1dSRodney W. Grimes 	 * Figure out how many bytes to move.  If the packet is
2407df8bae1dSRodney W. Grimes 	 * greater or equal to the snapshot length, transfer that
2408df8bae1dSRodney W. Grimes 	 * much.  Otherwise, transfer the whole packet (unless
2409df8bae1dSRodney W. Grimes 	 * we hit the buffer size limit).
2410df8bae1dSRodney W. Grimes 	 */
2411547d94bdSJung-uk Kim 	hdrlen = bpf_hdrlen(d);
2412df8bae1dSRodney W. Grimes 	totlen = hdrlen + min(snaplen, pktlen);
2413df8bae1dSRodney W. Grimes 	if (totlen > d->bd_bufsize)
2414df8bae1dSRodney W. Grimes 		totlen = d->bd_bufsize;
2415df8bae1dSRodney W. Grimes 
2416df8bae1dSRodney W. Grimes 	/*
2417df8bae1dSRodney W. Grimes 	 * Round up the end of the previous packet to the next longword.
2418a7a91e65SRobert Watson 	 *
2419a7a91e65SRobert Watson 	 * Drop the packet if there's no room and no hope of room
2420a7a91e65SRobert Watson 	 * If the packet would overflow the storage buffer or the storage
2421a7a91e65SRobert Watson 	 * buffer is considered immutable by the buffer model, try to rotate
2422a7a91e65SRobert Watson 	 * the buffer and wakeup pending processes.
2423df8bae1dSRodney W. Grimes 	 */
2424fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
2425fc0a61a4SKonstantin Belousov 	if (d->bd_compat32)
2426fc0a61a4SKonstantin Belousov 		curlen = BPF_WORDALIGN32(d->bd_slen);
2427fc0a61a4SKonstantin Belousov 	else
2428fc0a61a4SKonstantin Belousov #endif
2429df8bae1dSRodney W. Grimes 		curlen = BPF_WORDALIGN(d->bd_slen);
2430a7a91e65SRobert Watson 	if (curlen + totlen > d->bd_bufsize || !bpf_canwritebuf(d)) {
2431572bde2aSRobert Watson 		if (d->bd_fbuf == NULL) {
2432df8bae1dSRodney W. Grimes 			/*
2433a7a91e65SRobert Watson 			 * There's no room in the store buffer, and no
2434a7a91e65SRobert Watson 			 * prospect of room, so drop the packet.  Notify the
2435a7a91e65SRobert Watson 			 * buffer model.
2436df8bae1dSRodney W. Grimes 			 */
2437a7a91e65SRobert Watson 			bpf_buffull(d);
2438df8bae1dSRodney W. Grimes 			++d->bd_dcount;
2439df8bae1dSRodney W. Grimes 			return;
2440df8bae1dSRodney W. Grimes 		}
244198fa5d85SLuiz Otavio O Souza 		KASSERT(!d->bd_hbuf_in_use, ("hold buffer is in use"));
2442df8bae1dSRodney W. Grimes 		ROTATE_BUFFERS(d);
24437819da79SJohn-Mark Gurney 		do_wakeup = 1;
2444df8bae1dSRodney W. Grimes 		curlen = 0;
2445a7a91e65SRobert Watson 	} else if (d->bd_immediate || d->bd_state == BPF_TIMED_OUT)
2446df8bae1dSRodney W. Grimes 		/*
24474d621040SChristian S.J. Peron 		 * Immediate mode is set, or the read timeout has already
24484d621040SChristian S.J. Peron 		 * expired during a select call.  A packet arrived, so the
24494d621040SChristian S.J. Peron 		 * reader should be woken up.
2450df8bae1dSRodney W. Grimes 		 */
24517819da79SJohn-Mark Gurney 		do_wakeup = 1;
2452547d94bdSJung-uk Kim 	caplen = totlen - hdrlen;
2453547d94bdSJung-uk Kim 	tstype = d->bd_tstamp;
2454547d94bdSJung-uk Kim 	do_timestamp = tstype != BPF_T_NONE;
2455547d94bdSJung-uk Kim #ifndef BURN_BRIDGES
2456547d94bdSJung-uk Kim 	if (tstype == BPF_T_NONE || BPF_T_FORMAT(tstype) == BPF_T_MICROTIME) {
2457547d94bdSJung-uk Kim 		struct bpf_ts ts;
2458547d94bdSJung-uk Kim 		if (do_timestamp)
2459547d94bdSJung-uk Kim 			bpf_bintime2ts(bt, &ts, tstype);
2460fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
2461fc0a61a4SKonstantin Belousov 		if (d->bd_compat32) {
2462547d94bdSJung-uk Kim 			bzero(&hdr32_old, sizeof(hdr32_old));
2463547d94bdSJung-uk Kim 			if (do_timestamp) {
2464547d94bdSJung-uk Kim 				hdr32_old.bh_tstamp.tv_sec = ts.bt_sec;
2465547d94bdSJung-uk Kim 				hdr32_old.bh_tstamp.tv_usec = ts.bt_frac;
2466547d94bdSJung-uk Kim 			}
2467547d94bdSJung-uk Kim 			hdr32_old.bh_datalen = pktlen;
2468547d94bdSJung-uk Kim 			hdr32_old.bh_hdrlen = hdrlen;
2469547d94bdSJung-uk Kim 			hdr32_old.bh_caplen = caplen;
2470547d94bdSJung-uk Kim 			bpf_append_bytes(d, d->bd_sbuf, curlen, &hdr32_old,
2471547d94bdSJung-uk Kim 			    sizeof(hdr32_old));
2472547d94bdSJung-uk Kim 			goto copy;
2473547d94bdSJung-uk Kim 		}
2474547d94bdSJung-uk Kim #endif
2475547d94bdSJung-uk Kim 		bzero(&hdr_old, sizeof(hdr_old));
2476547d94bdSJung-uk Kim 		if (do_timestamp) {
2477547d94bdSJung-uk Kim 			hdr_old.bh_tstamp.tv_sec = ts.bt_sec;
2478547d94bdSJung-uk Kim 			hdr_old.bh_tstamp.tv_usec = ts.bt_frac;
2479547d94bdSJung-uk Kim 		}
2480547d94bdSJung-uk Kim 		hdr_old.bh_datalen = pktlen;
2481547d94bdSJung-uk Kim 		hdr_old.bh_hdrlen = hdrlen;
2482547d94bdSJung-uk Kim 		hdr_old.bh_caplen = caplen;
2483547d94bdSJung-uk Kim 		bpf_append_bytes(d, d->bd_sbuf, curlen, &hdr_old,
2484547d94bdSJung-uk Kim 		    sizeof(hdr_old));
2485fc0a61a4SKonstantin Belousov 		goto copy;
2486fc0a61a4SKonstantin Belousov 	}
2487fc0a61a4SKonstantin Belousov #endif
2488df8bae1dSRodney W. Grimes 
2489df8bae1dSRodney W. Grimes 	/*
24904d621040SChristian S.J. Peron 	 * Append the bpf header.  Note we append the actual header size, but
24914d621040SChristian S.J. Peron 	 * move forward the length of the header plus padding.
2492df8bae1dSRodney W. Grimes 	 */
24934d621040SChristian S.J. Peron 	bzero(&hdr, sizeof(hdr));
2494547d94bdSJung-uk Kim 	if (do_timestamp)
2495547d94bdSJung-uk Kim 		bpf_bintime2ts(bt, &hdr.bh_tstamp, tstype);
24964d621040SChristian S.J. Peron 	hdr.bh_datalen = pktlen;
24974d621040SChristian S.J. Peron 	hdr.bh_hdrlen = hdrlen;
2498547d94bdSJung-uk Kim 	hdr.bh_caplen = caplen;
24994d621040SChristian S.J. Peron 	bpf_append_bytes(d, d->bd_sbuf, curlen, &hdr, sizeof(hdr));
25004d621040SChristian S.J. Peron 
2501df8bae1dSRodney W. Grimes 	/*
2502df8bae1dSRodney W. Grimes 	 * Copy the packet data into the store buffer and update its length.
2503df8bae1dSRodney W. Grimes 	 */
2504547d94bdSJung-uk Kim #ifndef BURN_BRIDGES
2505fc0a61a4SKonstantin Belousov copy:
2506fc0a61a4SKonstantin Belousov #endif
2507547d94bdSJung-uk Kim 	(*cpfn)(d, d->bd_sbuf, curlen + hdrlen, pkt, caplen);
2508df8bae1dSRodney W. Grimes 	d->bd_slen = curlen + totlen;
25097819da79SJohn-Mark Gurney 
25107819da79SJohn-Mark Gurney 	if (do_wakeup)
25117819da79SJohn-Mark Gurney 		bpf_wakeup(d);
2512df8bae1dSRodney W. Grimes }
2513df8bae1dSRodney W. Grimes 
2514df8bae1dSRodney W. Grimes /*
2515df8bae1dSRodney W. Grimes  * Free buffers currently in use by a descriptor.
2516df8bae1dSRodney W. Grimes  * Called on close.
2517df8bae1dSRodney W. Grimes  */
2518df8bae1dSRodney W. Grimes static void
251919ba8395SChristian S.J. Peron bpf_freed(struct bpf_d *d)
2520df8bae1dSRodney W. Grimes {
25214d621040SChristian S.J. Peron 
2522df8bae1dSRodney W. Grimes 	/*
2523df8bae1dSRodney W. Grimes 	 * We don't need to lock out interrupts since this descriptor has
2524df8bae1dSRodney W. Grimes 	 * been detached from its interface and it yet hasn't been marked
2525df8bae1dSRodney W. Grimes 	 * free.
2526df8bae1dSRodney W. Grimes 	 */
25274d621040SChristian S.J. Peron 	bpf_free(d);
252870485847SJung-uk Kim 	if (d->bd_rfilter != NULL) {
252993e39f0bSChristian S.J. Peron 		free((caddr_t)d->bd_rfilter, M_BPF);
2530ae275efcSJung-uk Kim #ifdef BPF_JITTER
253170485847SJung-uk Kim 		if (d->bd_bfilter != NULL)
2532ae275efcSJung-uk Kim 			bpf_destroy_jit_filter(d->bd_bfilter);
2533ae275efcSJung-uk Kim #endif
2534ae275efcSJung-uk Kim 	}
253570485847SJung-uk Kim 	if (d->bd_wfilter != NULL)
253693e39f0bSChristian S.J. Peron 		free((caddr_t)d->bd_wfilter, M_BPF);
2537afa85850SAlexander V. Chernikov 	mtx_destroy(&d->bd_lock);
2538df8bae1dSRodney W. Grimes }
2539df8bae1dSRodney W. Grimes 
2540df8bae1dSRodney W. Grimes /*
254124a229f4SSam Leffler  * Attach an interface to bpf.  dlt is the link layer type; hdrlen is the
254224a229f4SSam Leffler  * fixed size of the link header (variable length headers not yet supported).
2543df8bae1dSRodney W. Grimes  */
2544df8bae1dSRodney W. Grimes void
254519ba8395SChristian S.J. Peron bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
2546df8bae1dSRodney W. Grimes {
254724a229f4SSam Leffler 
254824a229f4SSam Leffler 	bpfattach2(ifp, dlt, hdrlen, &ifp->if_bpf);
254924a229f4SSam Leffler }
255024a229f4SSam Leffler 
255124a229f4SSam Leffler /*
255224a229f4SSam Leffler  * Attach an interface to bpf.  ifp is a pointer to the structure
255324a229f4SSam Leffler  * defining the interface to be attached, dlt is the link layer type,
255424a229f4SSam Leffler  * and hdrlen is the fixed size of the link header (variable length
255524a229f4SSam Leffler  * headers are not yet supporrted).
255624a229f4SSam Leffler  */
255724a229f4SSam Leffler void
255819ba8395SChristian S.J. Peron bpfattach2(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp)
255924a229f4SSam Leffler {
2560df8bae1dSRodney W. Grimes 	struct bpf_if *bp;
256119ba8395SChristian S.J. Peron 
256219ba8395SChristian S.J. Peron 	bp = malloc(sizeof(*bp), M_BPF, M_NOWAIT | M_ZERO);
2563572bde2aSRobert Watson 	if (bp == NULL)
2564df8bae1dSRodney W. Grimes 		panic("bpfattach");
2565df8bae1dSRodney W. Grimes 
25664a3feeaaSRobert Watson 	LIST_INIT(&bp->bif_dlist);
256751ec1eb7SAlexander V. Chernikov 	LIST_INIT(&bp->bif_wlist);
2568df8bae1dSRodney W. Grimes 	bp->bif_ifp = ifp;
2569df8bae1dSRodney W. Grimes 	bp->bif_dlt = dlt;
2570e4b3229aSAlexander V. Chernikov 	rw_init(&bp->bif_lock, "bpf interface lock");
257116d878ccSChristian S.J. Peron 	KASSERT(*driverp == NULL, ("bpfattach2: driverp already initialized"));
25729ce40d32SKristof Provost 	bp->bif_bpf = driverp;
257316d878ccSChristian S.J. Peron 	*driverp = bp;
2574df8bae1dSRodney W. Grimes 
2575e4b3229aSAlexander V. Chernikov 	BPF_LOCK();
25764a3feeaaSRobert Watson 	LIST_INSERT_HEAD(&bpf_iflist, bp, bif_next);
2577e4b3229aSAlexander V. Chernikov 	BPF_UNLOCK();
2578df8bae1dSRodney W. Grimes 
2579547d94bdSJung-uk Kim 	bp->bif_hdrlen = hdrlen;
2580df8bae1dSRodney W. Grimes 
2581616bc4f4SBjoern A. Zeeb 	if (bootverbose && IS_DEFAULT_VNET(curvnet))
258224a229f4SSam Leffler 		if_printf(ifp, "bpf attached\n");
2583df8bae1dSRodney W. Grimes }
258453ac6efbSJulian Elischer 
258505fc4164SBjoern A. Zeeb #ifdef VIMAGE
258605fc4164SBjoern A. Zeeb /*
258705fc4164SBjoern A. Zeeb  * When moving interfaces between vnet instances we need a way to
258805fc4164SBjoern A. Zeeb  * query the dlt and hdrlen before detach so we can re-attch the if_bpf
258905fc4164SBjoern A. Zeeb  * after the vmove.  We unfortunately have no device driver infrastructure
259005fc4164SBjoern A. Zeeb  * to query the interface for these values after creation/attach, thus
259105fc4164SBjoern A. Zeeb  * add this as a workaround.
259205fc4164SBjoern A. Zeeb  */
259305fc4164SBjoern A. Zeeb int
259405fc4164SBjoern A. Zeeb bpf_get_bp_params(struct bpf_if *bp, u_int *bif_dlt, u_int *bif_hdrlen)
259505fc4164SBjoern A. Zeeb {
259605fc4164SBjoern A. Zeeb 
259705fc4164SBjoern A. Zeeb 	if (bp == NULL)
259805fc4164SBjoern A. Zeeb 		return (ENXIO);
259905fc4164SBjoern A. Zeeb 	if (bif_dlt == NULL && bif_hdrlen == NULL)
260005fc4164SBjoern A. Zeeb 		return (0);
260105fc4164SBjoern A. Zeeb 
260205fc4164SBjoern A. Zeeb 	if (bif_dlt != NULL)
260305fc4164SBjoern A. Zeeb 		*bif_dlt = bp->bif_dlt;
260405fc4164SBjoern A. Zeeb 	if (bif_hdrlen != NULL)
260505fc4164SBjoern A. Zeeb 		*bif_hdrlen = bp->bif_hdrlen;
260605fc4164SBjoern A. Zeeb 
260705fc4164SBjoern A. Zeeb 	return (0);
260805fc4164SBjoern A. Zeeb }
260905fc4164SBjoern A. Zeeb #endif
261005fc4164SBjoern A. Zeeb 
2611de5d9935SRobert Watson /*
2612de5d9935SRobert Watson  * Detach bpf from an interface. This involves detaching each descriptor
26136c74ff0eSAlexander V. Chernikov  * associated with the interface. Notify each descriptor as it's detached
26146c74ff0eSAlexander V. Chernikov  * so that any sleepers wake up and get ENXIO.
2615de5d9935SRobert Watson  */
2616de5d9935SRobert Watson void
261719ba8395SChristian S.J. Peron bpfdetach(struct ifnet *ifp)
2618de5d9935SRobert Watson {
2619f079a0faSAlexander V. Chernikov 	struct bpf_if	*bp, *bp_temp;
2620de5d9935SRobert Watson 	struct bpf_d	*d;
26219a7e6bacSLawrence Stewart 	int ndetached;
2622de5d9935SRobert Watson 
26239a7e6bacSLawrence Stewart 	ndetached = 0;
26249a7e6bacSLawrence Stewart 
2625afa85850SAlexander V. Chernikov 	BPF_LOCK();
26269a7e6bacSLawrence Stewart 	/* Find all bpf_if struct's which reference ifp and detach them. */
2627f079a0faSAlexander V. Chernikov 	LIST_FOREACH_SAFE(bp, &bpf_iflist, bif_next, bp_temp) {
2628f079a0faSAlexander V. Chernikov 		if (ifp != bp->bif_ifp)
2629f079a0faSAlexander V. Chernikov 			continue;
2630de5d9935SRobert Watson 
2631f079a0faSAlexander V. Chernikov 		LIST_REMOVE(bp, bif_next);
2632f079a0faSAlexander V. Chernikov 		/* Add to to-be-freed list */
2633f079a0faSAlexander V. Chernikov 		LIST_INSERT_HEAD(&bpf_freelist, bp, bif_next);
2634f079a0faSAlexander V. Chernikov 
26359a7e6bacSLawrence Stewart 		ndetached++;
2636f079a0faSAlexander V. Chernikov 		/*
2637f079a0faSAlexander V. Chernikov 		 * Delay freeing bp till interface is detached
2638f079a0faSAlexander V. Chernikov 		 * and all routes through this interface are removed.
2639f079a0faSAlexander V. Chernikov 		 * Mark bp as detached to restrict new consumers.
2640f079a0faSAlexander V. Chernikov 		 */
2641f079a0faSAlexander V. Chernikov 		BPFIF_WLOCK(bp);
2642b23cbbe6SMark Johnston 		bp->bif_flags |= BPFIF_FLAG_DYING;
26439ce40d32SKristof Provost 		*bp->bif_bpf = NULL;
2644f079a0faSAlexander V. Chernikov 		BPFIF_WUNLOCK(bp);
2645f079a0faSAlexander V. Chernikov 
2646f079a0faSAlexander V. Chernikov 		CTR4(KTR_NET, "%s: sheduling free for encap %d (%p) for if %p",
2647f079a0faSAlexander V. Chernikov 		    __func__, bp->bif_dlt, bp, ifp);
2648f079a0faSAlexander V. Chernikov 
2649f079a0faSAlexander V. Chernikov 		/* Free common descriptors */
26504a3feeaaSRobert Watson 		while ((d = LIST_FIRST(&bp->bif_dlist)) != NULL) {
2651afa85850SAlexander V. Chernikov 			bpf_detachd_locked(d);
2652afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
2653e7bb21b3SJonathan Lemon 			bpf_wakeup(d);
2654afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
2655e7bb21b3SJonathan Lemon 		}
2656f079a0faSAlexander V. Chernikov 
26576c74ff0eSAlexander V. Chernikov 		/* Free writer-only descriptors */
26586c74ff0eSAlexander V. Chernikov 		while ((d = LIST_FIRST(&bp->bif_wlist)) != NULL) {
2659afa85850SAlexander V. Chernikov 			bpf_detachd_locked(d);
2660afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
26616c74ff0eSAlexander V. Chernikov 			bpf_wakeup(d);
2662afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
26636c74ff0eSAlexander V. Chernikov 		}
26648eab61f3SSam Leffler 	}
2665afa85850SAlexander V. Chernikov 	BPF_UNLOCK();
26669a7e6bacSLawrence Stewart 
26679a7e6bacSLawrence Stewart #ifdef INVARIANTS
26689a7e6bacSLawrence Stewart 	if (ndetached == 0)
26699a7e6bacSLawrence Stewart 		printf("bpfdetach: %s was not attached\n", ifp->if_xname);
26709a7e6bacSLawrence Stewart #endif
26719a7e6bacSLawrence Stewart }
2672de5d9935SRobert Watson 
26738eab61f3SSam Leffler /*
2674784292f8SAlexander V. Chernikov  * Interface departure handler.
26754fe83b81SAlexander V. Chernikov  * Note departure event does not guarantee interface is going down.
2676f079a0faSAlexander V. Chernikov  * Interface renaming is currently done via departure/arrival event set.
2677f079a0faSAlexander V. Chernikov  *
2678f079a0faSAlexander V. Chernikov  * Departure handled is called after all routes pointing to
2679f079a0faSAlexander V. Chernikov  * given interface are removed and interface is in down state
2680f079a0faSAlexander V. Chernikov  * restricting any packets to be sent/received. We assume it is now safe
2681f079a0faSAlexander V. Chernikov  * to free data allocated by BPF.
2682afa85850SAlexander V. Chernikov  */
2683afa85850SAlexander V. Chernikov static void
2684afa85850SAlexander V. Chernikov bpf_ifdetach(void *arg __unused, struct ifnet *ifp)
2685afa85850SAlexander V. Chernikov {
2686f079a0faSAlexander V. Chernikov 	struct bpf_if *bp, *bp_temp;
2687f079a0faSAlexander V. Chernikov 	int nmatched = 0;
2688afa85850SAlexander V. Chernikov 
2689250a8e27SAndrey V. Elsukov 	/* Ignore ifnet renaming. */
2690250a8e27SAndrey V. Elsukov 	if (ifp->if_flags & IFF_RENAMING)
2691250a8e27SAndrey V. Elsukov 		return;
2692250a8e27SAndrey V. Elsukov 
2693784292f8SAlexander V. Chernikov 	BPF_LOCK();
2694f079a0faSAlexander V. Chernikov 	/*
2695f079a0faSAlexander V. Chernikov 	 * Find matching entries in free list.
2696f079a0faSAlexander V. Chernikov 	 * Nothing should be found if bpfdetach() was not called.
2697f079a0faSAlexander V. Chernikov 	 */
2698f079a0faSAlexander V. Chernikov 	LIST_FOREACH_SAFE(bp, &bpf_freelist, bif_next, bp_temp) {
2699f079a0faSAlexander V. Chernikov 		if (ifp != bp->bif_ifp)
2700f079a0faSAlexander V. Chernikov 			continue;
2701784292f8SAlexander V. Chernikov 
2702f079a0faSAlexander V. Chernikov 		CTR3(KTR_NET, "%s: freeing BPF instance %p for interface %p",
2703afa85850SAlexander V. Chernikov 		    __func__, bp, ifp);
2704afa85850SAlexander V. Chernikov 
2705f079a0faSAlexander V. Chernikov 		LIST_REMOVE(bp, bif_next);
2706784292f8SAlexander V. Chernikov 
2707afa85850SAlexander V. Chernikov 		rw_destroy(&bp->bif_lock);
2708afa85850SAlexander V. Chernikov 		free(bp, M_BPF);
2709f079a0faSAlexander V. Chernikov 
2710f079a0faSAlexander V. Chernikov 		nmatched++;
2711f079a0faSAlexander V. Chernikov 	}
2712f079a0faSAlexander V. Chernikov 	BPF_UNLOCK();
2713afa85850SAlexander V. Chernikov }
2714afa85850SAlexander V. Chernikov 
2715afa85850SAlexander V. Chernikov /*
27168eab61f3SSam Leffler  * Get a list of available data link type of the interface.
27178eab61f3SSam Leffler  */
27188eab61f3SSam Leffler static int
271919ba8395SChristian S.J. Peron bpf_getdltlist(struct bpf_d *d, struct bpf_dltlist *bfl)
27208eab61f3SSam Leffler {
27218eab61f3SSam Leffler 	struct ifnet *ifp;
27228eab61f3SSam Leffler 	struct bpf_if *bp;
272370209acaSKonstantin Belousov 	u_int *lst;
272470209acaSKonstantin Belousov 	int error, n, n1;
27258eab61f3SSam Leffler 
272697aacec6SAlexander V. Chernikov 	BPF_LOCK_ASSERT();
272797aacec6SAlexander V. Chernikov 
27288eab61f3SSam Leffler 	ifp = d->bd_bif->bif_ifp;
272970209acaSKonstantin Belousov again:
273070209acaSKonstantin Belousov 	n1 = 0;
273170209acaSKonstantin Belousov 	LIST_FOREACH(bp, &bpf_iflist, bif_next) {
273270209acaSKonstantin Belousov 		if (bp->bif_ifp == ifp)
273370209acaSKonstantin Belousov 			n1++;
273470209acaSKonstantin Belousov 	}
273570209acaSKonstantin Belousov 	if (bfl->bfl_list == NULL) {
273670209acaSKonstantin Belousov 		bfl->bfl_len = n1;
273770209acaSKonstantin Belousov 		return (0);
273870209acaSKonstantin Belousov 	}
273970209acaSKonstantin Belousov 	if (n1 > bfl->bfl_len)
274070209acaSKonstantin Belousov 		return (ENOMEM);
274170209acaSKonstantin Belousov 	BPF_UNLOCK();
274270209acaSKonstantin Belousov 	lst = malloc(n1 * sizeof(u_int), M_TEMP, M_WAITOK);
27438eab61f3SSam Leffler 	n = 0;
274470209acaSKonstantin Belousov 	BPF_LOCK();
27454a3feeaaSRobert Watson 	LIST_FOREACH(bp, &bpf_iflist, bif_next) {
27468eab61f3SSam Leffler 		if (bp->bif_ifp != ifp)
27478eab61f3SSam Leffler 			continue;
27485412ec6eSConrad Meyer 		if (n >= n1) {
274970209acaSKonstantin Belousov 			free(lst, M_TEMP);
275070209acaSKonstantin Belousov 			goto again;
27518eab61f3SSam Leffler 		}
275270209acaSKonstantin Belousov 		lst[n] = bp->bif_dlt;
27538eab61f3SSam Leffler 		n++;
27548eab61f3SSam Leffler 	}
275570209acaSKonstantin Belousov 	BPF_UNLOCK();
275670209acaSKonstantin Belousov 	error = copyout(lst, bfl->bfl_list, sizeof(u_int) * n);
275770209acaSKonstantin Belousov 	free(lst, M_TEMP);
275870209acaSKonstantin Belousov 	BPF_LOCK();
27598eab61f3SSam Leffler 	bfl->bfl_len = n;
27608eab61f3SSam Leffler 	return (error);
27618eab61f3SSam Leffler }
27628eab61f3SSam Leffler 
27638eab61f3SSam Leffler /*
27648eab61f3SSam Leffler  * Set the data link type of a BPF instance.
27658eab61f3SSam Leffler  */
27668eab61f3SSam Leffler static int
276719ba8395SChristian S.J. Peron bpf_setdlt(struct bpf_d *d, u_int dlt)
27688eab61f3SSam Leffler {
27698eab61f3SSam Leffler 	int error, opromisc;
27708eab61f3SSam Leffler 	struct ifnet *ifp;
27718eab61f3SSam Leffler 	struct bpf_if *bp;
27728eab61f3SSam Leffler 
27736c74ff0eSAlexander V. Chernikov 	BPF_LOCK_ASSERT();
27746c74ff0eSAlexander V. Chernikov 
27758eab61f3SSam Leffler 	if (d->bd_bif->bif_dlt == dlt)
27768eab61f3SSam Leffler 		return (0);
27778eab61f3SSam Leffler 	ifp = d->bd_bif->bif_ifp;
27786c74ff0eSAlexander V. Chernikov 
27794a3feeaaSRobert Watson 	LIST_FOREACH(bp, &bpf_iflist, bif_next) {
27808eab61f3SSam Leffler 		if (bp->bif_ifp == ifp && bp->bif_dlt == dlt)
27818eab61f3SSam Leffler 			break;
27828eab61f3SSam Leffler 	}
27836c74ff0eSAlexander V. Chernikov 
27848eab61f3SSam Leffler 	if (bp != NULL) {
27858eab61f3SSam Leffler 		opromisc = d->bd_promisc;
27868eab61f3SSam Leffler 		bpf_attachd(d, bp);
2787afa85850SAlexander V. Chernikov 		BPFD_LOCK(d);
27888eab61f3SSam Leffler 		reset_d(d);
2789afa85850SAlexander V. Chernikov 		BPFD_UNLOCK(d);
27908eab61f3SSam Leffler 		if (opromisc) {
27918eab61f3SSam Leffler 			error = ifpromisc(bp->bif_ifp, 1);
27928eab61f3SSam Leffler 			if (error)
27938eab61f3SSam Leffler 				if_printf(bp->bif_ifp,
27948eab61f3SSam Leffler 					"bpf_setdlt: ifpromisc failed (%d)\n",
27958eab61f3SSam Leffler 					error);
27968eab61f3SSam Leffler 			else
27978eab61f3SSam Leffler 				d->bd_promisc = 1;
27988eab61f3SSam Leffler 		}
27998eab61f3SSam Leffler 	}
28008eab61f3SSam Leffler 	return (bp == NULL ? EINVAL : 0);
2801de5d9935SRobert Watson }
2802de5d9935SRobert Watson 
28033f54a085SPoul-Henning Kamp static void
280419ba8395SChristian S.J. Peron bpf_drvinit(void *unused)
280553ac6efbSJulian Elischer {
2806136600feSEd Schouten 	struct cdev *dev;
280753ac6efbSJulian Elischer 
28086008862bSJohn Baldwin 	mtx_init(&bpf_mtx, "bpf global lock", NULL, MTX_DEF);
28094a3feeaaSRobert Watson 	LIST_INIT(&bpf_iflist);
2810f079a0faSAlexander V. Chernikov 	LIST_INIT(&bpf_freelist);
2811136600feSEd Schouten 
2812136600feSEd Schouten 	dev = make_dev(&bpf_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, "bpf");
2813136600feSEd Schouten 	/* For compatibility */
2814136600feSEd Schouten 	make_dev_alias(dev, "bpf0");
2815afa85850SAlexander V. Chernikov 
2816afa85850SAlexander V. Chernikov 	/* Register interface departure handler */
2817afa85850SAlexander V. Chernikov 	bpf_ifdetach_cookie = EVENTHANDLER_REGISTER(
2818afa85850SAlexander V. Chernikov 		    ifnet_departure_event, bpf_ifdetach, NULL,
2819afa85850SAlexander V. Chernikov 		    EVENTHANDLER_PRI_ANY);
28207198bf47SJulian Elischer }
282153ac6efbSJulian Elischer 
28220e37f3e1SChristian S.J. Peron /*
28230e37f3e1SChristian S.J. Peron  * Zero out the various packet counters associated with all of the bpf
28240e37f3e1SChristian S.J. Peron  * descriptors.  At some point, we will probably want to get a bit more
28250e37f3e1SChristian S.J. Peron  * granular and allow the user to specify descriptors to be zeroed.
28260e37f3e1SChristian S.J. Peron  */
28270e37f3e1SChristian S.J. Peron static void
28280e37f3e1SChristian S.J. Peron bpf_zero_counters(void)
28290e37f3e1SChristian S.J. Peron {
28300e37f3e1SChristian S.J. Peron 	struct bpf_if *bp;
28310e37f3e1SChristian S.J. Peron 	struct bpf_d *bd;
28320e37f3e1SChristian S.J. Peron 
2833e4b3229aSAlexander V. Chernikov 	BPF_LOCK();
28340e37f3e1SChristian S.J. Peron 	LIST_FOREACH(bp, &bpf_iflist, bif_next) {
2835e4b3229aSAlexander V. Chernikov 		BPFIF_RLOCK(bp);
28360e37f3e1SChristian S.J. Peron 		LIST_FOREACH(bd, &bp->bif_dlist, bd_next) {
2837afa85850SAlexander V. Chernikov 			BPFD_LOCK(bd);
28380e37f3e1SChristian S.J. Peron 			bd->bd_rcount = 0;
28390e37f3e1SChristian S.J. Peron 			bd->bd_dcount = 0;
28400e37f3e1SChristian S.J. Peron 			bd->bd_fcount = 0;
28410e37f3e1SChristian S.J. Peron 			bd->bd_wcount = 0;
28420e37f3e1SChristian S.J. Peron 			bd->bd_wfcount = 0;
28430e37f3e1SChristian S.J. Peron 			bd->bd_zcopy = 0;
2844afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(bd);
28450e37f3e1SChristian S.J. Peron 		}
2846e4b3229aSAlexander V. Chernikov 		BPFIF_RUNLOCK(bp);
28470e37f3e1SChristian S.J. Peron 	}
2848e4b3229aSAlexander V. Chernikov 	BPF_UNLOCK();
28490e37f3e1SChristian S.J. Peron }
28500e37f3e1SChristian S.J. Peron 
28516c74ff0eSAlexander V. Chernikov /*
28526c74ff0eSAlexander V. Chernikov  * Fill filter statistics
28536c74ff0eSAlexander V. Chernikov  */
285469f7644bSChristian S.J. Peron static void
285569f7644bSChristian S.J. Peron bpfstats_fill_xbpf(struct xbpf_d *d, struct bpf_d *bd)
285669f7644bSChristian S.J. Peron {
285769f7644bSChristian S.J. Peron 
285869f7644bSChristian S.J. Peron 	bzero(d, sizeof(*d));
285969f7644bSChristian S.J. Peron 	BPFD_LOCK_ASSERT(bd);
28604d621040SChristian S.J. Peron 	d->bd_structsize = sizeof(*d);
28616c74ff0eSAlexander V. Chernikov 	/* XXX: reading should be protected by global lock */
286269f7644bSChristian S.J. Peron 	d->bd_immediate = bd->bd_immediate;
286369f7644bSChristian S.J. Peron 	d->bd_promisc = bd->bd_promisc;
286469f7644bSChristian S.J. Peron 	d->bd_hdrcmplt = bd->bd_hdrcmplt;
2865560a54e1SJung-uk Kim 	d->bd_direction = bd->bd_direction;
2866560a54e1SJung-uk Kim 	d->bd_feedback = bd->bd_feedback;
286769f7644bSChristian S.J. Peron 	d->bd_async = bd->bd_async;
286869f7644bSChristian S.J. Peron 	d->bd_rcount = bd->bd_rcount;
286969f7644bSChristian S.J. Peron 	d->bd_dcount = bd->bd_dcount;
287069f7644bSChristian S.J. Peron 	d->bd_fcount = bd->bd_fcount;
287169f7644bSChristian S.J. Peron 	d->bd_sig = bd->bd_sig;
287269f7644bSChristian S.J. Peron 	d->bd_slen = bd->bd_slen;
287369f7644bSChristian S.J. Peron 	d->bd_hlen = bd->bd_hlen;
287469f7644bSChristian S.J. Peron 	d->bd_bufsize = bd->bd_bufsize;
287569f7644bSChristian S.J. Peron 	d->bd_pid = bd->bd_pid;
287669f7644bSChristian S.J. Peron 	strlcpy(d->bd_ifname,
287769f7644bSChristian S.J. Peron 	    bd->bd_bif->bif_ifp->if_xname, IFNAMSIZ);
287893e39f0bSChristian S.J. Peron 	d->bd_locked = bd->bd_locked;
28794d621040SChristian S.J. Peron 	d->bd_wcount = bd->bd_wcount;
28804d621040SChristian S.J. Peron 	d->bd_wdcount = bd->bd_wdcount;
28814d621040SChristian S.J. Peron 	d->bd_wfcount = bd->bd_wfcount;
28824d621040SChristian S.J. Peron 	d->bd_zcopy = bd->bd_zcopy;
28834d621040SChristian S.J. Peron 	d->bd_bufmode = bd->bd_bufmode;
288469f7644bSChristian S.J. Peron }
288569f7644bSChristian S.J. Peron 
28866c74ff0eSAlexander V. Chernikov /*
28876c74ff0eSAlexander V. Chernikov  * Handle `netstat -B' stats request
28886c74ff0eSAlexander V. Chernikov  */
288969f7644bSChristian S.J. Peron static int
289069f7644bSChristian S.J. Peron bpf_stats_sysctl(SYSCTL_HANDLER_ARGS)
289169f7644bSChristian S.J. Peron {
28920e1152fcSHans Petter Selasky 	static const struct xbpf_d zerostats;
28930e1152fcSHans Petter Selasky 	struct xbpf_d *xbdbuf, *xbd, tempstats;
2894422a63daSChristian S.J. Peron 	int index, error;
289569f7644bSChristian S.J. Peron 	struct bpf_if *bp;
289669f7644bSChristian S.J. Peron 	struct bpf_d *bd;
289769f7644bSChristian S.J. Peron 
289869f7644bSChristian S.J. Peron 	/*
289969f7644bSChristian S.J. Peron 	 * XXX This is not technically correct. It is possible for non
290069f7644bSChristian S.J. Peron 	 * privileged users to open bpf devices. It would make sense
290169f7644bSChristian S.J. Peron 	 * if the users who opened the devices were able to retrieve
290269f7644bSChristian S.J. Peron 	 * the statistics for them, too.
290369f7644bSChristian S.J. Peron 	 */
2904acd3428bSRobert Watson 	error = priv_check(req->td, PRIV_NET_BPF);
290569f7644bSChristian S.J. Peron 	if (error)
290669f7644bSChristian S.J. Peron 		return (error);
29070e37f3e1SChristian S.J. Peron 	/*
29080e37f3e1SChristian S.J. Peron 	 * Check to see if the user is requesting that the counters be
29090e37f3e1SChristian S.J. Peron 	 * zeroed out.  Explicitly check that the supplied data is zeroed,
29100e37f3e1SChristian S.J. Peron 	 * as we aren't allowing the user to set the counters currently.
29110e37f3e1SChristian S.J. Peron 	 */
29120e37f3e1SChristian S.J. Peron 	if (req->newptr != NULL) {
29130e1152fcSHans Petter Selasky 		if (req->newlen != sizeof(tempstats))
29140e37f3e1SChristian S.J. Peron 			return (EINVAL);
29150e1152fcSHans Petter Selasky 		memset(&tempstats, 0, sizeof(tempstats));
29160e1152fcSHans Petter Selasky 		error = SYSCTL_IN(req, &tempstats, sizeof(tempstats));
29170e1152fcSHans Petter Selasky 		if (error)
29180e1152fcSHans Petter Selasky 			return (error);
29190e1152fcSHans Petter Selasky 		if (bcmp(&tempstats, &zerostats, sizeof(tempstats)) != 0)
29200e37f3e1SChristian S.J. Peron 			return (EINVAL);
29210e37f3e1SChristian S.J. Peron 		bpf_zero_counters();
29220e37f3e1SChristian S.J. Peron 		return (0);
29230e37f3e1SChristian S.J. Peron 	}
292469f7644bSChristian S.J. Peron 	if (req->oldptr == NULL)
2925422a63daSChristian S.J. Peron 		return (SYSCTL_OUT(req, 0, bpf_bpfd_cnt * sizeof(*xbd)));
292669f7644bSChristian S.J. Peron 	if (bpf_bpfd_cnt == 0)
292769f7644bSChristian S.J. Peron 		return (SYSCTL_OUT(req, 0, 0));
2928422a63daSChristian S.J. Peron 	xbdbuf = malloc(req->oldlen, M_BPF, M_WAITOK);
2929e4b3229aSAlexander V. Chernikov 	BPF_LOCK();
2930422a63daSChristian S.J. Peron 	if (req->oldlen < (bpf_bpfd_cnt * sizeof(*xbd))) {
2931e4b3229aSAlexander V. Chernikov 		BPF_UNLOCK();
2932422a63daSChristian S.J. Peron 		free(xbdbuf, M_BPF);
2933422a63daSChristian S.J. Peron 		return (ENOMEM);
2934422a63daSChristian S.J. Peron 	}
2935422a63daSChristian S.J. Peron 	index = 0;
293669f7644bSChristian S.J. Peron 	LIST_FOREACH(bp, &bpf_iflist, bif_next) {
2937e4b3229aSAlexander V. Chernikov 		BPFIF_RLOCK(bp);
293851ec1eb7SAlexander V. Chernikov 		/* Send writers-only first */
293951ec1eb7SAlexander V. Chernikov 		LIST_FOREACH(bd, &bp->bif_wlist, bd_next) {
294051ec1eb7SAlexander V. Chernikov 			xbd = &xbdbuf[index++];
2941afa85850SAlexander V. Chernikov 			BPFD_LOCK(bd);
294251ec1eb7SAlexander V. Chernikov 			bpfstats_fill_xbpf(xbd, bd);
2943afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(bd);
294451ec1eb7SAlexander V. Chernikov 		}
294569f7644bSChristian S.J. Peron 		LIST_FOREACH(bd, &bp->bif_dlist, bd_next) {
2946422a63daSChristian S.J. Peron 			xbd = &xbdbuf[index++];
2947afa85850SAlexander V. Chernikov 			BPFD_LOCK(bd);
2948422a63daSChristian S.J. Peron 			bpfstats_fill_xbpf(xbd, bd);
2949afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(bd);
295069f7644bSChristian S.J. Peron 		}
2951e4b3229aSAlexander V. Chernikov 		BPFIF_RUNLOCK(bp);
295269f7644bSChristian S.J. Peron 	}
2953e4b3229aSAlexander V. Chernikov 	BPF_UNLOCK();
2954422a63daSChristian S.J. Peron 	error = SYSCTL_OUT(req, xbdbuf, index * sizeof(*xbd));
2955422a63daSChristian S.J. Peron 	free(xbdbuf, M_BPF);
295669f7644bSChristian S.J. Peron 	return (error);
295769f7644bSChristian S.J. Peron }
295869f7644bSChristian S.J. Peron 
2959237fdd78SRobert Watson SYSINIT(bpfdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE,bpf_drvinit,NULL);
296053ac6efbSJulian Elischer 
29615bb5f2c9SPeter Wemm #else /* !DEV_BPF && !NETGRAPH_BPF */
2962f8dc4716SMike Smith /*
2963f8dc4716SMike Smith  * NOP stubs to allow bpf-using drivers to load and function.
2964f8dc4716SMike Smith  *
2965f8dc4716SMike Smith  * A 'better' implementation would allow the core bpf functionality
2966f8dc4716SMike Smith  * to be loaded at runtime.
2967f8dc4716SMike Smith  */
29687eae78a4SChristian S.J. Peron static struct bpf_if bp_null;
2969f8dc4716SMike Smith 
2970f8dc4716SMike Smith void
297119ba8395SChristian S.J. Peron bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen)
2972f8dc4716SMike Smith {
2973f8dc4716SMike Smith }
2974f8dc4716SMike Smith 
2975f8dc4716SMike Smith void
297619ba8395SChristian S.J. Peron bpf_mtap(struct bpf_if *bp, struct mbuf *m)
2977f8dc4716SMike Smith {
2978f8dc4716SMike Smith }
2979f8dc4716SMike Smith 
2980f8dc4716SMike Smith void
298119ba8395SChristian S.J. Peron bpf_mtap2(struct bpf_if *bp, void *d, u_int l, struct mbuf *m)
2982437ffe18SSam Leffler {
2983437ffe18SSam Leffler }
2984437ffe18SSam Leffler 
2985437ffe18SSam Leffler void
298619ba8395SChristian S.J. Peron bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
2987f8dc4716SMike Smith {
29887eae78a4SChristian S.J. Peron 
29897eae78a4SChristian S.J. Peron 	bpfattach2(ifp, dlt, hdrlen, &ifp->if_bpf);
2990f8dc4716SMike Smith }
2991f8dc4716SMike Smith 
2992da626c17SBill Paul void
299319ba8395SChristian S.J. Peron bpfattach2(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp)
29945f7a7923SSam Leffler {
29957eae78a4SChristian S.J. Peron 
29967eae78a4SChristian S.J. Peron 	*driverp = &bp_null;
29975f7a7923SSam Leffler }
29985f7a7923SSam Leffler 
29995f7a7923SSam Leffler void
300019ba8395SChristian S.J. Peron bpfdetach(struct ifnet *ifp)
3001da626c17SBill Paul {
3002da626c17SBill Paul }
3003da626c17SBill Paul 
3004f8dc4716SMike Smith u_int
300519ba8395SChristian S.J. Peron bpf_filter(const struct bpf_insn *pc, u_char *p, u_int wirelen, u_int buflen)
3006f8dc4716SMike Smith {
3007f8dc4716SMike Smith 	return -1;	/* "no filter" behaviour */
3008f8dc4716SMike Smith }
3009f8dc4716SMike Smith 
30105bb5f2c9SPeter Wemm int
301119ba8395SChristian S.J. Peron bpf_validate(const struct bpf_insn *f, int len)
30125bb5f2c9SPeter Wemm {
30135bb5f2c9SPeter Wemm 	return 0;		/* false */
30145bb5f2c9SPeter Wemm }
30155bb5f2c9SPeter Wemm 
30165bb5f2c9SPeter Wemm #endif /* !DEV_BPF && !NETGRAPH_BPF */
301705fc4164SBjoern A. Zeeb 
301805fc4164SBjoern A. Zeeb #ifdef DDB
301905fc4164SBjoern A. Zeeb static void
302005fc4164SBjoern A. Zeeb bpf_show_bpf_if(struct bpf_if *bpf_if)
302105fc4164SBjoern A. Zeeb {
302205fc4164SBjoern A. Zeeb 
302305fc4164SBjoern A. Zeeb 	if (bpf_if == NULL)
302405fc4164SBjoern A. Zeeb 		return;
302505fc4164SBjoern A. Zeeb 	db_printf("%p:\n", bpf_if);
302605fc4164SBjoern A. Zeeb #define	BPF_DB_PRINTF(f, e)	db_printf("   %s = " f "\n", #e, bpf_if->e);
302705fc4164SBjoern A. Zeeb 	/* bif_ext.bif_next */
302805fc4164SBjoern A. Zeeb 	/* bif_ext.bif_dlist */
302905fc4164SBjoern A. Zeeb 	BPF_DB_PRINTF("%#x", bif_dlt);
303005fc4164SBjoern A. Zeeb 	BPF_DB_PRINTF("%u", bif_hdrlen);
303105fc4164SBjoern A. Zeeb 	BPF_DB_PRINTF("%p", bif_ifp);
303205fc4164SBjoern A. Zeeb 	/* bif_lock */
303305fc4164SBjoern A. Zeeb 	/* bif_wlist */
303405fc4164SBjoern A. Zeeb 	BPF_DB_PRINTF("%#x", bif_flags);
303505fc4164SBjoern A. Zeeb }
303605fc4164SBjoern A. Zeeb 
303705fc4164SBjoern A. Zeeb DB_SHOW_COMMAND(bpf_if, db_show_bpf_if)
303805fc4164SBjoern A. Zeeb {
303905fc4164SBjoern A. Zeeb 
304005fc4164SBjoern A. Zeeb 	if (!have_addr) {
304105fc4164SBjoern A. Zeeb 		db_printf("usage: show bpf_if <struct bpf_if *>\n");
304205fc4164SBjoern A. Zeeb 		return;
304305fc4164SBjoern A. Zeeb 	}
304405fc4164SBjoern A. Zeeb 
304505fc4164SBjoern A. Zeeb 	bpf_show_bpf_if((struct bpf_if *)addr);
304605fc4164SBjoern A. Zeeb }
304705fc4164SBjoern A. Zeeb #endif
3048