xref: /freebsd/sys/net/bpf.c (revision b43660921340f3f13c5ccf2932dfbf2b41167703)
1c398230bSWarner Losh /*-
2df8bae1dSRodney W. Grimes  * Copyright (c) 1990, 1991, 1993
3253a3814SLawrence Stewart  *	The Regents of the University of California.  All rights reserved.
4df8bae1dSRodney W. Grimes  *
5df8bae1dSRodney W. Grimes  * This code is derived from the Stanford/CMU enet packet filter,
6df8bae1dSRodney W. Grimes  * (net/enet.c) distributed as part of 4.3BSD, and code contributed
7df8bae1dSRodney W. Grimes  * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
8df8bae1dSRodney W. Grimes  * Berkeley Laboratory.
9df8bae1dSRodney W. Grimes  *
10df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
11df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
12df8bae1dSRodney W. Grimes  * are met:
13df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
14df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
15df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
16df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
17df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
18fbbd9655SWarner Losh  * 3. Neither the name of the University nor the names of its contributors
19df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
20df8bae1dSRodney W. Grimes  *    without specific prior written permission.
21df8bae1dSRodney W. Grimes  *
22df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
33df8bae1dSRodney W. Grimes  *
344f252c4dSRuslan Ermilov  *      @(#)bpf.c	8.4 (Berkeley) 1/9/95
35df8bae1dSRodney W. Grimes  */
36df8bae1dSRodney W. Grimes 
37c7866007SRobert Watson #include <sys/cdefs.h>
38c7866007SRobert Watson __FBSDID("$FreeBSD$");
39c7866007SRobert Watson 
405bb5f2c9SPeter Wemm #include "opt_bpf.h"
41fc0a61a4SKonstantin Belousov #include "opt_compat.h"
4205fc4164SBjoern A. Zeeb #include "opt_ddb.h"
435bb5f2c9SPeter Wemm #include "opt_netgraph.h"
44df8bae1dSRodney W. Grimes 
4595aab9ccSJohn-Mark Gurney #include <sys/types.h>
46df8bae1dSRodney W. Grimes #include <sys/param.h>
47e4b3229aSAlexander V. Chernikov #include <sys/lock.h>
48e4b3229aSAlexander V. Chernikov #include <sys/rwlock.h>
49df8bae1dSRodney W. Grimes #include <sys/systm.h>
50ce7609a4SBruce Evans #include <sys/conf.h>
51e76eee55SPoul-Henning Kamp #include <sys/fcntl.h>
52ebd8672cSBjoern A. Zeeb #include <sys/jail.h>
534d1d4912SBruce Evans #include <sys/malloc.h>
54df8bae1dSRodney W. Grimes #include <sys/mbuf.h>
55df8bae1dSRodney W. Grimes #include <sys/time.h>
56acd3428bSRobert Watson #include <sys/priv.h>
57df8bae1dSRodney W. Grimes #include <sys/proc.h>
580310c19fSBruce Evans #include <sys/signalvar.h>
59528f627fSBruce Evans #include <sys/filio.h>
60528f627fSBruce Evans #include <sys/sockio.h>
61528f627fSBruce Evans #include <sys/ttycom.h>
62e76eee55SPoul-Henning Kamp #include <sys/uio.h>
63df8bae1dSRodney W. Grimes 
6495aab9ccSJohn-Mark Gurney #include <sys/event.h>
6595aab9ccSJohn-Mark Gurney #include <sys/file.h>
66243ac7d8SPeter Wemm #include <sys/poll.h>
6795aab9ccSJohn-Mark Gurney #include <sys/proc.h>
68df8bae1dSRodney W. Grimes 
69df8bae1dSRodney W. Grimes #include <sys/socket.h>
70df8bae1dSRodney W. Grimes 
7105fc4164SBjoern A. Zeeb #ifdef DDB
7205fc4164SBjoern A. Zeeb #include <ddb/ddb.h>
7305fc4164SBjoern A. Zeeb #endif
7405fc4164SBjoern A. Zeeb 
75fba9235dSBruce Evans #include <net/if.h>
7676039bc8SGleb Smirnoff #include <net/if_var.h>
774fb3a820SAlexander V. Chernikov #include <net/if_dl.h>
78df8bae1dSRodney W. Grimes #include <net/bpf.h>
794d621040SChristian S.J. Peron #include <net/bpf_buffer.h>
80ae275efcSJung-uk Kim #ifdef BPF_JITTER
81ae275efcSJung-uk Kim #include <net/bpf_jitter.h>
82ae275efcSJung-uk Kim #endif
834d621040SChristian S.J. Peron #include <net/bpf_zerocopy.h>
84df8bae1dSRodney W. Grimes #include <net/bpfdesc.h>
854fb3a820SAlexander V. Chernikov #include <net/route.h>
86530c0060SRobert Watson #include <net/vnet.h>
87df8bae1dSRodney W. Grimes 
88df8bae1dSRodney W. Grimes #include <netinet/in.h>
89df8bae1dSRodney W. Grimes #include <netinet/if_ether.h>
90df8bae1dSRodney W. Grimes #include <sys/kernel.h>
91f708ef1bSPoul-Henning Kamp #include <sys/sysctl.h>
927b778b5eSEivind Eklund 
93246b5467SSam Leffler #include <net80211/ieee80211_freebsd.h>
94246b5467SSam Leffler 
95aed55708SRobert Watson #include <security/mac/mac_framework.h>
96aed55708SRobert Watson 
974d621040SChristian S.J. Peron MALLOC_DEFINE(M_BPF, "BPF", "BPF data");
9887f6c662SJulian Elischer 
99b23cbbe6SMark Johnston struct bpf_if {
100b23cbbe6SMark Johnston #define	bif_next	bif_ext.bif_next
101b23cbbe6SMark Johnston #define	bif_dlist	bif_ext.bif_dlist
102b23cbbe6SMark Johnston 	struct bpf_if_ext bif_ext;	/* public members */
103b23cbbe6SMark Johnston 	u_int		bif_dlt;	/* link layer type */
104b23cbbe6SMark Johnston 	u_int		bif_hdrlen;	/* length of link header */
105b23cbbe6SMark Johnston 	struct ifnet	*bif_ifp;	/* corresponding interface */
106b23cbbe6SMark Johnston 	struct rwlock	bif_lock;	/* interface lock */
107b23cbbe6SMark Johnston 	LIST_HEAD(, bpf_d) bif_wlist;	/* writer-only list */
108b23cbbe6SMark Johnston 	int		bif_flags;	/* Interface flags */
109b23cbbe6SMark Johnston };
110b23cbbe6SMark Johnston 
111b23cbbe6SMark Johnston CTASSERT(offsetof(struct bpf_if, bif_ext) == 0);
112b23cbbe6SMark Johnston 
1135bb5f2c9SPeter Wemm #if defined(DEV_BPF) || defined(NETGRAPH_BPF)
11453ac6efbSJulian Elischer 
115df8bae1dSRodney W. Grimes #define PRINET  26			/* interruptible */
116df8bae1dSRodney W. Grimes 
117547d94bdSJung-uk Kim #define	SIZEOF_BPF_HDR(type)	\
118547d94bdSJung-uk Kim     (offsetof(type, bh_hdrlen) + sizeof(((type *)0)->bh_hdrlen))
119547d94bdSJung-uk Kim 
120fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
121fc0a61a4SKonstantin Belousov #include <sys/mount.h>
122fc0a61a4SKonstantin Belousov #include <compat/freebsd32/freebsd32.h>
123fc0a61a4SKonstantin Belousov #define BPF_ALIGNMENT32 sizeof(int32_t)
124d9c9c81cSPedro F. Giffuni #define	BPF_WORDALIGN32(x) roundup2(x, BPF_ALIGNMENT32)
125fc0a61a4SKonstantin Belousov 
126547d94bdSJung-uk Kim #ifndef BURN_BRIDGES
127fc0a61a4SKonstantin Belousov /*
128fc0a61a4SKonstantin Belousov  * 32-bit version of structure prepended to each packet.  We use this header
129fc0a61a4SKonstantin Belousov  * instead of the standard one for 32-bit streams.  We mark the a stream as
130fc0a61a4SKonstantin Belousov  * 32-bit the first time we see a 32-bit compat ioctl request.
131fc0a61a4SKonstantin Belousov  */
132fc0a61a4SKonstantin Belousov struct bpf_hdr32 {
133fc0a61a4SKonstantin Belousov 	struct timeval32 bh_tstamp;	/* time stamp */
134fc0a61a4SKonstantin Belousov 	uint32_t	bh_caplen;	/* length of captured portion */
135fc0a61a4SKonstantin Belousov 	uint32_t	bh_datalen;	/* original length of packet */
136fc0a61a4SKonstantin Belousov 	uint16_t	bh_hdrlen;	/* length of bpf header (this struct
137fc0a61a4SKonstantin Belousov 					   plus alignment padding) */
138fc0a61a4SKonstantin Belousov };
139253a3814SLawrence Stewart #endif
140fc0a61a4SKonstantin Belousov 
141fc0a61a4SKonstantin Belousov struct bpf_program32 {
142fc0a61a4SKonstantin Belousov 	u_int bf_len;
143fc0a61a4SKonstantin Belousov 	uint32_t bf_insns;
144fc0a61a4SKonstantin Belousov };
145fc0a61a4SKonstantin Belousov 
146fc0a61a4SKonstantin Belousov struct bpf_dltlist32 {
147fc0a61a4SKonstantin Belousov 	u_int	bfl_len;
148fc0a61a4SKonstantin Belousov 	u_int	bfl_list;
149fc0a61a4SKonstantin Belousov };
150fc0a61a4SKonstantin Belousov 
151fc0a61a4SKonstantin Belousov #define	BIOCSETF32	_IOW('B', 103, struct bpf_program32)
152fc0a61a4SKonstantin Belousov #define	BIOCSRTIMEOUT32	_IOW('B', 109, struct timeval32)
153fc0a61a4SKonstantin Belousov #define	BIOCGRTIMEOUT32	_IOR('B', 110, struct timeval32)
154fc0a61a4SKonstantin Belousov #define	BIOCGDLTLIST32	_IOWR('B', 121, struct bpf_dltlist32)
155fc0a61a4SKonstantin Belousov #define	BIOCSETWF32	_IOW('B', 123, struct bpf_program32)
156fc0a61a4SKonstantin Belousov #define	BIOCSETFNR32	_IOW('B', 130, struct bpf_program32)
157253a3814SLawrence Stewart #endif
158fc0a61a4SKonstantin Belousov 
159df8bae1dSRodney W. Grimes /*
160d1a67300SRobert Watson  * bpf_iflist is a list of BPF interface structures, each corresponding to a
161d1a67300SRobert Watson  * specific DLT.  The same network interface might have several BPF interface
162d1a67300SRobert Watson  * structures registered by different layers in the stack (i.e., 802.11
163d1a67300SRobert Watson  * frames, ethernet frames, etc).
164df8bae1dSRodney W. Grimes  */
165f079a0faSAlexander V. Chernikov static LIST_HEAD(, bpf_if)	bpf_iflist, bpf_freelist;
166e7bb21b3SJonathan Lemon static struct mtx	bpf_mtx;		/* bpf global lock */
16769f7644bSChristian S.J. Peron static int		bpf_bpfd_cnt;
168df8bae1dSRodney W. Grimes 
16919ba8395SChristian S.J. Peron static void	bpf_attachd(struct bpf_d *, struct bpf_if *);
17019ba8395SChristian S.J. Peron static void	bpf_detachd(struct bpf_d *);
1716c74ff0eSAlexander V. Chernikov static void	bpf_detachd_locked(struct bpf_d *);
172929ddbbbSAlfred Perlstein static void	bpf_freed(struct bpf_d *);
173cb44b6dfSAndrew Thompson static int	bpf_movein(struct uio *, int, struct ifnet *, struct mbuf **,
1744fb3a820SAlexander V. Chernikov 		    struct sockaddr *, int *, struct bpf_d *);
175929ddbbbSAlfred Perlstein static int	bpf_setif(struct bpf_d *, struct ifreq *);
176929ddbbbSAlfred Perlstein static void	bpf_timed_out(void *);
177e7bb21b3SJonathan Lemon static __inline void
178929ddbbbSAlfred Perlstein 		bpf_wakeup(struct bpf_d *);
1794d621040SChristian S.J. Peron static void	catchpacket(struct bpf_d *, u_char *, u_int, u_int,
1804d621040SChristian S.J. Peron 		    void (*)(struct bpf_d *, caddr_t, u_int, void *, u_int),
181547d94bdSJung-uk Kim 		    struct bintime *);
182929ddbbbSAlfred Perlstein static void	reset_d(struct bpf_d *);
18393e39f0bSChristian S.J. Peron static int	bpf_setf(struct bpf_d *, struct bpf_program *, u_long cmd);
1848eab61f3SSam Leffler static int	bpf_getdltlist(struct bpf_d *, struct bpf_dltlist *);
1858eab61f3SSam Leffler static int	bpf_setdlt(struct bpf_d *, u_int);
18695aab9ccSJohn-Mark Gurney static void	filt_bpfdetach(struct knote *);
18795aab9ccSJohn-Mark Gurney static int	filt_bpfread(struct knote *, long);
188a3272e3cSChristian S.J. Peron static void	bpf_drvinit(void *);
18969f7644bSChristian S.J. Peron static int	bpf_stats_sysctl(SYSCTL_HANDLER_ARGS);
19069f7644bSChristian S.J. Peron 
19169f7644bSChristian S.J. Peron SYSCTL_NODE(_net, OID_AUTO, bpf, CTLFLAG_RW, 0, "bpf sysctl");
19212dc9582SJung-uk Kim int bpf_maxinsns = BPF_MAXINSNS;
19369f7644bSChristian S.J. Peron SYSCTL_INT(_net_bpf, OID_AUTO, maxinsns, CTLFLAG_RW,
19469f7644bSChristian S.J. Peron     &bpf_maxinsns, 0, "Maximum bpf program instructions");
195ffeeb924SChristian S.J. Peron static int bpf_zerocopy_enable = 0;
1964d621040SChristian S.J. Peron SYSCTL_INT(_net_bpf, OID_AUTO, zerocopy_enable, CTLFLAG_RW,
1974d621040SChristian S.J. Peron     &bpf_zerocopy_enable, 0, "Enable new zero-copy BPF buffer sessions");
1986472ac3dSEd Schouten static SYSCTL_NODE(_net_bpf, OID_AUTO, stats, CTLFLAG_MPSAFE | CTLFLAG_RW,
19969f7644bSChristian S.J. Peron     bpf_stats_sysctl, "bpf statistics portal");
200df8bae1dSRodney W. Grimes 
20151ec1eb7SAlexander V. Chernikov static VNET_DEFINE(int, bpf_optimize_writers) = 0;
20251ec1eb7SAlexander V. Chernikov #define	V_bpf_optimize_writers VNET(bpf_optimize_writers)
2036df8a710SGleb Smirnoff SYSCTL_INT(_net_bpf, OID_AUTO, optimize_writers, CTLFLAG_VNET | CTLFLAG_RW,
2046df8a710SGleb Smirnoff     &VNET_NAME(bpf_optimize_writers), 0,
20551ec1eb7SAlexander V. Chernikov     "Do not send packets until BPF program is set");
20651ec1eb7SAlexander V. Chernikov 
20787f6c662SJulian Elischer static	d_open_t	bpfopen;
20887f6c662SJulian Elischer static	d_read_t	bpfread;
20987f6c662SJulian Elischer static	d_write_t	bpfwrite;
21087f6c662SJulian Elischer static	d_ioctl_t	bpfioctl;
211243ac7d8SPeter Wemm static	d_poll_t	bpfpoll;
21295aab9ccSJohn-Mark Gurney static	d_kqfilter_t	bpfkqfilter;
21387f6c662SJulian Elischer 
2144e2f199eSPoul-Henning Kamp static struct cdevsw bpf_cdevsw = {
215dc08ffecSPoul-Henning Kamp 	.d_version =	D_VERSION,
2167ac40f5fSPoul-Henning Kamp 	.d_open =	bpfopen,
2177ac40f5fSPoul-Henning Kamp 	.d_read =	bpfread,
2187ac40f5fSPoul-Henning Kamp 	.d_write =	bpfwrite,
2197ac40f5fSPoul-Henning Kamp 	.d_ioctl =	bpfioctl,
2207ac40f5fSPoul-Henning Kamp 	.d_poll =	bpfpoll,
2217ac40f5fSPoul-Henning Kamp 	.d_name =	"bpf",
22295aab9ccSJohn-Mark Gurney 	.d_kqfilter =	bpfkqfilter,
2234e2f199eSPoul-Henning Kamp };
22487f6c662SJulian Elischer 
225e76d823bSRobert Watson static struct filterops bpfread_filtops = {
226e76d823bSRobert Watson 	.f_isfd = 1,
227e76d823bSRobert Watson 	.f_detach = filt_bpfdetach,
228e76d823bSRobert Watson 	.f_event = filt_bpfread,
229e76d823bSRobert Watson };
23087f6c662SJulian Elischer 
231afa85850SAlexander V. Chernikov eventhandler_tag	bpf_ifdetach_cookie = NULL;
232afa85850SAlexander V. Chernikov 
2334d621040SChristian S.J. Peron /*
2346c74ff0eSAlexander V. Chernikov  * LOCKING MODEL USED BY BPF:
2356c74ff0eSAlexander V. Chernikov  * Locks:
2366c74ff0eSAlexander V. Chernikov  * 1) global lock (BPF_LOCK). Mutex, used to protect interface addition/removal,
2376c74ff0eSAlexander V. Chernikov  * some global counters and every bpf_if reference.
2386c74ff0eSAlexander V. Chernikov  * 2) Interface lock. Rwlock, used to protect list of BPF descriptors and their filters.
239afa85850SAlexander V. Chernikov  * 3) Descriptor lock. Mutex, used to protect BPF buffers and various structure fields
2406c74ff0eSAlexander V. Chernikov  *   used by bpf_mtap code.
2416c74ff0eSAlexander V. Chernikov  *
2426c74ff0eSAlexander V. Chernikov  * Lock order:
2436c74ff0eSAlexander V. Chernikov  *
2446c74ff0eSAlexander V. Chernikov  * Global lock, interface lock, descriptor lock
2456c74ff0eSAlexander V. Chernikov  *
2466c74ff0eSAlexander V. Chernikov  * We have to acquire interface lock before descriptor main lock due to BPF_MTAP[2]
2476c74ff0eSAlexander V. Chernikov  * working model. In many places (like bpf_detachd) we start with BPF descriptor
2486c74ff0eSAlexander V. Chernikov  * (and we need to at least rlock it to get reliable interface pointer). This
2496c74ff0eSAlexander V. Chernikov  * gives us potential LOR. As a result, we use global lock to protect from bpf_if
2506c74ff0eSAlexander V. Chernikov  * change in every such place.
2516c74ff0eSAlexander V. Chernikov  *
2526c74ff0eSAlexander V. Chernikov  * Changing d->bd_bif is protected by 1) global lock, 2) interface lock and
2536c74ff0eSAlexander V. Chernikov  * 3) descriptor main wlock.
2546c74ff0eSAlexander V. Chernikov  * Reading bd_bif can be protected by any of these locks, typically global lock.
2556c74ff0eSAlexander V. Chernikov  *
2566c74ff0eSAlexander V. Chernikov  * Changing read/write BPF filter is protected by the same three locks,
2576c74ff0eSAlexander V. Chernikov  * the same applies for reading.
2586c74ff0eSAlexander V. Chernikov  *
2596c74ff0eSAlexander V. Chernikov  * Sleeping in global lock is not allowed due to bpfdetach() using it.
2606c74ff0eSAlexander V. Chernikov  */
2616c74ff0eSAlexander V. Chernikov 
2626c74ff0eSAlexander V. Chernikov /*
2634d621040SChristian S.J. Peron  * Wrapper functions for various buffering methods.  If the set of buffer
2644d621040SChristian S.J. Peron  * modes expands, we will probably want to introduce a switch data structure
2654d621040SChristian S.J. Peron  * similar to protosw, et.
2664d621040SChristian S.J. Peron  */
2674d621040SChristian S.J. Peron static void
2684d621040SChristian S.J. Peron bpf_append_bytes(struct bpf_d *d, caddr_t buf, u_int offset, void *src,
2694d621040SChristian S.J. Peron     u_int len)
2704d621040SChristian S.J. Peron {
2714d621040SChristian S.J. Peron 
272afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
2734d621040SChristian S.J. Peron 
2744d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
2754d621040SChristian S.J. Peron 	case BPF_BUFMODE_BUFFER:
2764d621040SChristian S.J. Peron 		return (bpf_buffer_append_bytes(d, buf, offset, src, len));
2774d621040SChristian S.J. Peron 
2784d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
2794d621040SChristian S.J. Peron 		d->bd_zcopy++;
2804d621040SChristian S.J. Peron 		return (bpf_zerocopy_append_bytes(d, buf, offset, src, len));
2814d621040SChristian S.J. Peron 
2824d621040SChristian S.J. Peron 	default:
2834d621040SChristian S.J. Peron 		panic("bpf_buf_append_bytes");
2844d621040SChristian S.J. Peron 	}
2854d621040SChristian S.J. Peron }
2864d621040SChristian S.J. Peron 
2874d621040SChristian S.J. Peron static void
2884d621040SChristian S.J. Peron bpf_append_mbuf(struct bpf_d *d, caddr_t buf, u_int offset, void *src,
2894d621040SChristian S.J. Peron     u_int len)
2904d621040SChristian S.J. Peron {
2914d621040SChristian S.J. Peron 
292afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
2934d621040SChristian S.J. Peron 
2944d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
2954d621040SChristian S.J. Peron 	case BPF_BUFMODE_BUFFER:
2964d621040SChristian S.J. Peron 		return (bpf_buffer_append_mbuf(d, buf, offset, src, len));
2974d621040SChristian S.J. Peron 
2984d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
2994d621040SChristian S.J. Peron 		d->bd_zcopy++;
3004d621040SChristian S.J. Peron 		return (bpf_zerocopy_append_mbuf(d, buf, offset, src, len));
3014d621040SChristian S.J. Peron 
3024d621040SChristian S.J. Peron 	default:
3034d621040SChristian S.J. Peron 		panic("bpf_buf_append_mbuf");
3044d621040SChristian S.J. Peron 	}
3054d621040SChristian S.J. Peron }
3064d621040SChristian S.J. Peron 
3074d621040SChristian S.J. Peron /*
30829f612ecSChristian S.J. Peron  * This function gets called when the free buffer is re-assigned.
30929f612ecSChristian S.J. Peron  */
31029f612ecSChristian S.J. Peron static void
31129f612ecSChristian S.J. Peron bpf_buf_reclaimed(struct bpf_d *d)
31229f612ecSChristian S.J. Peron {
31329f612ecSChristian S.J. Peron 
314afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
31529f612ecSChristian S.J. Peron 
31629f612ecSChristian S.J. Peron 	switch (d->bd_bufmode) {
31729f612ecSChristian S.J. Peron 	case BPF_BUFMODE_BUFFER:
31829f612ecSChristian S.J. Peron 		return;
31929f612ecSChristian S.J. Peron 
32029f612ecSChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
32129f612ecSChristian S.J. Peron 		bpf_zerocopy_buf_reclaimed(d);
32229f612ecSChristian S.J. Peron 		return;
32329f612ecSChristian S.J. Peron 
32429f612ecSChristian S.J. Peron 	default:
32529f612ecSChristian S.J. Peron 		panic("bpf_buf_reclaimed");
32629f612ecSChristian S.J. Peron 	}
32729f612ecSChristian S.J. Peron }
32829f612ecSChristian S.J. Peron 
32929f612ecSChristian S.J. Peron /*
3304d621040SChristian S.J. Peron  * If the buffer mechanism has a way to decide that a held buffer can be made
3314d621040SChristian S.J. Peron  * free, then it is exposed via the bpf_canfreebuf() interface.  (1) is
3324d621040SChristian S.J. Peron  * returned if the buffer can be discarded, (0) is returned if it cannot.
3334d621040SChristian S.J. Peron  */
3344d621040SChristian S.J. Peron static int
3354d621040SChristian S.J. Peron bpf_canfreebuf(struct bpf_d *d)
3364d621040SChristian S.J. Peron {
3374d621040SChristian S.J. Peron 
3384d621040SChristian S.J. Peron 	BPFD_LOCK_ASSERT(d);
3394d621040SChristian S.J. Peron 
3404d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
3414d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
3424d621040SChristian S.J. Peron 		return (bpf_zerocopy_canfreebuf(d));
3434d621040SChristian S.J. Peron 	}
3444d621040SChristian S.J. Peron 	return (0);
3454d621040SChristian S.J. Peron }
3464d621040SChristian S.J. Peron 
347a7a91e65SRobert Watson /*
348a7a91e65SRobert Watson  * Allow the buffer model to indicate that the current store buffer is
349a7a91e65SRobert Watson  * immutable, regardless of the appearance of space.  Return (1) if the
350a7a91e65SRobert Watson  * buffer is writable, and (0) if not.
351a7a91e65SRobert Watson  */
352a7a91e65SRobert Watson static int
353a7a91e65SRobert Watson bpf_canwritebuf(struct bpf_d *d)
354a7a91e65SRobert Watson {
355a7a91e65SRobert Watson 	BPFD_LOCK_ASSERT(d);
356a7a91e65SRobert Watson 
357a7a91e65SRobert Watson 	switch (d->bd_bufmode) {
358a7a91e65SRobert Watson 	case BPF_BUFMODE_ZBUF:
359a7a91e65SRobert Watson 		return (bpf_zerocopy_canwritebuf(d));
360a7a91e65SRobert Watson 	}
361a7a91e65SRobert Watson 	return (1);
362a7a91e65SRobert Watson }
363a7a91e65SRobert Watson 
364a7a91e65SRobert Watson /*
365a7a91e65SRobert Watson  * Notify buffer model that an attempt to write to the store buffer has
366a7a91e65SRobert Watson  * resulted in a dropped packet, in which case the buffer may be considered
367a7a91e65SRobert Watson  * full.
368a7a91e65SRobert Watson  */
369a7a91e65SRobert Watson static void
370a7a91e65SRobert Watson bpf_buffull(struct bpf_d *d)
371a7a91e65SRobert Watson {
372a7a91e65SRobert Watson 
373afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
374a7a91e65SRobert Watson 
375a7a91e65SRobert Watson 	switch (d->bd_bufmode) {
376a7a91e65SRobert Watson 	case BPF_BUFMODE_ZBUF:
377a7a91e65SRobert Watson 		bpf_zerocopy_buffull(d);
378a7a91e65SRobert Watson 		break;
379a7a91e65SRobert Watson 	}
380a7a91e65SRobert Watson }
381a7a91e65SRobert Watson 
382a7a91e65SRobert Watson /*
383a7a91e65SRobert Watson  * Notify the buffer model that a buffer has moved into the hold position.
384a7a91e65SRobert Watson  */
3854d621040SChristian S.J. Peron void
3864d621040SChristian S.J. Peron bpf_bufheld(struct bpf_d *d)
3874d621040SChristian S.J. Peron {
3884d621040SChristian S.J. Peron 
389afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
3904d621040SChristian S.J. Peron 
3914d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
3924d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
3934d621040SChristian S.J. Peron 		bpf_zerocopy_bufheld(d);
3944d621040SChristian S.J. Peron 		break;
3954d621040SChristian S.J. Peron 	}
3964d621040SChristian S.J. Peron }
3974d621040SChristian S.J. Peron 
3984d621040SChristian S.J. Peron static void
3994d621040SChristian S.J. Peron bpf_free(struct bpf_d *d)
4004d621040SChristian S.J. Peron {
4014d621040SChristian S.J. Peron 
4024d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
4034d621040SChristian S.J. Peron 	case BPF_BUFMODE_BUFFER:
4044d621040SChristian S.J. Peron 		return (bpf_buffer_free(d));
4054d621040SChristian S.J. Peron 
4064d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
4074d621040SChristian S.J. Peron 		return (bpf_zerocopy_free(d));
4084d621040SChristian S.J. Peron 
4094d621040SChristian S.J. Peron 	default:
4104d621040SChristian S.J. Peron 		panic("bpf_buf_free");
4114d621040SChristian S.J. Peron 	}
4124d621040SChristian S.J. Peron }
4134d621040SChristian S.J. Peron 
4144d621040SChristian S.J. Peron static int
4154d621040SChristian S.J. Peron bpf_uiomove(struct bpf_d *d, caddr_t buf, u_int len, struct uio *uio)
4164d621040SChristian S.J. Peron {
4174d621040SChristian S.J. Peron 
4184d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_BUFFER)
4194d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
4204d621040SChristian S.J. Peron 	return (bpf_buffer_uiomove(d, buf, len, uio));
4214d621040SChristian S.J. Peron }
4224d621040SChristian S.J. Peron 
4234d621040SChristian S.J. Peron static int
4244d621040SChristian S.J. Peron bpf_ioctl_sblen(struct bpf_d *d, u_int *i)
4254d621040SChristian S.J. Peron {
4264d621040SChristian S.J. Peron 
4274d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_BUFFER)
4284d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
4294d621040SChristian S.J. Peron 	return (bpf_buffer_ioctl_sblen(d, i));
4304d621040SChristian S.J. Peron }
4314d621040SChristian S.J. Peron 
4324d621040SChristian S.J. Peron static int
4334d621040SChristian S.J. Peron bpf_ioctl_getzmax(struct thread *td, struct bpf_d *d, size_t *i)
4344d621040SChristian S.J. Peron {
4354d621040SChristian S.J. Peron 
4364d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_ZBUF)
4374d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
4384d621040SChristian S.J. Peron 	return (bpf_zerocopy_ioctl_getzmax(td, d, i));
4394d621040SChristian S.J. Peron }
4404d621040SChristian S.J. Peron 
4414d621040SChristian S.J. Peron static int
4424d621040SChristian S.J. Peron bpf_ioctl_rotzbuf(struct thread *td, struct bpf_d *d, struct bpf_zbuf *bz)
4434d621040SChristian S.J. Peron {
4444d621040SChristian S.J. Peron 
4454d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_ZBUF)
4464d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
4474d621040SChristian S.J. Peron 	return (bpf_zerocopy_ioctl_rotzbuf(td, d, bz));
4484d621040SChristian S.J. Peron }
4494d621040SChristian S.J. Peron 
4504d621040SChristian S.J. Peron static int
4514d621040SChristian S.J. Peron bpf_ioctl_setzbuf(struct thread *td, struct bpf_d *d, struct bpf_zbuf *bz)
4524d621040SChristian S.J. Peron {
4534d621040SChristian S.J. Peron 
4544d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_ZBUF)
4554d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
4564d621040SChristian S.J. Peron 	return (bpf_zerocopy_ioctl_setzbuf(td, d, bz));
4574d621040SChristian S.J. Peron }
4584d621040SChristian S.J. Peron 
4594d621040SChristian S.J. Peron /*
4604d621040SChristian S.J. Peron  * General BPF functions.
4614d621040SChristian S.J. Peron  */
462df8bae1dSRodney W. Grimes static int
463cb44b6dfSAndrew Thompson bpf_movein(struct uio *uio, int linktype, struct ifnet *ifp, struct mbuf **mp,
4644fb3a820SAlexander V. Chernikov     struct sockaddr *sockp, int *hdrlen, struct bpf_d *d)
465df8bae1dSRodney W. Grimes {
466246b5467SSam Leffler 	const struct ieee80211_bpf_params *p;
467cb44b6dfSAndrew Thompson 	struct ether_header *eh;
468df8bae1dSRodney W. Grimes 	struct mbuf *m;
469df8bae1dSRodney W. Grimes 	int error;
470df8bae1dSRodney W. Grimes 	int len;
471df8bae1dSRodney W. Grimes 	int hlen;
47293e39f0bSChristian S.J. Peron 	int slen;
473df8bae1dSRodney W. Grimes 
474df8bae1dSRodney W. Grimes 	/*
475df8bae1dSRodney W. Grimes 	 * Build a sockaddr based on the data link layer type.
476df8bae1dSRodney W. Grimes 	 * We do this at this level because the ethernet header
477df8bae1dSRodney W. Grimes 	 * is copied directly into the data field of the sockaddr.
478df8bae1dSRodney W. Grimes 	 * In the case of SLIP, there is no header and the packet
479df8bae1dSRodney W. Grimes 	 * is forwarded as is.
480df8bae1dSRodney W. Grimes 	 * Also, we are careful to leave room at the front of the mbuf
481df8bae1dSRodney W. Grimes 	 * for the link level header.
482df8bae1dSRodney W. Grimes 	 */
483df8bae1dSRodney W. Grimes 	switch (linktype) {
484df8bae1dSRodney W. Grimes 
485df8bae1dSRodney W. Grimes 	case DLT_SLIP:
486df8bae1dSRodney W. Grimes 		sockp->sa_family = AF_INET;
487df8bae1dSRodney W. Grimes 		hlen = 0;
488df8bae1dSRodney W. Grimes 		break;
489df8bae1dSRodney W. Grimes 
490df8bae1dSRodney W. Grimes 	case DLT_EN10MB:
491df8bae1dSRodney W. Grimes 		sockp->sa_family = AF_UNSPEC;
492df8bae1dSRodney W. Grimes 		/* XXX Would MAXLINKHDR be better? */
493797f247bSMatthew N. Dodd 		hlen = ETHER_HDR_LEN;
494df8bae1dSRodney W. Grimes 		break;
495df8bae1dSRodney W. Grimes 
496df8bae1dSRodney W. Grimes 	case DLT_FDDI:
497d41f24e7SDavid Greenman 		sockp->sa_family = AF_IMPLINK;
498d41f24e7SDavid Greenman 		hlen = 0;
499df8bae1dSRodney W. Grimes 		break;
500df8bae1dSRodney W. Grimes 
50122f05c43SAndrey A. Chernov 	case DLT_RAW:
502df8bae1dSRodney W. Grimes 		sockp->sa_family = AF_UNSPEC;
503df8bae1dSRodney W. Grimes 		hlen = 0;
504df8bae1dSRodney W. Grimes 		break;
505df8bae1dSRodney W. Grimes 
50601399f34SDavid Malone 	case DLT_NULL:
50701399f34SDavid Malone 		/*
50801399f34SDavid Malone 		 * null interface types require a 4 byte pseudo header which
50901399f34SDavid Malone 		 * corresponds to the address family of the packet.
51001399f34SDavid Malone 		 */
51101399f34SDavid Malone 		sockp->sa_family = AF_UNSPEC;
51201399f34SDavid Malone 		hlen = 4;
51301399f34SDavid Malone 		break;
51401399f34SDavid Malone 
5154f53e3ccSKenjiro Cho 	case DLT_ATM_RFC1483:
5164f53e3ccSKenjiro Cho 		/*
5174f53e3ccSKenjiro Cho 		 * en atm driver requires 4-byte atm pseudo header.
5184f53e3ccSKenjiro Cho 		 * though it isn't standard, vpi:vci needs to be
5194f53e3ccSKenjiro Cho 		 * specified anyway.
5204f53e3ccSKenjiro Cho 		 */
5214f53e3ccSKenjiro Cho 		sockp->sa_family = AF_UNSPEC;
5224f53e3ccSKenjiro Cho 		hlen = 12;	/* XXX 4(ATM_PH) + 3(LLC) + 5(SNAP) */
5234f53e3ccSKenjiro Cho 		break;
5244f53e3ccSKenjiro Cho 
52530fa52a6SBrian Somers 	case DLT_PPP:
52630fa52a6SBrian Somers 		sockp->sa_family = AF_UNSPEC;
52730fa52a6SBrian Somers 		hlen = 4;	/* This should match PPP_HDRLEN */
52830fa52a6SBrian Somers 		break;
52930fa52a6SBrian Somers 
530246b5467SSam Leffler 	case DLT_IEEE802_11:		/* IEEE 802.11 wireless */
531246b5467SSam Leffler 		sockp->sa_family = AF_IEEE80211;
532246b5467SSam Leffler 		hlen = 0;
533246b5467SSam Leffler 		break;
534246b5467SSam Leffler 
535246b5467SSam Leffler 	case DLT_IEEE802_11_RADIO:	/* IEEE 802.11 wireless w/ phy params */
536246b5467SSam Leffler 		sockp->sa_family = AF_IEEE80211;
537246b5467SSam Leffler 		sockp->sa_len = 12;	/* XXX != 0 */
538246b5467SSam Leffler 		hlen = sizeof(struct ieee80211_bpf_params);
539246b5467SSam Leffler 		break;
540246b5467SSam Leffler 
541df8bae1dSRodney W. Grimes 	default:
542df8bae1dSRodney W. Grimes 		return (EIO);
543df8bae1dSRodney W. Grimes 	}
544df8bae1dSRodney W. Grimes 
545df8bae1dSRodney W. Grimes 	len = uio->uio_resid;
546ed63043bSGleb Smirnoff 	if (len < hlen || len - hlen > ifp->if_mtu)
54701399f34SDavid Malone 		return (EMSGSIZE);
54801399f34SDavid Malone 
54941a7572bSGleb Smirnoff 	m = m_get2(len, M_WAITOK, MT_DATA, M_PKTHDR);
550ed63043bSGleb Smirnoff 	if (m == NULL)
551df8bae1dSRodney W. Grimes 		return (EIO);
552963e4c2aSGarrett Wollman 	m->m_pkthdr.len = m->m_len = len;
553df8bae1dSRodney W. Grimes 	*mp = m;
55424a229f4SSam Leffler 
55593e39f0bSChristian S.J. Peron 	error = uiomove(mtod(m, u_char *), len, uio);
55693e39f0bSChristian S.J. Peron 	if (error)
55793e39f0bSChristian S.J. Peron 		goto bad;
55893e39f0bSChristian S.J. Peron 
5594fb3a820SAlexander V. Chernikov 	slen = bpf_filter(d->bd_wfilter, mtod(m, u_char *), len, len);
56093e39f0bSChristian S.J. Peron 	if (slen == 0) {
56193e39f0bSChristian S.J. Peron 		error = EPERM;
56293e39f0bSChristian S.J. Peron 		goto bad;
56393e39f0bSChristian S.J. Peron 	}
56493e39f0bSChristian S.J. Peron 
565cb44b6dfSAndrew Thompson 	/* Check for multicast destination */
566cb44b6dfSAndrew Thompson 	switch (linktype) {
567cb44b6dfSAndrew Thompson 	case DLT_EN10MB:
568cb44b6dfSAndrew Thompson 		eh = mtod(m, struct ether_header *);
569cb44b6dfSAndrew Thompson 		if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
570cb44b6dfSAndrew Thompson 			if (bcmp(ifp->if_broadcastaddr, eh->ether_dhost,
571cb44b6dfSAndrew Thompson 			    ETHER_ADDR_LEN) == 0)
572cb44b6dfSAndrew Thompson 				m->m_flags |= M_BCAST;
573cb44b6dfSAndrew Thompson 			else
574cb44b6dfSAndrew Thompson 				m->m_flags |= M_MCAST;
575cb44b6dfSAndrew Thompson 		}
5764fb3a820SAlexander V. Chernikov 		if (d->bd_hdrcmplt == 0) {
5774fb3a820SAlexander V. Chernikov 			memcpy(eh->ether_shost, IF_LLADDR(ifp),
5784fb3a820SAlexander V. Chernikov 			    sizeof(eh->ether_shost));
5794fb3a820SAlexander V. Chernikov 		}
580cb44b6dfSAndrew Thompson 		break;
581cb44b6dfSAndrew Thompson 	}
582cb44b6dfSAndrew Thompson 
583df8bae1dSRodney W. Grimes 	/*
58493e39f0bSChristian S.J. Peron 	 * Make room for link header, and copy it to sockaddr
585df8bae1dSRodney W. Grimes 	 */
586df8bae1dSRodney W. Grimes 	if (hlen != 0) {
587246b5467SSam Leffler 		if (sockp->sa_family == AF_IEEE80211) {
588246b5467SSam Leffler 			/*
589246b5467SSam Leffler 			 * Collect true length from the parameter header
590246b5467SSam Leffler 			 * NB: sockp is known to be zero'd so if we do a
591246b5467SSam Leffler 			 *     short copy unspecified parameters will be
592246b5467SSam Leffler 			 *     zero.
593246b5467SSam Leffler 			 * NB: packet may not be aligned after stripping
594246b5467SSam Leffler 			 *     bpf params
595246b5467SSam Leffler 			 * XXX check ibp_vers
596246b5467SSam Leffler 			 */
597246b5467SSam Leffler 			p = mtod(m, const struct ieee80211_bpf_params *);
598246b5467SSam Leffler 			hlen = p->ibp_len;
599246b5467SSam Leffler 			if (hlen > sizeof(sockp->sa_data)) {
600246b5467SSam Leffler 				error = EINVAL;
601246b5467SSam Leffler 				goto bad;
602246b5467SSam Leffler 			}
603246b5467SSam Leffler 		}
604a09968c4SAdrian Chadd 		bcopy(mtod(m, const void *), sockp->sa_data, hlen);
605df8bae1dSRodney W. Grimes 	}
606560a54e1SJung-uk Kim 	*hdrlen = hlen;
60793e39f0bSChristian S.J. Peron 
608df8bae1dSRodney W. Grimes 	return (0);
609df8bae1dSRodney W. Grimes bad:
610df8bae1dSRodney W. Grimes 	m_freem(m);
611df8bae1dSRodney W. Grimes 	return (error);
612df8bae1dSRodney W. Grimes }
613df8bae1dSRodney W. Grimes 
614df8bae1dSRodney W. Grimes /*
615df8bae1dSRodney W. Grimes  * Attach file to the bpf interface, i.e. make d listen on bp.
616df8bae1dSRodney W. Grimes  */
617df8bae1dSRodney W. Grimes static void
61819ba8395SChristian S.J. Peron bpf_attachd(struct bpf_d *d, struct bpf_if *bp)
619df8bae1dSRodney W. Grimes {
6206c74ff0eSAlexander V. Chernikov 	int op_w;
6216c74ff0eSAlexander V. Chernikov 
6226c74ff0eSAlexander V. Chernikov 	BPF_LOCK_ASSERT();
6236c74ff0eSAlexander V. Chernikov 
6246c74ff0eSAlexander V. Chernikov 	/*
6256c74ff0eSAlexander V. Chernikov 	 * Save sysctl value to protect from sysctl change
6266c74ff0eSAlexander V. Chernikov 	 * between reads
6276c74ff0eSAlexander V. Chernikov 	 */
62871448753SAlexander Motin 	op_w = V_bpf_optimize_writers || d->bd_writer;
6296c74ff0eSAlexander V. Chernikov 
6306c74ff0eSAlexander V. Chernikov 	if (d->bd_bif != NULL)
6316c74ff0eSAlexander V. Chernikov 		bpf_detachd_locked(d);
632df8bae1dSRodney W. Grimes 	/*
63351ec1eb7SAlexander V. Chernikov 	 * Point d at bp, and add d to the interface's list.
634f87e372eSLuiz Otavio O Souza 	 * Since there are many applications using BPF for
63551ec1eb7SAlexander V. Chernikov 	 * sending raw packets only (dhcpd, cdpd are good examples)
63651ec1eb7SAlexander V. Chernikov 	 * we can delay adding d to the list of active listeners until
63751ec1eb7SAlexander V. Chernikov 	 * some filter is configured.
638df8bae1dSRodney W. Grimes 	 */
63951ec1eb7SAlexander V. Chernikov 
64051ec1eb7SAlexander V. Chernikov 	BPFIF_WLOCK(bp);
641afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
64251ec1eb7SAlexander V. Chernikov 
6436c74ff0eSAlexander V. Chernikov 	d->bd_bif = bp;
6446c74ff0eSAlexander V. Chernikov 
6456c74ff0eSAlexander V. Chernikov 	if (op_w != 0) {
64651ec1eb7SAlexander V. Chernikov 		/* Add to writers-only list */
64751ec1eb7SAlexander V. Chernikov 		LIST_INSERT_HEAD(&bp->bif_wlist, d, bd_next);
64851ec1eb7SAlexander V. Chernikov 		/*
64951ec1eb7SAlexander V. Chernikov 		 * We decrement bd_writer on every filter set operation.
65051ec1eb7SAlexander V. Chernikov 		 * First BIOCSETF is done by pcap_open_live() to set up
65151ec1eb7SAlexander V. Chernikov 		 * snap length. After that appliation usually sets its own filter
65251ec1eb7SAlexander V. Chernikov 		 */
65351ec1eb7SAlexander V. Chernikov 		d->bd_writer = 2;
65451ec1eb7SAlexander V. Chernikov 	} else
6554a3feeaaSRobert Watson 		LIST_INSERT_HEAD(&bp->bif_dlist, d, bd_next);
656df8bae1dSRodney W. Grimes 
657afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
658e4b3229aSAlexander V. Chernikov 	BPFIF_WUNLOCK(bp);
659b743c310SSam Leffler 
66051ec1eb7SAlexander V. Chernikov 	bpf_bpfd_cnt++;
66151ec1eb7SAlexander V. Chernikov 
66251ec1eb7SAlexander V. Chernikov 	CTR3(KTR_NET, "%s: bpf_attach called by pid %d, adding to %s list",
66351ec1eb7SAlexander V. Chernikov 	    __func__, d->bd_pid, d->bd_writer ? "writer" : "active");
66451ec1eb7SAlexander V. Chernikov 
6656c74ff0eSAlexander V. Chernikov 	if (op_w == 0)
66651ec1eb7SAlexander V. Chernikov 		EVENTHANDLER_INVOKE(bpf_track, bp->bif_ifp, bp->bif_dlt, 1);
66751ec1eb7SAlexander V. Chernikov }
66851ec1eb7SAlexander V. Chernikov 
66951ec1eb7SAlexander V. Chernikov /*
670402000ffSAlexander V. Chernikov  * Check if we need to upgrade our descriptor @d from write-only mode.
671402000ffSAlexander V. Chernikov  */
672402000ffSAlexander V. Chernikov static int
673402000ffSAlexander V. Chernikov bpf_check_upgrade(u_long cmd, struct bpf_d *d, struct bpf_insn *fcode, int flen)
674402000ffSAlexander V. Chernikov {
675402000ffSAlexander V. Chernikov 	int is_snap, need_upgrade;
676402000ffSAlexander V. Chernikov 
677402000ffSAlexander V. Chernikov 	/*
678402000ffSAlexander V. Chernikov 	 * Check if we've already upgraded or new filter is empty.
679402000ffSAlexander V. Chernikov 	 */
680402000ffSAlexander V. Chernikov 	if (d->bd_writer == 0 || fcode == NULL)
681402000ffSAlexander V. Chernikov 		return (0);
682402000ffSAlexander V. Chernikov 
683402000ffSAlexander V. Chernikov 	need_upgrade = 0;
684402000ffSAlexander V. Chernikov 
685402000ffSAlexander V. Chernikov 	/*
686402000ffSAlexander V. Chernikov 	 * Check if cmd looks like snaplen setting from
687402000ffSAlexander V. Chernikov 	 * pcap_bpf.c:pcap_open_live().
688402000ffSAlexander V. Chernikov 	 * Note we're not checking .k value here:
689402000ffSAlexander V. Chernikov 	 * while pcap_open_live() definitely sets to to non-zero value,
690402000ffSAlexander V. Chernikov 	 * we'd prefer to treat k=0 (deny ALL) case the same way: e.g.
691402000ffSAlexander V. Chernikov 	 * do not consider upgrading immediately
692402000ffSAlexander V. Chernikov 	 */
693402000ffSAlexander V. Chernikov 	if (cmd == BIOCSETF && flen == 1 && fcode[0].code == (BPF_RET | BPF_K))
694402000ffSAlexander V. Chernikov 		is_snap = 1;
695402000ffSAlexander V. Chernikov 	else
696402000ffSAlexander V. Chernikov 		is_snap = 0;
697402000ffSAlexander V. Chernikov 
698402000ffSAlexander V. Chernikov 	if (is_snap == 0) {
699402000ffSAlexander V. Chernikov 		/*
700402000ffSAlexander V. Chernikov 		 * We're setting first filter and it doesn't look like
701402000ffSAlexander V. Chernikov 		 * setting snaplen.  We're probably using bpf directly.
702402000ffSAlexander V. Chernikov 		 * Upgrade immediately.
703402000ffSAlexander V. Chernikov 		 */
704402000ffSAlexander V. Chernikov 		need_upgrade = 1;
705402000ffSAlexander V. Chernikov 	} else {
706402000ffSAlexander V. Chernikov 		/*
707402000ffSAlexander V. Chernikov 		 * Do not require upgrade by first BIOCSETF
708402000ffSAlexander V. Chernikov 		 * (used to set snaplen) by pcap_open_live().
709402000ffSAlexander V. Chernikov 		 */
710402000ffSAlexander V. Chernikov 
711402000ffSAlexander V. Chernikov 		if (--d->bd_writer == 0) {
712402000ffSAlexander V. Chernikov 			/*
713402000ffSAlexander V. Chernikov 			 * First snaplen filter has already
714402000ffSAlexander V. Chernikov 			 * been set. This is probably catch-all
715402000ffSAlexander V. Chernikov 			 * filter
716402000ffSAlexander V. Chernikov 			 */
717402000ffSAlexander V. Chernikov 			need_upgrade = 1;
718402000ffSAlexander V. Chernikov 		}
719402000ffSAlexander V. Chernikov 	}
720402000ffSAlexander V. Chernikov 
721402000ffSAlexander V. Chernikov 	CTR5(KTR_NET,
722402000ffSAlexander V. Chernikov 	    "%s: filter function set by pid %d, "
723402000ffSAlexander V. Chernikov 	    "bd_writer counter %d, snap %d upgrade %d",
724402000ffSAlexander V. Chernikov 	    __func__, d->bd_pid, d->bd_writer,
725402000ffSAlexander V. Chernikov 	    is_snap, need_upgrade);
726402000ffSAlexander V. Chernikov 
727402000ffSAlexander V. Chernikov 	return (need_upgrade);
728402000ffSAlexander V. Chernikov }
729402000ffSAlexander V. Chernikov 
730402000ffSAlexander V. Chernikov /*
73151ec1eb7SAlexander V. Chernikov  * Add d to the list of active bp filters.
732f87e372eSLuiz Otavio O Souza  * Requires bpf_attachd() to be called before.
73351ec1eb7SAlexander V. Chernikov  */
73451ec1eb7SAlexander V. Chernikov static void
73551ec1eb7SAlexander V. Chernikov bpf_upgraded(struct bpf_d *d)
73651ec1eb7SAlexander V. Chernikov {
73751ec1eb7SAlexander V. Chernikov 	struct bpf_if *bp;
73851ec1eb7SAlexander V. Chernikov 
7396c74ff0eSAlexander V. Chernikov 	BPF_LOCK_ASSERT();
7406c74ff0eSAlexander V. Chernikov 
74151ec1eb7SAlexander V. Chernikov 	bp = d->bd_bif;
74251ec1eb7SAlexander V. Chernikov 
7436c74ff0eSAlexander V. Chernikov 	/*
7446c74ff0eSAlexander V. Chernikov 	 * Filter can be set several times without specifying interface.
7456c74ff0eSAlexander V. Chernikov 	 * Mark d as reader and exit.
7466c74ff0eSAlexander V. Chernikov 	 */
7476c74ff0eSAlexander V. Chernikov 	if (bp == NULL) {
748afa85850SAlexander V. Chernikov 		BPFD_LOCK(d);
7496c74ff0eSAlexander V. Chernikov 		d->bd_writer = 0;
750afa85850SAlexander V. Chernikov 		BPFD_UNLOCK(d);
7516c74ff0eSAlexander V. Chernikov 		return;
7526c74ff0eSAlexander V. Chernikov 	}
7536c74ff0eSAlexander V. Chernikov 
75451ec1eb7SAlexander V. Chernikov 	BPFIF_WLOCK(bp);
755afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
75651ec1eb7SAlexander V. Chernikov 
75751ec1eb7SAlexander V. Chernikov 	/* Remove from writers-only list */
75851ec1eb7SAlexander V. Chernikov 	LIST_REMOVE(d, bd_next);
75951ec1eb7SAlexander V. Chernikov 	LIST_INSERT_HEAD(&bp->bif_dlist, d, bd_next);
76051ec1eb7SAlexander V. Chernikov 	/* Mark d as reader */
76151ec1eb7SAlexander V. Chernikov 	d->bd_writer = 0;
76251ec1eb7SAlexander V. Chernikov 
763afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
76451ec1eb7SAlexander V. Chernikov 	BPFIF_WUNLOCK(bp);
76551ec1eb7SAlexander V. Chernikov 
76651ec1eb7SAlexander V. Chernikov 	CTR2(KTR_NET, "%s: upgrade required by pid %d", __func__, d->bd_pid);
76751ec1eb7SAlexander V. Chernikov 
7685ce8d970SSam Leffler 	EVENTHANDLER_INVOKE(bpf_track, bp->bif_ifp, bp->bif_dlt, 1);
769df8bae1dSRodney W. Grimes }
770df8bae1dSRodney W. Grimes 
771df8bae1dSRodney W. Grimes /*
772df8bae1dSRodney W. Grimes  * Detach a file from its interface.
773df8bae1dSRodney W. Grimes  */
774df8bae1dSRodney W. Grimes static void
77519ba8395SChristian S.J. Peron bpf_detachd(struct bpf_d *d)
776df8bae1dSRodney W. Grimes {
7776c74ff0eSAlexander V. Chernikov 	BPF_LOCK();
7786c74ff0eSAlexander V. Chernikov 	bpf_detachd_locked(d);
7796c74ff0eSAlexander V. Chernikov 	BPF_UNLOCK();
7806c74ff0eSAlexander V. Chernikov }
7816c74ff0eSAlexander V. Chernikov 
7826c74ff0eSAlexander V. Chernikov static void
7836c74ff0eSAlexander V. Chernikov bpf_detachd_locked(struct bpf_d *d)
7846c74ff0eSAlexander V. Chernikov {
7856e891d64SPoul-Henning Kamp 	int error;
786df8bae1dSRodney W. Grimes 	struct bpf_if *bp;
78746448b5aSRobert Watson 	struct ifnet *ifp;
788df8bae1dSRodney W. Grimes 
78951ec1eb7SAlexander V. Chernikov 	CTR2(KTR_NET, "%s: detach required by pid %d", __func__, d->bd_pid);
79051ec1eb7SAlexander V. Chernikov 
791e4b3229aSAlexander V. Chernikov 	BPF_LOCK_ASSERT();
792e4b3229aSAlexander V. Chernikov 
7936c74ff0eSAlexander V. Chernikov 	/* Check if descriptor is attached */
7946c74ff0eSAlexander V. Chernikov 	if ((bp = d->bd_bif) == NULL)
7956c74ff0eSAlexander V. Chernikov 		return;
7966c74ff0eSAlexander V. Chernikov 
797e4b3229aSAlexander V. Chernikov 	BPFIF_WLOCK(bp);
798afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
79946448b5aSRobert Watson 
80051ec1eb7SAlexander V. Chernikov 	/* Save bd_writer value */
80151ec1eb7SAlexander V. Chernikov 	error = d->bd_writer;
80251ec1eb7SAlexander V. Chernikov 
80346448b5aSRobert Watson 	/*
80446448b5aSRobert Watson 	 * Remove d from the interface's descriptor list.
80546448b5aSRobert Watson 	 */
80646448b5aSRobert Watson 	LIST_REMOVE(d, bd_next);
80746448b5aSRobert Watson 
808e4b3229aSAlexander V. Chernikov 	ifp = bp->bif_ifp;
809572bde2aSRobert Watson 	d->bd_bif = NULL;
810afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
811e4b3229aSAlexander V. Chernikov 	BPFIF_WUNLOCK(bp);
812e4b3229aSAlexander V. Chernikov 
813e4b3229aSAlexander V. Chernikov 	bpf_bpfd_cnt--;
81446448b5aSRobert Watson 
81551ec1eb7SAlexander V. Chernikov 	/* Call event handler iff d is attached */
81651ec1eb7SAlexander V. Chernikov 	if (error == 0)
8175ce8d970SSam Leffler 		EVENTHANDLER_INVOKE(bpf_track, ifp, bp->bif_dlt, 0);
818b743c310SSam Leffler 
819df8bae1dSRodney W. Grimes 	/*
820df8bae1dSRodney W. Grimes 	 * Check if this descriptor had requested promiscuous mode.
821df8bae1dSRodney W. Grimes 	 * If so, turn it off.
822df8bae1dSRodney W. Grimes 	 */
823df8bae1dSRodney W. Grimes 	if (d->bd_promisc) {
824df8bae1dSRodney W. Grimes 		d->bd_promisc = 0;
82597021c24SMarko Zec 		CURVNET_SET(ifp->if_vnet);
82646448b5aSRobert Watson 		error = ifpromisc(ifp, 0);
82797021c24SMarko Zec 		CURVNET_RESTORE();
8286e891d64SPoul-Henning Kamp 		if (error != 0 && error != ENXIO) {
829df8bae1dSRodney W. Grimes 			/*
8306e891d64SPoul-Henning Kamp 			 * ENXIO can happen if a pccard is unplugged
831df8bae1dSRodney W. Grimes 			 * Something is really wrong if we were able to put
832df8bae1dSRodney W. Grimes 			 * the driver into promiscuous mode, but can't
833df8bae1dSRodney W. Grimes 			 * take it out.
834df8bae1dSRodney W. Grimes 			 */
8358eab61f3SSam Leffler 			if_printf(bp->bif_ifp,
8368eab61f3SSam Leffler 				"bpf_detach: ifpromisc failed (%d)\n", error);
8376e891d64SPoul-Henning Kamp 		}
838df8bae1dSRodney W. Grimes 	}
839df8bae1dSRodney W. Grimes }
840df8bae1dSRodney W. Grimes 
841df8bae1dSRodney W. Grimes /*
842136600feSEd Schouten  * Close the descriptor by detaching it from its interface,
843136600feSEd Schouten  * deallocating its buffers, and marking it free.
844136600feSEd Schouten  */
845136600feSEd Schouten static void
846136600feSEd Schouten bpf_dtor(void *data)
847136600feSEd Schouten {
848136600feSEd Schouten 	struct bpf_d *d = data;
849136600feSEd Schouten 
850afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
851136600feSEd Schouten 	if (d->bd_state == BPF_WAITING)
852136600feSEd Schouten 		callout_stop(&d->bd_callout);
853136600feSEd Schouten 	d->bd_state = BPF_IDLE;
854afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
855136600feSEd Schouten 	funsetown(&d->bd_sigio);
856136600feSEd Schouten 	bpf_detachd(d);
857136600feSEd Schouten #ifdef MAC
858136600feSEd Schouten 	mac_bpfdesc_destroy(d);
859136600feSEd Schouten #endif /* MAC */
8606aba400aSAttilio Rao 	seldrain(&d->bd_sel);
861136600feSEd Schouten 	knlist_destroy(&d->bd_sel.si_note);
8629fee1bd1SJung-uk Kim 	callout_drain(&d->bd_callout);
863136600feSEd Schouten 	bpf_freed(d);
864136600feSEd Schouten 	free(d, M_BPF);
865136600feSEd Schouten }
866136600feSEd Schouten 
867136600feSEd Schouten /*
868df8bae1dSRodney W. Grimes  * Open ethernet device.  Returns ENXIO for illegal minor device number,
869df8bae1dSRodney W. Grimes  * EBUSY if file is open by another process.
870df8bae1dSRodney W. Grimes  */
871df8bae1dSRodney W. Grimes /* ARGSUSED */
87287f6c662SJulian Elischer static	int
87319ba8395SChristian S.J. Peron bpfopen(struct cdev *dev, int flags, int fmt, struct thread *td)
874df8bae1dSRodney W. Grimes {
875e7bb21b3SJonathan Lemon 	struct bpf_d *d;
8764f42daa4SLuiz Otavio O Souza 	int error;
877df8bae1dSRodney W. Grimes 
8781ede983cSDag-Erling Smørgrav 	d = malloc(sizeof(*d), M_BPF, M_WAITOK | M_ZERO);
879136600feSEd Schouten 	error = devfs_set_cdevpriv(d, bpf_dtor);
880136600feSEd Schouten 	if (error != 0) {
881136600feSEd Schouten 		free(d, M_BPF);
882136600feSEd Schouten 		return (error);
883136600feSEd Schouten 	}
8844d621040SChristian S.J. Peron 
8854d621040SChristian S.J. Peron 	/*
8864d621040SChristian S.J. Peron 	 * For historical reasons, perform a one-time initialization call to
8874d621040SChristian S.J. Peron 	 * the buffer routines, even though we're not yet committed to a
8884d621040SChristian S.J. Peron 	 * particular buffer method.
8894d621040SChristian S.J. Peron 	 */
8904d621040SChristian S.J. Peron 	bpf_buffer_init(d);
89171448753SAlexander Motin 	if ((flags & FREAD) == 0)
89271448753SAlexander Motin 		d->bd_writer = 2;
8933b3b91e7SGuy Helmer 	d->bd_hbuf_in_use = 0;
8944d621040SChristian S.J. Peron 	d->bd_bufmode = BPF_BUFMODE_BUFFER;
89500a83887SPaul Traina 	d->bd_sig = SIGIO;
896560a54e1SJung-uk Kim 	d->bd_direction = BPF_D_INOUT;
897e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH(d, td);
89882f4445dSRobert Watson #ifdef MAC
89930d239bcSRobert Watson 	mac_bpfdesc_init(d);
90030d239bcSRobert Watson 	mac_bpfdesc_create(td->td_ucred, d);
90182f4445dSRobert Watson #endif
902afa85850SAlexander V. Chernikov 	mtx_init(&d->bd_lock, devtoname(dev), "bpf cdev lock", MTX_DEF);
903afa85850SAlexander V. Chernikov 	callout_init_mtx(&d->bd_callout, &d->bd_lock, 0);
904afa85850SAlexander V. Chernikov 	knlist_init_mtx(&d->bd_sel.si_note, &d->bd_lock);
905df8bae1dSRodney W. Grimes 
906df8bae1dSRodney W. Grimes 	return (0);
907df8bae1dSRodney W. Grimes }
908df8bae1dSRodney W. Grimes 
909df8bae1dSRodney W. Grimes /*
910df8bae1dSRodney W. Grimes  *  bpfread - read next chunk of packets from buffers
911df8bae1dSRodney W. Grimes  */
91287f6c662SJulian Elischer static	int
91319ba8395SChristian S.J. Peron bpfread(struct cdev *dev, struct uio *uio, int ioflag)
914df8bae1dSRodney W. Grimes {
915136600feSEd Schouten 	struct bpf_d *d;
916df8bae1dSRodney W. Grimes 	int error;
9178df67d77SJung-uk Kim 	int non_block;
9188df67d77SJung-uk Kim 	int timed_out;
919df8bae1dSRodney W. Grimes 
920136600feSEd Schouten 	error = devfs_get_cdevpriv((void **)&d);
921136600feSEd Schouten 	if (error != 0)
922136600feSEd Schouten 		return (error);
923136600feSEd Schouten 
924df8bae1dSRodney W. Grimes 	/*
925df8bae1dSRodney W. Grimes 	 * Restrict application to use a buffer the same size as
926df8bae1dSRodney W. Grimes 	 * as kernel buffers.
927df8bae1dSRodney W. Grimes 	 */
928df8bae1dSRodney W. Grimes 	if (uio->uio_resid != d->bd_bufsize)
929df8bae1dSRodney W. Grimes 		return (EINVAL);
930df8bae1dSRodney W. Grimes 
9318df67d77SJung-uk Kim 	non_block = ((ioflag & O_NONBLOCK) != 0);
9328df67d77SJung-uk Kim 
933afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
934e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH_CUR(d);
9354d621040SChristian S.J. Peron 	if (d->bd_bufmode != BPF_BUFMODE_BUFFER) {
936afa85850SAlexander V. Chernikov 		BPFD_UNLOCK(d);
9374d621040SChristian S.J. Peron 		return (EOPNOTSUPP);
9384d621040SChristian S.J. Peron 	}
93981bda851SJohn Polstra 	if (d->bd_state == BPF_WAITING)
94081bda851SJohn Polstra 		callout_stop(&d->bd_callout);
94181bda851SJohn Polstra 	timed_out = (d->bd_state == BPF_TIMED_OUT);
94281bda851SJohn Polstra 	d->bd_state = BPF_IDLE;
943d013d902SGuy Helmer 	while (d->bd_hbuf_in_use) {
944d013d902SGuy Helmer 		error = mtx_sleep(&d->bd_hbuf_in_use, &d->bd_lock,
9453b3b91e7SGuy Helmer 		    PRINET|PCATCH, "bd_hbuf", 0);
946d013d902SGuy Helmer 		if (error != 0) {
947d013d902SGuy Helmer 			BPFD_UNLOCK(d);
948d013d902SGuy Helmer 			return (error);
949d013d902SGuy Helmer 		}
950d013d902SGuy Helmer 	}
951df8bae1dSRodney W. Grimes 	/*
952df8bae1dSRodney W. Grimes 	 * If the hold buffer is empty, then do a timed sleep, which
953df8bae1dSRodney W. Grimes 	 * ends when the timeout expires or when enough packets
954df8bae1dSRodney W. Grimes 	 * have arrived to fill the store buffer.
955df8bae1dSRodney W. Grimes 	 */
956572bde2aSRobert Watson 	while (d->bd_hbuf == NULL) {
9578df67d77SJung-uk Kim 		if (d->bd_slen != 0) {
958df8bae1dSRodney W. Grimes 			/*
959df8bae1dSRodney W. Grimes 			 * A packet(s) either arrived since the previous
960df8bae1dSRodney W. Grimes 			 * read or arrived while we were asleep.
9618df67d77SJung-uk Kim 			 */
9628df67d77SJung-uk Kim 			if (d->bd_immediate || non_block || timed_out) {
9638df67d77SJung-uk Kim 				/*
9648df67d77SJung-uk Kim 				 * Rotate the buffers and return what's here
9658df67d77SJung-uk Kim 				 * if we are in immediate mode, non-blocking
9668df67d77SJung-uk Kim 				 * flag is set, or this descriptor timed out.
967df8bae1dSRodney W. Grimes 				 */
968df8bae1dSRodney W. Grimes 				ROTATE_BUFFERS(d);
969df8bae1dSRodney W. Grimes 				break;
970df8bae1dSRodney W. Grimes 			}
9718df67d77SJung-uk Kim 		}
972de5d9935SRobert Watson 
973de5d9935SRobert Watson 		/*
974de5d9935SRobert Watson 		 * No data is available, check to see if the bpf device
975de5d9935SRobert Watson 		 * is still pointed at a real interface.  If not, return
976de5d9935SRobert Watson 		 * ENXIO so that the userland process knows to rebind
977de5d9935SRobert Watson 		 * it before using it again.
978de5d9935SRobert Watson 		 */
979de5d9935SRobert Watson 		if (d->bd_bif == NULL) {
980afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
981de5d9935SRobert Watson 			return (ENXIO);
982de5d9935SRobert Watson 		}
983de5d9935SRobert Watson 
9848df67d77SJung-uk Kim 		if (non_block) {
985afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
986fba3cfdeSJohn Polstra 			return (EWOULDBLOCK);
987fba3cfdeSJohn Polstra 		}
988afa85850SAlexander V. Chernikov 		error = msleep(d, &d->bd_lock, PRINET|PCATCH,
989e7bb21b3SJonathan Lemon 		     "bpf", d->bd_rtout);
990df8bae1dSRodney W. Grimes 		if (error == EINTR || error == ERESTART) {
991afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
992df8bae1dSRodney W. Grimes 			return (error);
993df8bae1dSRodney W. Grimes 		}
994df8bae1dSRodney W. Grimes 		if (error == EWOULDBLOCK) {
995df8bae1dSRodney W. Grimes 			/*
996df8bae1dSRodney W. Grimes 			 * On a timeout, return what's in the buffer,
997df8bae1dSRodney W. Grimes 			 * which may be nothing.  If there is something
998df8bae1dSRodney W. Grimes 			 * in the store buffer, we can rotate the buffers.
999df8bae1dSRodney W. Grimes 			 */
1000df8bae1dSRodney W. Grimes 			if (d->bd_hbuf)
1001df8bae1dSRodney W. Grimes 				/*
1002df8bae1dSRodney W. Grimes 				 * We filled up the buffer in between
1003df8bae1dSRodney W. Grimes 				 * getting the timeout and arriving
1004df8bae1dSRodney W. Grimes 				 * here, so we don't need to rotate.
1005df8bae1dSRodney W. Grimes 				 */
1006df8bae1dSRodney W. Grimes 				break;
1007df8bae1dSRodney W. Grimes 
1008df8bae1dSRodney W. Grimes 			if (d->bd_slen == 0) {
1009afa85850SAlexander V. Chernikov 				BPFD_UNLOCK(d);
1010df8bae1dSRodney W. Grimes 				return (0);
1011df8bae1dSRodney W. Grimes 			}
1012df8bae1dSRodney W. Grimes 			ROTATE_BUFFERS(d);
1013df8bae1dSRodney W. Grimes 			break;
1014df8bae1dSRodney W. Grimes 		}
1015df8bae1dSRodney W. Grimes 	}
1016df8bae1dSRodney W. Grimes 	/*
1017df8bae1dSRodney W. Grimes 	 * At this point, we know we have something in the hold slot.
1018df8bae1dSRodney W. Grimes 	 */
10193b3b91e7SGuy Helmer 	d->bd_hbuf_in_use = 1;
1020afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
1021df8bae1dSRodney W. Grimes 
1022df8bae1dSRodney W. Grimes 	/*
1023df8bae1dSRodney W. Grimes 	 * Move data from hold buffer into user space.
1024df8bae1dSRodney W. Grimes 	 * We know the entire buffer is transferred since
1025df8bae1dSRodney W. Grimes 	 * we checked above that the read buffer is bpf_bufsize bytes.
102631b32e6dSRobert Watson   	 *
10273b3b91e7SGuy Helmer 	 * We do not have to worry about simultaneous reads because
10283b3b91e7SGuy Helmer 	 * we waited for sole access to the hold buffer above.
1029df8bae1dSRodney W. Grimes 	 */
10304d621040SChristian S.J. Peron 	error = bpf_uiomove(d, d->bd_hbuf, d->bd_hlen, uio);
1031df8bae1dSRodney W. Grimes 
1032afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
10333b3b91e7SGuy Helmer 	KASSERT(d->bd_hbuf != NULL, ("bpfread: lost bd_hbuf"));
1034df8bae1dSRodney W. Grimes 	d->bd_fbuf = d->bd_hbuf;
1035572bde2aSRobert Watson 	d->bd_hbuf = NULL;
1036df8bae1dSRodney W. Grimes 	d->bd_hlen = 0;
103729f612ecSChristian S.J. Peron 	bpf_buf_reclaimed(d);
10383b3b91e7SGuy Helmer 	d->bd_hbuf_in_use = 0;
10393b3b91e7SGuy Helmer 	wakeup(&d->bd_hbuf_in_use);
1040afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
1041df8bae1dSRodney W. Grimes 
1042df8bae1dSRodney W. Grimes 	return (error);
1043df8bae1dSRodney W. Grimes }
1044df8bae1dSRodney W. Grimes 
1045df8bae1dSRodney W. Grimes /*
1046df8bae1dSRodney W. Grimes  * If there are processes sleeping on this descriptor, wake them up.
1047df8bae1dSRodney W. Grimes  */
1048e7bb21b3SJonathan Lemon static __inline void
104919ba8395SChristian S.J. Peron bpf_wakeup(struct bpf_d *d)
1050df8bae1dSRodney W. Grimes {
1051a3272e3cSChristian S.J. Peron 
1052afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
105381bda851SJohn Polstra 	if (d->bd_state == BPF_WAITING) {
105481bda851SJohn Polstra 		callout_stop(&d->bd_callout);
105581bda851SJohn Polstra 		d->bd_state = BPF_IDLE;
105681bda851SJohn Polstra 	}
1057521f364bSDag-Erling Smørgrav 	wakeup(d);
1058831d27a9SDon Lewis 	if (d->bd_async && d->bd_sig && d->bd_sigio)
1059f1320723SAlfred Perlstein 		pgsigio(&d->bd_sigio, d->bd_sig, 0);
106000a83887SPaul Traina 
1061512824f8SSeigo Tanimura 	selwakeuppri(&d->bd_sel, PRINET);
1062ad3b9257SJohn-Mark Gurney 	KNOTE_LOCKED(&d->bd_sel.si_note, 0);
1063df8bae1dSRodney W. Grimes }
1064df8bae1dSRodney W. Grimes 
106581bda851SJohn Polstra static void
106619ba8395SChristian S.J. Peron bpf_timed_out(void *arg)
106781bda851SJohn Polstra {
106881bda851SJohn Polstra 	struct bpf_d *d = (struct bpf_d *)arg;
106981bda851SJohn Polstra 
1070afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
10719fee1bd1SJung-uk Kim 
10729fee1bd1SJung-uk Kim 	if (callout_pending(&d->bd_callout) || !callout_active(&d->bd_callout))
10739fee1bd1SJung-uk Kim 		return;
107481bda851SJohn Polstra 	if (d->bd_state == BPF_WAITING) {
107581bda851SJohn Polstra 		d->bd_state = BPF_TIMED_OUT;
107681bda851SJohn Polstra 		if (d->bd_slen != 0)
107781bda851SJohn Polstra 			bpf_wakeup(d);
107881bda851SJohn Polstra 	}
107981bda851SJohn Polstra }
108081bda851SJohn Polstra 
108187f6c662SJulian Elischer static int
10824d621040SChristian S.J. Peron bpf_ready(struct bpf_d *d)
10834d621040SChristian S.J. Peron {
10844d621040SChristian S.J. Peron 
1085afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
10864d621040SChristian S.J. Peron 
10874d621040SChristian S.J. Peron 	if (!bpf_canfreebuf(d) && d->bd_hlen != 0)
10884d621040SChristian S.J. Peron 		return (1);
10894d621040SChristian S.J. Peron 	if ((d->bd_immediate || d->bd_state == BPF_TIMED_OUT) &&
10904d621040SChristian S.J. Peron 	    d->bd_slen != 0)
10914d621040SChristian S.J. Peron 		return (1);
10924d621040SChristian S.J. Peron 	return (0);
10934d621040SChristian S.J. Peron }
10944d621040SChristian S.J. Peron 
10954d621040SChristian S.J. Peron static int
109619ba8395SChristian S.J. Peron bpfwrite(struct cdev *dev, struct uio *uio, int ioflag)
1097df8bae1dSRodney W. Grimes {
1098136600feSEd Schouten 	struct bpf_d *d;
1099df8bae1dSRodney W. Grimes 	struct ifnet *ifp;
1100560a54e1SJung-uk Kim 	struct mbuf *m, *mc;
11018240bf1eSRobert Watson 	struct sockaddr dst;
11024fb3a820SAlexander V. Chernikov 	struct route ro;
1103560a54e1SJung-uk Kim 	int error, hlen;
1104df8bae1dSRodney W. Grimes 
1105136600feSEd Schouten 	error = devfs_get_cdevpriv((void **)&d);
1106136600feSEd Schouten 	if (error != 0)
1107136600feSEd Schouten 		return (error);
1108136600feSEd Schouten 
1109e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH_CUR(d);
11104d621040SChristian S.J. Peron 	d->bd_wcount++;
11116c74ff0eSAlexander V. Chernikov 	/* XXX: locking required */
11124d621040SChristian S.J. Peron 	if (d->bd_bif == NULL) {
11134d621040SChristian S.J. Peron 		d->bd_wdcount++;
1114df8bae1dSRodney W. Grimes 		return (ENXIO);
11154d621040SChristian S.J. Peron 	}
1116df8bae1dSRodney W. Grimes 
1117df8bae1dSRodney W. Grimes 	ifp = d->bd_bif->bif_ifp;
1118df8bae1dSRodney W. Grimes 
11194d621040SChristian S.J. Peron 	if ((ifp->if_flags & IFF_UP) == 0) {
11204d621040SChristian S.J. Peron 		d->bd_wdcount++;
11213518d220SSam Leffler 		return (ENETDOWN);
11224d621040SChristian S.J. Peron 	}
11233518d220SSam Leffler 
11244d621040SChristian S.J. Peron 	if (uio->uio_resid == 0) {
11254d621040SChristian S.J. Peron 		d->bd_wdcount++;
1126df8bae1dSRodney W. Grimes 		return (0);
11274d621040SChristian S.J. Peron 	}
1128df8bae1dSRodney W. Grimes 
11298240bf1eSRobert Watson 	bzero(&dst, sizeof(dst));
1130d83e603aSChristian S.J. Peron 	m = NULL;
1131d83e603aSChristian S.J. Peron 	hlen = 0;
11326c74ff0eSAlexander V. Chernikov 	/* XXX: bpf_movein() can sleep */
1133cb44b6dfSAndrew Thompson 	error = bpf_movein(uio, (int)d->bd_bif->bif_dlt, ifp,
11344fb3a820SAlexander V. Chernikov 	    &m, &dst, &hlen, d);
11354d621040SChristian S.J. Peron 	if (error) {
11364d621040SChristian S.J. Peron 		d->bd_wdcount++;
1137df8bae1dSRodney W. Grimes 		return (error);
11384d621040SChristian S.J. Peron 	}
11394d621040SChristian S.J. Peron 	d->bd_wfcount++;
1140114ae644SMike Smith 	if (d->bd_hdrcmplt)
1141114ae644SMike Smith 		dst.sa_family = pseudo_AF_HDRCMPLT;
1142114ae644SMike Smith 
1143560a54e1SJung-uk Kim 	if (d->bd_feedback) {
1144eb1b1807SGleb Smirnoff 		mc = m_dup(m, M_NOWAIT);
1145560a54e1SJung-uk Kim 		if (mc != NULL)
1146560a54e1SJung-uk Kim 			mc->m_pkthdr.rcvif = ifp;
11478cd892f7SJung-uk Kim 		/* Set M_PROMISC for outgoing packets to be discarded. */
11488cd892f7SJung-uk Kim 		if (d->bd_direction == BPF_D_INOUT)
11498cd892f7SJung-uk Kim 			m->m_flags |= M_PROMISC;
1150560a54e1SJung-uk Kim 	} else
1151560a54e1SJung-uk Kim 		mc = NULL;
1152560a54e1SJung-uk Kim 
1153560a54e1SJung-uk Kim 	m->m_pkthdr.len -= hlen;
1154560a54e1SJung-uk Kim 	m->m_len -= hlen;
1155560a54e1SJung-uk Kim 	m->m_data += hlen;	/* XXX */
1156560a54e1SJung-uk Kim 
115721ca7b57SMarko Zec 	CURVNET_SET(ifp->if_vnet);
115882f4445dSRobert Watson #ifdef MAC
1159afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
116030d239bcSRobert Watson 	mac_bpfdesc_create_mbuf(d, m);
1161560a54e1SJung-uk Kim 	if (mc != NULL)
116230d239bcSRobert Watson 		mac_bpfdesc_create_mbuf(d, mc);
1163afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
116482f4445dSRobert Watson #endif
1165560a54e1SJung-uk Kim 
11664fb3a820SAlexander V. Chernikov 	bzero(&ro, sizeof(ro));
11674fb3a820SAlexander V. Chernikov 	if (hlen != 0) {
11684fb3a820SAlexander V. Chernikov 		ro.ro_prepend = (u_char *)&dst.sa_data;
11694fb3a820SAlexander V. Chernikov 		ro.ro_plen = hlen;
11704fb3a820SAlexander V. Chernikov 		ro.ro_flags = RT_HAS_HEADER;
11714fb3a820SAlexander V. Chernikov 	}
11724fb3a820SAlexander V. Chernikov 
11734fb3a820SAlexander V. Chernikov 	error = (*ifp->if_output)(ifp, m, &dst, &ro);
11744d621040SChristian S.J. Peron 	if (error)
11754d621040SChristian S.J. Peron 		d->bd_wdcount++;
1176560a54e1SJung-uk Kim 
1177560a54e1SJung-uk Kim 	if (mc != NULL) {
11780bf686c1SRobert Watson 		if (error == 0)
1179560a54e1SJung-uk Kim 			(*ifp->if_input)(ifp, mc);
11800bf686c1SRobert Watson 		else
1181560a54e1SJung-uk Kim 			m_freem(mc);
1182560a54e1SJung-uk Kim 	}
118321ca7b57SMarko Zec 	CURVNET_RESTORE();
1184560a54e1SJung-uk Kim 
1185df8bae1dSRodney W. Grimes 	return (error);
1186df8bae1dSRodney W. Grimes }
1187df8bae1dSRodney W. Grimes 
1188df8bae1dSRodney W. Grimes /*
1189e82669d9SRobert Watson  * Reset a descriptor by flushing its packet buffer and clearing the receive
1190e82669d9SRobert Watson  * and drop counts.  This is doable for kernel-only buffers, but with
1191e82669d9SRobert Watson  * zero-copy buffers, we can't write to (or rotate) buffers that are
1192e82669d9SRobert Watson  * currently owned by userspace.  It would be nice if we could encapsulate
1193e82669d9SRobert Watson  * this logic in the buffer code rather than here.
1194df8bae1dSRodney W. Grimes  */
1195df8bae1dSRodney W. Grimes static void
119619ba8395SChristian S.J. Peron reset_d(struct bpf_d *d)
1197df8bae1dSRodney W. Grimes {
1198e7bb21b3SJonathan Lemon 
1199afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
1200e82669d9SRobert Watson 
12013b3b91e7SGuy Helmer 	while (d->bd_hbuf_in_use)
12023b3b91e7SGuy Helmer 		mtx_sleep(&d->bd_hbuf_in_use, &d->bd_lock, PRINET,
12033b3b91e7SGuy Helmer 		    "bd_hbuf", 0);
1204e82669d9SRobert Watson 	if ((d->bd_hbuf != NULL) &&
1205e82669d9SRobert Watson 	    (d->bd_bufmode != BPF_BUFMODE_ZBUF || bpf_canfreebuf(d))) {
1206df8bae1dSRodney W. Grimes 		/* Free the hold buffer. */
1207df8bae1dSRodney W. Grimes 		d->bd_fbuf = d->bd_hbuf;
1208572bde2aSRobert Watson 		d->bd_hbuf = NULL;
1209e82669d9SRobert Watson 		d->bd_hlen = 0;
121029f612ecSChristian S.J. Peron 		bpf_buf_reclaimed(d);
1211df8bae1dSRodney W. Grimes 	}
1212e82669d9SRobert Watson 	if (bpf_canwritebuf(d))
1213df8bae1dSRodney W. Grimes 		d->bd_slen = 0;
1214df8bae1dSRodney W. Grimes 	d->bd_rcount = 0;
1215df8bae1dSRodney W. Grimes 	d->bd_dcount = 0;
121669f7644bSChristian S.J. Peron 	d->bd_fcount = 0;
12174d621040SChristian S.J. Peron 	d->bd_wcount = 0;
12184d621040SChristian S.J. Peron 	d->bd_wfcount = 0;
12194d621040SChristian S.J. Peron 	d->bd_wdcount = 0;
12204d621040SChristian S.J. Peron 	d->bd_zcopy = 0;
1221df8bae1dSRodney W. Grimes }
1222df8bae1dSRodney W. Grimes 
1223df8bae1dSRodney W. Grimes /*
1224df8bae1dSRodney W. Grimes  *  FIONREAD		Check for read packet available.
1225df8bae1dSRodney W. Grimes  *  BIOCGBLEN		Get buffer len [for read()].
1226f11c3508SDavid Malone  *  BIOCSETF		Set read filter.
1227f11c3508SDavid Malone  *  BIOCSETFNR		Set read filter without resetting descriptor.
1228f11c3508SDavid Malone  *  BIOCSETWF		Set write filter.
1229df8bae1dSRodney W. Grimes  *  BIOCFLUSH		Flush read packet buffer.
1230df8bae1dSRodney W. Grimes  *  BIOCPROMISC		Put interface into promiscuous mode.
1231df8bae1dSRodney W. Grimes  *  BIOCGDLT		Get link layer type.
1232df8bae1dSRodney W. Grimes  *  BIOCGETIF		Get interface name.
1233df8bae1dSRodney W. Grimes  *  BIOCSETIF		Set interface.
1234df8bae1dSRodney W. Grimes  *  BIOCSRTIMEOUT	Set read timeout.
1235df8bae1dSRodney W. Grimes  *  BIOCGRTIMEOUT	Get read timeout.
1236df8bae1dSRodney W. Grimes  *  BIOCGSTATS		Get packet stats.
1237df8bae1dSRodney W. Grimes  *  BIOCIMMEDIATE	Set immediate mode.
1238df8bae1dSRodney W. Grimes  *  BIOCVERSION		Get filter language version.
1239114ae644SMike Smith  *  BIOCGHDRCMPLT	Get "header already complete" flag
1240114ae644SMike Smith  *  BIOCSHDRCMPLT	Set "header already complete" flag
1241560a54e1SJung-uk Kim  *  BIOCGDIRECTION	Get packet direction flag
1242560a54e1SJung-uk Kim  *  BIOCSDIRECTION	Set packet direction flag
1243547d94bdSJung-uk Kim  *  BIOCGTSTAMP		Get time stamp format and resolution.
1244547d94bdSJung-uk Kim  *  BIOCSTSTAMP		Set time stamp format and resolution.
124593e39f0bSChristian S.J. Peron  *  BIOCLOCK		Set "locked" flag
1246560a54e1SJung-uk Kim  *  BIOCFEEDBACK	Set packet feedback mode.
12474d621040SChristian S.J. Peron  *  BIOCSETZBUF		Set current zero-copy buffer locations.
12484d621040SChristian S.J. Peron  *  BIOCGETZMAX		Get maximum zero-copy buffer size.
12494d621040SChristian S.J. Peron  *  BIOCROTZBUF		Force rotation of zero-copy buffer
12504d621040SChristian S.J. Peron  *  BIOCSETBUFMODE	Set buffer mode.
12514d621040SChristian S.J. Peron  *  BIOCGETBUFMODE	Get current buffer mode.
1252df8bae1dSRodney W. Grimes  */
1253df8bae1dSRodney W. Grimes /* ARGSUSED */
125487f6c662SJulian Elischer static	int
125519ba8395SChristian S.J. Peron bpfioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags,
125619ba8395SChristian S.J. Peron     struct thread *td)
1257df8bae1dSRodney W. Grimes {
1258136600feSEd Schouten 	struct bpf_d *d;
1259136600feSEd Schouten 	int error;
1260136600feSEd Schouten 
1261136600feSEd Schouten 	error = devfs_get_cdevpriv((void **)&d);
1262136600feSEd Schouten 	if (error != 0)
1263136600feSEd Schouten 		return (error);
1264df8bae1dSRodney W. Grimes 
1265b75a24a0SChristian S.J. Peron 	/*
1266b75a24a0SChristian S.J. Peron 	 * Refresh PID associated with this descriptor.
1267b75a24a0SChristian S.J. Peron 	 */
1268afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
1269e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH(d, td);
127081bda851SJohn Polstra 	if (d->bd_state == BPF_WAITING)
127181bda851SJohn Polstra 		callout_stop(&d->bd_callout);
127281bda851SJohn Polstra 	d->bd_state = BPF_IDLE;
1273afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
127481bda851SJohn Polstra 
127593e39f0bSChristian S.J. Peron 	if (d->bd_locked == 1) {
127693e39f0bSChristian S.J. Peron 		switch (cmd) {
127793e39f0bSChristian S.J. Peron 		case BIOCGBLEN:
127893e39f0bSChristian S.J. Peron 		case BIOCFLUSH:
127993e39f0bSChristian S.J. Peron 		case BIOCGDLT:
128093e39f0bSChristian S.J. Peron 		case BIOCGDLTLIST:
1281fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
1282fc0a61a4SKonstantin Belousov 		case BIOCGDLTLIST32:
1283fc0a61a4SKonstantin Belousov #endif
128493e39f0bSChristian S.J. Peron 		case BIOCGETIF:
128593e39f0bSChristian S.J. Peron 		case BIOCGRTIMEOUT:
1286*b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1287fc0a61a4SKonstantin Belousov 		case BIOCGRTIMEOUT32:
1288fc0a61a4SKonstantin Belousov #endif
128993e39f0bSChristian S.J. Peron 		case BIOCGSTATS:
129093e39f0bSChristian S.J. Peron 		case BIOCVERSION:
129193e39f0bSChristian S.J. Peron 		case BIOCGRSIG:
129293e39f0bSChristian S.J. Peron 		case BIOCGHDRCMPLT:
1293547d94bdSJung-uk Kim 		case BIOCSTSTAMP:
1294560a54e1SJung-uk Kim 		case BIOCFEEDBACK:
129593e39f0bSChristian S.J. Peron 		case FIONREAD:
129693e39f0bSChristian S.J. Peron 		case BIOCLOCK:
129793e39f0bSChristian S.J. Peron 		case BIOCSRTIMEOUT:
1298*b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1299fc0a61a4SKonstantin Belousov 		case BIOCSRTIMEOUT32:
1300fc0a61a4SKonstantin Belousov #endif
130193e39f0bSChristian S.J. Peron 		case BIOCIMMEDIATE:
130293e39f0bSChristian S.J. Peron 		case TIOCGPGRP:
13034d621040SChristian S.J. Peron 		case BIOCROTZBUF:
130493e39f0bSChristian S.J. Peron 			break;
130593e39f0bSChristian S.J. Peron 		default:
130693e39f0bSChristian S.J. Peron 			return (EPERM);
130793e39f0bSChristian S.J. Peron 		}
130893e39f0bSChristian S.J. Peron 	}
1309fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
1310fc0a61a4SKonstantin Belousov 	/*
1311fc0a61a4SKonstantin Belousov 	 * If we see a 32-bit compat ioctl, mark the stream as 32-bit so
1312fc0a61a4SKonstantin Belousov 	 * that it will get 32-bit packet headers.
1313fc0a61a4SKonstantin Belousov 	 */
1314fc0a61a4SKonstantin Belousov 	switch (cmd) {
1315fc0a61a4SKonstantin Belousov 	case BIOCSETF32:
1316fc0a61a4SKonstantin Belousov 	case BIOCSETFNR32:
1317fc0a61a4SKonstantin Belousov 	case BIOCSETWF32:
1318fc0a61a4SKonstantin Belousov 	case BIOCGDLTLIST32:
1319fc0a61a4SKonstantin Belousov 	case BIOCGRTIMEOUT32:
1320fc0a61a4SKonstantin Belousov 	case BIOCSRTIMEOUT32:
132197aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1322fc0a61a4SKonstantin Belousov 		d->bd_compat32 = 1;
132397aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1324fc0a61a4SKonstantin Belousov 	}
1325fc0a61a4SKonstantin Belousov #endif
1326fc0a61a4SKonstantin Belousov 
132797021c24SMarko Zec 	CURVNET_SET(TD_TO_VNET(td));
1328df8bae1dSRodney W. Grimes 	switch (cmd) {
1329df8bae1dSRodney W. Grimes 
1330df8bae1dSRodney W. Grimes 	default:
1331df8bae1dSRodney W. Grimes 		error = EINVAL;
1332df8bae1dSRodney W. Grimes 		break;
1333df8bae1dSRodney W. Grimes 
1334df8bae1dSRodney W. Grimes 	/*
1335df8bae1dSRodney W. Grimes 	 * Check for read packet available.
1336df8bae1dSRodney W. Grimes 	 */
1337df8bae1dSRodney W. Grimes 	case FIONREAD:
1338df8bae1dSRodney W. Grimes 		{
1339df8bae1dSRodney W. Grimes 			int n;
1340df8bae1dSRodney W. Grimes 
1341afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
1342df8bae1dSRodney W. Grimes 			n = d->bd_slen;
13433b3b91e7SGuy Helmer 			while (d->bd_hbuf_in_use)
13443b3b91e7SGuy Helmer 				mtx_sleep(&d->bd_hbuf_in_use, &d->bd_lock,
13453b3b91e7SGuy Helmer 				    PRINET, "bd_hbuf", 0);
1346df8bae1dSRodney W. Grimes 			if (d->bd_hbuf)
1347df8bae1dSRodney W. Grimes 				n += d->bd_hlen;
1348afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
1349df8bae1dSRodney W. Grimes 
1350df8bae1dSRodney W. Grimes 			*(int *)addr = n;
1351df8bae1dSRodney W. Grimes 			break;
1352df8bae1dSRodney W. Grimes 		}
1353df8bae1dSRodney W. Grimes 
1354df8bae1dSRodney W. Grimes 	/*
1355df8bae1dSRodney W. Grimes 	 * Get buffer len [for read()].
1356df8bae1dSRodney W. Grimes 	 */
1357df8bae1dSRodney W. Grimes 	case BIOCGBLEN:
135897aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1359df8bae1dSRodney W. Grimes 		*(u_int *)addr = d->bd_bufsize;
136097aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1361df8bae1dSRodney W. Grimes 		break;
1362df8bae1dSRodney W. Grimes 
1363df8bae1dSRodney W. Grimes 	/*
1364df8bae1dSRodney W. Grimes 	 * Set buffer length.
1365df8bae1dSRodney W. Grimes 	 */
1366df8bae1dSRodney W. Grimes 	case BIOCSBLEN:
13674d621040SChristian S.J. Peron 		error = bpf_ioctl_sblen(d, (u_int *)addr);
1368df8bae1dSRodney W. Grimes 		break;
1369df8bae1dSRodney W. Grimes 
1370df8bae1dSRodney W. Grimes 	/*
1371df8bae1dSRodney W. Grimes 	 * Set link layer read filter.
1372df8bae1dSRodney W. Grimes 	 */
1373df8bae1dSRodney W. Grimes 	case BIOCSETF:
1374f11c3508SDavid Malone 	case BIOCSETFNR:
137593e39f0bSChristian S.J. Peron 	case BIOCSETWF:
1376fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
1377fc0a61a4SKonstantin Belousov 	case BIOCSETF32:
1378fc0a61a4SKonstantin Belousov 	case BIOCSETFNR32:
1379fc0a61a4SKonstantin Belousov 	case BIOCSETWF32:
1380fc0a61a4SKonstantin Belousov #endif
138193e39f0bSChristian S.J. Peron 		error = bpf_setf(d, (struct bpf_program *)addr, cmd);
1382df8bae1dSRodney W. Grimes 		break;
1383df8bae1dSRodney W. Grimes 
1384df8bae1dSRodney W. Grimes 	/*
1385df8bae1dSRodney W. Grimes 	 * Flush read packet buffer.
1386df8bae1dSRodney W. Grimes 	 */
1387df8bae1dSRodney W. Grimes 	case BIOCFLUSH:
1388afa85850SAlexander V. Chernikov 		BPFD_LOCK(d);
1389df8bae1dSRodney W. Grimes 		reset_d(d);
1390afa85850SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1391df8bae1dSRodney W. Grimes 		break;
1392df8bae1dSRodney W. Grimes 
1393df8bae1dSRodney W. Grimes 	/*
1394df8bae1dSRodney W. Grimes 	 * Put interface into promiscuous mode.
1395df8bae1dSRodney W. Grimes 	 */
1396df8bae1dSRodney W. Grimes 	case BIOCPROMISC:
1397572bde2aSRobert Watson 		if (d->bd_bif == NULL) {
1398df8bae1dSRodney W. Grimes 			/*
1399df8bae1dSRodney W. Grimes 			 * No interface attached yet.
1400df8bae1dSRodney W. Grimes 			 */
1401df8bae1dSRodney W. Grimes 			error = EINVAL;
1402df8bae1dSRodney W. Grimes 			break;
1403df8bae1dSRodney W. Grimes 		}
1404df8bae1dSRodney W. Grimes 		if (d->bd_promisc == 0) {
1405df8bae1dSRodney W. Grimes 			error = ifpromisc(d->bd_bif->bif_ifp, 1);
1406df8bae1dSRodney W. Grimes 			if (error == 0)
1407df8bae1dSRodney W. Grimes 				d->bd_promisc = 1;
1408df8bae1dSRodney W. Grimes 		}
1409df8bae1dSRodney W. Grimes 		break;
1410df8bae1dSRodney W. Grimes 
1411df8bae1dSRodney W. Grimes 	/*
14128eab61f3SSam Leffler 	 * Get current data link type.
1413df8bae1dSRodney W. Grimes 	 */
1414df8bae1dSRodney W. Grimes 	case BIOCGDLT:
141597aacec6SAlexander V. Chernikov 		BPF_LOCK();
1416572bde2aSRobert Watson 		if (d->bd_bif == NULL)
1417df8bae1dSRodney W. Grimes 			error = EINVAL;
1418df8bae1dSRodney W. Grimes 		else
1419df8bae1dSRodney W. Grimes 			*(u_int *)addr = d->bd_bif->bif_dlt;
142097aacec6SAlexander V. Chernikov 		BPF_UNLOCK();
1421df8bae1dSRodney W. Grimes 		break;
1422df8bae1dSRodney W. Grimes 
1423df8bae1dSRodney W. Grimes 	/*
14248eab61f3SSam Leffler 	 * Get a list of supported data link types.
14258eab61f3SSam Leffler 	 */
1426fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
1427fc0a61a4SKonstantin Belousov 	case BIOCGDLTLIST32:
1428fc0a61a4SKonstantin Belousov 		{
1429fc0a61a4SKonstantin Belousov 			struct bpf_dltlist32 *list32;
1430fc0a61a4SKonstantin Belousov 			struct bpf_dltlist dltlist;
1431fc0a61a4SKonstantin Belousov 
1432fc0a61a4SKonstantin Belousov 			list32 = (struct bpf_dltlist32 *)addr;
1433fc0a61a4SKonstantin Belousov 			dltlist.bfl_len = list32->bfl_len;
1434fc0a61a4SKonstantin Belousov 			dltlist.bfl_list = PTRIN(list32->bfl_list);
143597aacec6SAlexander V. Chernikov 			BPF_LOCK();
1436fc0a61a4SKonstantin Belousov 			if (d->bd_bif == NULL)
1437fc0a61a4SKonstantin Belousov 				error = EINVAL;
1438fc0a61a4SKonstantin Belousov 			else {
1439fc0a61a4SKonstantin Belousov 				error = bpf_getdltlist(d, &dltlist);
1440fc0a61a4SKonstantin Belousov 				if (error == 0)
1441fc0a61a4SKonstantin Belousov 					list32->bfl_len = dltlist.bfl_len;
1442fc0a61a4SKonstantin Belousov 			}
144397aacec6SAlexander V. Chernikov 			BPF_UNLOCK();
1444fc0a61a4SKonstantin Belousov 			break;
1445fc0a61a4SKonstantin Belousov 		}
1446fc0a61a4SKonstantin Belousov #endif
1447fc0a61a4SKonstantin Belousov 
14488eab61f3SSam Leffler 	case BIOCGDLTLIST:
144997aacec6SAlexander V. Chernikov 		BPF_LOCK();
1450572bde2aSRobert Watson 		if (d->bd_bif == NULL)
14518eab61f3SSam Leffler 			error = EINVAL;
14528eab61f3SSam Leffler 		else
14538eab61f3SSam Leffler 			error = bpf_getdltlist(d, (struct bpf_dltlist *)addr);
145497aacec6SAlexander V. Chernikov 		BPF_UNLOCK();
14558eab61f3SSam Leffler 		break;
14568eab61f3SSam Leffler 
14578eab61f3SSam Leffler 	/*
14588eab61f3SSam Leffler 	 * Set data link type.
14598eab61f3SSam Leffler 	 */
14608eab61f3SSam Leffler 	case BIOCSDLT:
14616c74ff0eSAlexander V. Chernikov 		BPF_LOCK();
1462572bde2aSRobert Watson 		if (d->bd_bif == NULL)
14638eab61f3SSam Leffler 			error = EINVAL;
14648eab61f3SSam Leffler 		else
14658eab61f3SSam Leffler 			error = bpf_setdlt(d, *(u_int *)addr);
14666c74ff0eSAlexander V. Chernikov 		BPF_UNLOCK();
14678eab61f3SSam Leffler 		break;
14688eab61f3SSam Leffler 
14698eab61f3SSam Leffler 	/*
14701dd0feaaSArchie Cobbs 	 * Get interface name.
1471df8bae1dSRodney W. Grimes 	 */
1472df8bae1dSRodney W. Grimes 	case BIOCGETIF:
147397aacec6SAlexander V. Chernikov 		BPF_LOCK();
1474572bde2aSRobert Watson 		if (d->bd_bif == NULL)
1475df8bae1dSRodney W. Grimes 			error = EINVAL;
14761dd0feaaSArchie Cobbs 		else {
14771dd0feaaSArchie Cobbs 			struct ifnet *const ifp = d->bd_bif->bif_ifp;
14781dd0feaaSArchie Cobbs 			struct ifreq *const ifr = (struct ifreq *)addr;
14791dd0feaaSArchie Cobbs 
14809bf40edeSBrooks Davis 			strlcpy(ifr->ifr_name, ifp->if_xname,
14819bf40edeSBrooks Davis 			    sizeof(ifr->ifr_name));
14821dd0feaaSArchie Cobbs 		}
148397aacec6SAlexander V. Chernikov 		BPF_UNLOCK();
1484df8bae1dSRodney W. Grimes 		break;
1485df8bae1dSRodney W. Grimes 
1486df8bae1dSRodney W. Grimes 	/*
1487df8bae1dSRodney W. Grimes 	 * Set interface.
1488df8bae1dSRodney W. Grimes 	 */
1489df8bae1dSRodney W. Grimes 	case BIOCSETIF:
14904f42daa4SLuiz Otavio O Souza 		{
14914f42daa4SLuiz Otavio O Souza 			int alloc_buf, size;
14924f42daa4SLuiz Otavio O Souza 
14934f42daa4SLuiz Otavio O Souza 			/*
14944f42daa4SLuiz Otavio O Souza 			 * Behavior here depends on the buffering model.  If
14954f42daa4SLuiz Otavio O Souza 			 * we're using kernel memory buffers, then we can
14964f42daa4SLuiz Otavio O Souza 			 * allocate them here.  If we're using zero-copy,
14974f42daa4SLuiz Otavio O Souza 			 * then the user process must have registered buffers
14984f42daa4SLuiz Otavio O Souza 			 * by the time we get here.
14994f42daa4SLuiz Otavio O Souza 			 */
15004f42daa4SLuiz Otavio O Souza 			alloc_buf = 0;
15014f42daa4SLuiz Otavio O Souza 			BPFD_LOCK(d);
15024f42daa4SLuiz Otavio O Souza 			if (d->bd_bufmode == BPF_BUFMODE_BUFFER &&
15034f42daa4SLuiz Otavio O Souza 			    d->bd_sbuf == NULL)
15044f42daa4SLuiz Otavio O Souza 				alloc_buf = 1;
15054f42daa4SLuiz Otavio O Souza 			BPFD_UNLOCK(d);
15064f42daa4SLuiz Otavio O Souza 			if (alloc_buf) {
15074f42daa4SLuiz Otavio O Souza 				size = d->bd_bufsize;
15084f42daa4SLuiz Otavio O Souza 				error = bpf_buffer_ioctl_sblen(d, &size);
15094f42daa4SLuiz Otavio O Souza 				if (error != 0)
15104f42daa4SLuiz Otavio O Souza 					break;
15114f42daa4SLuiz Otavio O Souza 			}
15126c74ff0eSAlexander V. Chernikov 			BPF_LOCK();
1513df8bae1dSRodney W. Grimes 			error = bpf_setif(d, (struct ifreq *)addr);
15146c74ff0eSAlexander V. Chernikov 			BPF_UNLOCK();
1515df8bae1dSRodney W. Grimes 			break;
15164f42daa4SLuiz Otavio O Souza 		}
1517df8bae1dSRodney W. Grimes 
1518df8bae1dSRodney W. Grimes 	/*
1519df8bae1dSRodney W. Grimes 	 * Set read timeout.
1520df8bae1dSRodney W. Grimes 	 */
1521df8bae1dSRodney W. Grimes 	case BIOCSRTIMEOUT:
1522*b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1523fc0a61a4SKonstantin Belousov 	case BIOCSRTIMEOUT32:
1524fc0a61a4SKonstantin Belousov #endif
1525df8bae1dSRodney W. Grimes 		{
1526df8bae1dSRodney W. Grimes 			struct timeval *tv = (struct timeval *)addr;
15279624d947SJuli Mallett #if defined(COMPAT_FREEBSD32) && !defined(__mips__)
1528fc0a61a4SKonstantin Belousov 			struct timeval32 *tv32;
1529fc0a61a4SKonstantin Belousov 			struct timeval tv64;
1530fc0a61a4SKonstantin Belousov 
1531fc0a61a4SKonstantin Belousov 			if (cmd == BIOCSRTIMEOUT32) {
1532fc0a61a4SKonstantin Belousov 				tv32 = (struct timeval32 *)addr;
1533fc0a61a4SKonstantin Belousov 				tv = &tv64;
1534fc0a61a4SKonstantin Belousov 				tv->tv_sec = tv32->tv_sec;
1535fc0a61a4SKonstantin Belousov 				tv->tv_usec = tv32->tv_usec;
1536fc0a61a4SKonstantin Belousov 			} else
1537fc0a61a4SKonstantin Belousov #endif
1538fc0a61a4SKonstantin Belousov 				tv = (struct timeval *)addr;
1539df8bae1dSRodney W. Grimes 
1540bdc2cdc5SAlexander Langer 			/*
1541bdc2cdc5SAlexander Langer 			 * Subtract 1 tick from tvtohz() since this isn't
1542bdc2cdc5SAlexander Langer 			 * a one-shot timer.
1543bdc2cdc5SAlexander Langer 			 */
1544bdc2cdc5SAlexander Langer 			if ((error = itimerfix(tv)) == 0)
1545bdc2cdc5SAlexander Langer 				d->bd_rtout = tvtohz(tv) - 1;
1546df8bae1dSRodney W. Grimes 			break;
1547df8bae1dSRodney W. Grimes 		}
1548df8bae1dSRodney W. Grimes 
1549df8bae1dSRodney W. Grimes 	/*
1550df8bae1dSRodney W. Grimes 	 * Get read timeout.
1551df8bae1dSRodney W. Grimes 	 */
1552df8bae1dSRodney W. Grimes 	case BIOCGRTIMEOUT:
1553*b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1554fc0a61a4SKonstantin Belousov 	case BIOCGRTIMEOUT32:
1555fc0a61a4SKonstantin Belousov #endif
1556df8bae1dSRodney W. Grimes 		{
1557fc0a61a4SKonstantin Belousov 			struct timeval *tv;
1558*b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1559fc0a61a4SKonstantin Belousov 			struct timeval32 *tv32;
1560fc0a61a4SKonstantin Belousov 			struct timeval tv64;
1561fc0a61a4SKonstantin Belousov 
1562fc0a61a4SKonstantin Belousov 			if (cmd == BIOCGRTIMEOUT32)
1563fc0a61a4SKonstantin Belousov 				tv = &tv64;
1564fc0a61a4SKonstantin Belousov 			else
1565fc0a61a4SKonstantin Belousov #endif
1566fc0a61a4SKonstantin Belousov 				tv = (struct timeval *)addr;
1567df8bae1dSRodney W. Grimes 
1568bdc2cdc5SAlexander Langer 			tv->tv_sec = d->bd_rtout / hz;
1569bdc2cdc5SAlexander Langer 			tv->tv_usec = (d->bd_rtout % hz) * tick;
1570*b4366092SJustin Hibbits #if defined(COMPAT_FREEBSD32) && defined(__amd64__)
1571fc0a61a4SKonstantin Belousov 			if (cmd == BIOCGRTIMEOUT32) {
1572fc0a61a4SKonstantin Belousov 				tv32 = (struct timeval32 *)addr;
1573fc0a61a4SKonstantin Belousov 				tv32->tv_sec = tv->tv_sec;
1574fc0a61a4SKonstantin Belousov 				tv32->tv_usec = tv->tv_usec;
1575fc0a61a4SKonstantin Belousov 			}
1576fc0a61a4SKonstantin Belousov #endif
1577fc0a61a4SKonstantin Belousov 
1578df8bae1dSRodney W. Grimes 			break;
1579df8bae1dSRodney W. Grimes 		}
1580df8bae1dSRodney W. Grimes 
1581df8bae1dSRodney W. Grimes 	/*
1582df8bae1dSRodney W. Grimes 	 * Get packet stats.
1583df8bae1dSRodney W. Grimes 	 */
1584df8bae1dSRodney W. Grimes 	case BIOCGSTATS:
1585df8bae1dSRodney W. Grimes 		{
1586df8bae1dSRodney W. Grimes 			struct bpf_stat *bs = (struct bpf_stat *)addr;
1587df8bae1dSRodney W. Grimes 
15884d621040SChristian S.J. Peron 			/* XXXCSJP overflow */
1589df8bae1dSRodney W. Grimes 			bs->bs_recv = d->bd_rcount;
1590df8bae1dSRodney W. Grimes 			bs->bs_drop = d->bd_dcount;
1591df8bae1dSRodney W. Grimes 			break;
1592df8bae1dSRodney W. Grimes 		}
1593df8bae1dSRodney W. Grimes 
1594df8bae1dSRodney W. Grimes 	/*
1595df8bae1dSRodney W. Grimes 	 * Set immediate mode.
1596df8bae1dSRodney W. Grimes 	 */
1597df8bae1dSRodney W. Grimes 	case BIOCIMMEDIATE:
159897aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1599df8bae1dSRodney W. Grimes 		d->bd_immediate = *(u_int *)addr;
160097aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1601df8bae1dSRodney W. Grimes 		break;
1602df8bae1dSRodney W. Grimes 
1603df8bae1dSRodney W. Grimes 	case BIOCVERSION:
1604df8bae1dSRodney W. Grimes 		{
1605df8bae1dSRodney W. Grimes 			struct bpf_version *bv = (struct bpf_version *)addr;
1606df8bae1dSRodney W. Grimes 
1607df8bae1dSRodney W. Grimes 			bv->bv_major = BPF_MAJOR_VERSION;
1608df8bae1dSRodney W. Grimes 			bv->bv_minor = BPF_MINOR_VERSION;
1609df8bae1dSRodney W. Grimes 			break;
1610df8bae1dSRodney W. Grimes 		}
161100a83887SPaul Traina 
1612114ae644SMike Smith 	/*
1613114ae644SMike Smith 	 * Get "header already complete" flag
1614114ae644SMike Smith 	 */
1615114ae644SMike Smith 	case BIOCGHDRCMPLT:
161697aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1617114ae644SMike Smith 		*(u_int *)addr = d->bd_hdrcmplt;
161897aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1619114ae644SMike Smith 		break;
1620114ae644SMike Smith 
1621114ae644SMike Smith 	/*
1622114ae644SMike Smith 	 * Set "header already complete" flag
1623114ae644SMike Smith 	 */
1624114ae644SMike Smith 	case BIOCSHDRCMPLT:
162597aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1626114ae644SMike Smith 		d->bd_hdrcmplt = *(u_int *)addr ? 1 : 0;
162797aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1628114ae644SMike Smith 		break;
1629114ae644SMike Smith 
16308ed3828cSRobert Watson 	/*
1631560a54e1SJung-uk Kim 	 * Get packet direction flag
16328ed3828cSRobert Watson 	 */
1633560a54e1SJung-uk Kim 	case BIOCGDIRECTION:
163497aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1635560a54e1SJung-uk Kim 		*(u_int *)addr = d->bd_direction;
163697aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
16378ed3828cSRobert Watson 		break;
16388ed3828cSRobert Watson 
16398ed3828cSRobert Watson 	/*
1640560a54e1SJung-uk Kim 	 * Set packet direction flag
16418ed3828cSRobert Watson 	 */
1642560a54e1SJung-uk Kim 	case BIOCSDIRECTION:
1643560a54e1SJung-uk Kim 		{
1644560a54e1SJung-uk Kim 			u_int	direction;
1645560a54e1SJung-uk Kim 
1646560a54e1SJung-uk Kim 			direction = *(u_int *)addr;
1647560a54e1SJung-uk Kim 			switch (direction) {
1648560a54e1SJung-uk Kim 			case BPF_D_IN:
1649560a54e1SJung-uk Kim 			case BPF_D_INOUT:
1650560a54e1SJung-uk Kim 			case BPF_D_OUT:
165197aacec6SAlexander V. Chernikov 				BPFD_LOCK(d);
1652560a54e1SJung-uk Kim 				d->bd_direction = direction;
165397aacec6SAlexander V. Chernikov 				BPFD_UNLOCK(d);
1654560a54e1SJung-uk Kim 				break;
1655560a54e1SJung-uk Kim 			default:
1656560a54e1SJung-uk Kim 				error = EINVAL;
1657560a54e1SJung-uk Kim 			}
1658560a54e1SJung-uk Kim 		}
1659560a54e1SJung-uk Kim 		break;
1660560a54e1SJung-uk Kim 
1661547d94bdSJung-uk Kim 	/*
1662d0d7bcdfSJung-uk Kim 	 * Get packet timestamp format and resolution.
1663547d94bdSJung-uk Kim 	 */
1664547d94bdSJung-uk Kim 	case BIOCGTSTAMP:
166597aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1666547d94bdSJung-uk Kim 		*(u_int *)addr = d->bd_tstamp;
166797aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1668547d94bdSJung-uk Kim 		break;
1669547d94bdSJung-uk Kim 
1670547d94bdSJung-uk Kim 	/*
1671547d94bdSJung-uk Kim 	 * Set packet timestamp format and resolution.
1672547d94bdSJung-uk Kim 	 */
1673547d94bdSJung-uk Kim 	case BIOCSTSTAMP:
1674547d94bdSJung-uk Kim 		{
1675547d94bdSJung-uk Kim 			u_int	func;
1676547d94bdSJung-uk Kim 
1677547d94bdSJung-uk Kim 			func = *(u_int *)addr;
1678547d94bdSJung-uk Kim 			if (BPF_T_VALID(func))
1679547d94bdSJung-uk Kim 				d->bd_tstamp = func;
1680547d94bdSJung-uk Kim 			else
1681547d94bdSJung-uk Kim 				error = EINVAL;
1682547d94bdSJung-uk Kim 		}
1683547d94bdSJung-uk Kim 		break;
1684547d94bdSJung-uk Kim 
1685560a54e1SJung-uk Kim 	case BIOCFEEDBACK:
168697aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1687560a54e1SJung-uk Kim 		d->bd_feedback = *(u_int *)addr;
168897aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1689560a54e1SJung-uk Kim 		break;
1690560a54e1SJung-uk Kim 
1691560a54e1SJung-uk Kim 	case BIOCLOCK:
169297aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
1693560a54e1SJung-uk Kim 		d->bd_locked = 1;
169497aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
16958ed3828cSRobert Watson 		break;
16968ed3828cSRobert Watson 
169700a83887SPaul Traina 	case FIONBIO:		/* Non-blocking I/O */
169800a83887SPaul Traina 		break;
169900a83887SPaul Traina 
170000a83887SPaul Traina 	case FIOASYNC:		/* Send signal on receive packets */
170197aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
170200a83887SPaul Traina 		d->bd_async = *(int *)addr;
170397aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
170400a83887SPaul Traina 		break;
170500a83887SPaul Traina 
1706831d27a9SDon Lewis 	case FIOSETOWN:
170797aacec6SAlexander V. Chernikov 		/*
170897aacec6SAlexander V. Chernikov 		 * XXX: Add some sort of locking here?
170997aacec6SAlexander V. Chernikov 		 * fsetown() can sleep.
171097aacec6SAlexander V. Chernikov 		 */
1711831d27a9SDon Lewis 		error = fsetown(*(int *)addr, &d->bd_sigio);
171200a83887SPaul Traina 		break;
171300a83887SPaul Traina 
1714831d27a9SDon Lewis 	case FIOGETOWN:
171597aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
171691e97a82SDon Lewis 		*(int *)addr = fgetown(&d->bd_sigio);
171797aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
1718831d27a9SDon Lewis 		break;
1719831d27a9SDon Lewis 
1720831d27a9SDon Lewis 	/* This is deprecated, FIOSETOWN should be used instead. */
1721831d27a9SDon Lewis 	case TIOCSPGRP:
1722831d27a9SDon Lewis 		error = fsetown(-(*(int *)addr), &d->bd_sigio);
1723831d27a9SDon Lewis 		break;
1724831d27a9SDon Lewis 
1725831d27a9SDon Lewis 	/* This is deprecated, FIOGETOWN should be used instead. */
172600a83887SPaul Traina 	case TIOCGPGRP:
172791e97a82SDon Lewis 		*(int *)addr = -fgetown(&d->bd_sigio);
172800a83887SPaul Traina 		break;
172900a83887SPaul Traina 
173000a83887SPaul Traina 	case BIOCSRSIG:		/* Set receive signal */
173100a83887SPaul Traina 		{
173200a83887SPaul Traina 			u_int sig;
173300a83887SPaul Traina 
173400a83887SPaul Traina 			sig = *(u_int *)addr;
173500a83887SPaul Traina 
173600a83887SPaul Traina 			if (sig >= NSIG)
173700a83887SPaul Traina 				error = EINVAL;
173897aacec6SAlexander V. Chernikov 			else {
173997aacec6SAlexander V. Chernikov 				BPFD_LOCK(d);
174000a83887SPaul Traina 				d->bd_sig = sig;
174197aacec6SAlexander V. Chernikov 				BPFD_UNLOCK(d);
174297aacec6SAlexander V. Chernikov 			}
174300a83887SPaul Traina 			break;
174400a83887SPaul Traina 		}
174500a83887SPaul Traina 	case BIOCGRSIG:
174697aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
174700a83887SPaul Traina 		*(u_int *)addr = d->bd_sig;
174897aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
174900a83887SPaul Traina 		break;
17504d621040SChristian S.J. Peron 
17514d621040SChristian S.J. Peron 	case BIOCGETBUFMODE:
175297aacec6SAlexander V. Chernikov 		BPFD_LOCK(d);
17534d621040SChristian S.J. Peron 		*(u_int *)addr = d->bd_bufmode;
175497aacec6SAlexander V. Chernikov 		BPFD_UNLOCK(d);
17554d621040SChristian S.J. Peron 		break;
17564d621040SChristian S.J. Peron 
17574d621040SChristian S.J. Peron 	case BIOCSETBUFMODE:
17584d621040SChristian S.J. Peron 		/*
17594d621040SChristian S.J. Peron 		 * Allow the buffering mode to be changed as long as we
17604d621040SChristian S.J. Peron 		 * haven't yet committed to a particular mode.  Our
17614d621040SChristian S.J. Peron 		 * definition of commitment, for now, is whether or not a
17624d621040SChristian S.J. Peron 		 * buffer has been allocated or an interface attached, since
17634d621040SChristian S.J. Peron 		 * that's the point where things get tricky.
17644d621040SChristian S.J. Peron 		 */
17654d621040SChristian S.J. Peron 		switch (*(u_int *)addr) {
17664d621040SChristian S.J. Peron 		case BPF_BUFMODE_BUFFER:
17674d621040SChristian S.J. Peron 			break;
17684d621040SChristian S.J. Peron 
17694d621040SChristian S.J. Peron 		case BPF_BUFMODE_ZBUF:
17704d621040SChristian S.J. Peron 			if (bpf_zerocopy_enable)
17714d621040SChristian S.J. Peron 				break;
17724d621040SChristian S.J. Peron 			/* FALLSTHROUGH */
17734d621040SChristian S.J. Peron 
17744d621040SChristian S.J. Peron 		default:
17751b610a74SBjoern A. Zeeb 			CURVNET_RESTORE();
17764d621040SChristian S.J. Peron 			return (EINVAL);
17774d621040SChristian S.J. Peron 		}
17784d621040SChristian S.J. Peron 
1779afa85850SAlexander V. Chernikov 		BPFD_LOCK(d);
17804d621040SChristian S.J. Peron 		if (d->bd_sbuf != NULL || d->bd_hbuf != NULL ||
17814d621040SChristian S.J. Peron 		    d->bd_fbuf != NULL || d->bd_bif != NULL) {
1782afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
17831b610a74SBjoern A. Zeeb 			CURVNET_RESTORE();
17844d621040SChristian S.J. Peron 			return (EBUSY);
17854d621040SChristian S.J. Peron 		}
17864d621040SChristian S.J. Peron 		d->bd_bufmode = *(u_int *)addr;
1787afa85850SAlexander V. Chernikov 		BPFD_UNLOCK(d);
17884d621040SChristian S.J. Peron 		break;
17894d621040SChristian S.J. Peron 
17904d621040SChristian S.J. Peron 	case BIOCGETZMAX:
17911b610a74SBjoern A. Zeeb 		error = bpf_ioctl_getzmax(td, d, (size_t *)addr);
17921b610a74SBjoern A. Zeeb 		break;
17934d621040SChristian S.J. Peron 
17944d621040SChristian S.J. Peron 	case BIOCSETZBUF:
17951b610a74SBjoern A. Zeeb 		error = bpf_ioctl_setzbuf(td, d, (struct bpf_zbuf *)addr);
17961b610a74SBjoern A. Zeeb 		break;
17974d621040SChristian S.J. Peron 
17984d621040SChristian S.J. Peron 	case BIOCROTZBUF:
17991b610a74SBjoern A. Zeeb 		error = bpf_ioctl_rotzbuf(td, d, (struct bpf_zbuf *)addr);
18001b610a74SBjoern A. Zeeb 		break;
1801df8bae1dSRodney W. Grimes 	}
180297021c24SMarko Zec 	CURVNET_RESTORE();
1803df8bae1dSRodney W. Grimes 	return (error);
1804df8bae1dSRodney W. Grimes }
1805df8bae1dSRodney W. Grimes 
1806df8bae1dSRodney W. Grimes /*
1807df8bae1dSRodney W. Grimes  * Set d's packet filter program to fp.  If this file already has a filter,
1808df8bae1dSRodney W. Grimes  * free it and replace it.  Returns EINVAL for bogus requests.
1809784292f8SAlexander V. Chernikov  *
1810784292f8SAlexander V. Chernikov  * Note we need global lock here to serialize bpf_setf() and bpf_setif() calls
1811784292f8SAlexander V. Chernikov  * since reading d->bd_bif can't be protected by d or interface lock due to
1812784292f8SAlexander V. Chernikov  * lock order.
1813784292f8SAlexander V. Chernikov  *
1814784292f8SAlexander V. Chernikov  * Additionally, we have to acquire interface write lock due to bpf_mtap() uses
1815784292f8SAlexander V. Chernikov  * interface read lock to read all filers.
1816784292f8SAlexander V. Chernikov  *
1817df8bae1dSRodney W. Grimes  */
1818f708ef1bSPoul-Henning Kamp static int
181919ba8395SChristian S.J. Peron bpf_setf(struct bpf_d *d, struct bpf_program *fp, u_long cmd)
1820df8bae1dSRodney W. Grimes {
18219b7d4a7fSJung-uk Kim #ifdef COMPAT_FREEBSD32
18229b7d4a7fSJung-uk Kim 	struct bpf_program fp_swab;
18239b7d4a7fSJung-uk Kim 	struct bpf_program32 *fp32;
18249b7d4a7fSJung-uk Kim #endif
1825df8bae1dSRodney W. Grimes 	struct bpf_insn *fcode, *old;
1826293c06a1SRuslan Ermilov #ifdef BPF_JITTER
1827a86227d1SAlexander V. Chernikov 	bpf_jit_filter *jfunc, *ofunc;
1828ae275efcSJung-uk Kim #endif
18298b04b48aSJung-uk Kim 	size_t size;
18308b04b48aSJung-uk Kim 	u_int flen;
18319431cc16SAlexander V. Chernikov 	int need_upgrade;
1832df8bae1dSRodney W. Grimes 
18339b7d4a7fSJung-uk Kim #ifdef COMPAT_FREEBSD32
18346f731135SJung-uk Kim 	switch (cmd) {
18356f731135SJung-uk Kim 	case BIOCSETF32:
18366f731135SJung-uk Kim 	case BIOCSETWF32:
18376f731135SJung-uk Kim 	case BIOCSETFNR32:
1838fc0a61a4SKonstantin Belousov 		fp32 = (struct bpf_program32 *)fp;
1839fc0a61a4SKonstantin Belousov 		fp_swab.bf_len = fp32->bf_len;
1840fc0a61a4SKonstantin Belousov 		fp_swab.bf_insns = (struct bpf_insn *)(uintptr_t)fp32->bf_insns;
1841fc0a61a4SKonstantin Belousov 		fp = &fp_swab;
18426f731135SJung-uk Kim 		switch (cmd) {
18436f731135SJung-uk Kim 		case BIOCSETF32:
18446f731135SJung-uk Kim 			cmd = BIOCSETF;
18456f731135SJung-uk Kim 			break;
18466f731135SJung-uk Kim 		case BIOCSETWF32:
1847fc0a61a4SKonstantin Belousov 			cmd = BIOCSETWF;
18486f731135SJung-uk Kim 			break;
18496f731135SJung-uk Kim 		}
18506f731135SJung-uk Kim 		break;
1851fc0a61a4SKonstantin Belousov 	}
1852fc0a61a4SKonstantin Belousov #endif
18538b04b48aSJung-uk Kim 
18548b04b48aSJung-uk Kim 	fcode = NULL;
18558b04b48aSJung-uk Kim #ifdef BPF_JITTER
18568b04b48aSJung-uk Kim 	jfunc = ofunc = NULL;
18578b04b48aSJung-uk Kim #endif
18589b7d4a7fSJung-uk Kim 	need_upgrade = 0;
18598b04b48aSJung-uk Kim 
18606c74ff0eSAlexander V. Chernikov 	/*
18616c74ff0eSAlexander V. Chernikov 	 * Check new filter validness before acquiring any locks.
18626c74ff0eSAlexander V. Chernikov 	 * Allocate memory for new filter, if needed.
18636c74ff0eSAlexander V. Chernikov 	 */
18646c74ff0eSAlexander V. Chernikov 	flen = fp->bf_len;
18659b7d4a7fSJung-uk Kim 	if (flen > bpf_maxinsns || (fp->bf_insns == NULL && flen != 0))
18666c74ff0eSAlexander V. Chernikov 		return (EINVAL);
18676c74ff0eSAlexander V. Chernikov 	size = flen * sizeof(*fp->bf_insns);
1868a86227d1SAlexander V. Chernikov 	if (size > 0) {
18699b7d4a7fSJung-uk Kim 		/* We're setting up new filter.  Copy and check actual data. */
18709b7d4a7fSJung-uk Kim 		fcode = malloc(size, M_BPF, M_WAITOK);
18719b7d4a7fSJung-uk Kim 		if (copyin(fp->bf_insns, fcode, size) != 0 ||
18729b7d4a7fSJung-uk Kim 		    !bpf_validate(fcode, flen)) {
1873a86227d1SAlexander V. Chernikov 			free(fcode, M_BPF);
1874a86227d1SAlexander V. Chernikov 			return (EINVAL);
1875a86227d1SAlexander V. Chernikov 		}
1876c7b0200eSAlexander V. Chernikov #ifdef BPF_JITTER
18779b7d4a7fSJung-uk Kim 		/* Filter is copied inside fcode and is perfectly valid. */
1878c7b0200eSAlexander V. Chernikov 		jfunc = bpf_jitter(fcode, flen);
1879c7b0200eSAlexander V. Chernikov #endif
18808b04b48aSJung-uk Kim 	}
1881c7b0200eSAlexander V. Chernikov 
18826c74ff0eSAlexander V. Chernikov 	BPF_LOCK();
18836c74ff0eSAlexander V. Chernikov 
1884e4b3229aSAlexander V. Chernikov 	/*
1885a86227d1SAlexander V. Chernikov 	 * Set up new filter.
18869b7d4a7fSJung-uk Kim 	 * Protect filter change by interface lock.
18876c74ff0eSAlexander V. Chernikov 	 * Additionally, we are protected by global lock here.
1888e4b3229aSAlexander V. Chernikov 	 */
18896c74ff0eSAlexander V. Chernikov 	if (d->bd_bif != NULL)
1890e4b3229aSAlexander V. Chernikov 		BPFIF_WLOCK(d->bd_bif);
1891afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
18928b04b48aSJung-uk Kim 	if (cmd == BIOCSETWF) {
18938b04b48aSJung-uk Kim 		old = d->bd_wfilter;
189493e39f0bSChristian S.J. Peron 		d->bd_wfilter = fcode;
18958b04b48aSJung-uk Kim 	} else {
18968b04b48aSJung-uk Kim 		old = d->bd_rfilter;
189793e39f0bSChristian S.J. Peron 		d->bd_rfilter = fcode;
1898293c06a1SRuslan Ermilov #ifdef BPF_JITTER
18998b04b48aSJung-uk Kim 		ofunc = d->bd_bfilter;
1900c7b0200eSAlexander V. Chernikov 		d->bd_bfilter = jfunc;
1901ae275efcSJung-uk Kim #endif
1902f11c3508SDavid Malone 		if (cmd == BIOCSETF)
1903df8bae1dSRodney W. Grimes 			reset_d(d);
190451ec1eb7SAlexander V. Chernikov 
1905402000ffSAlexander V. Chernikov 		need_upgrade = bpf_check_upgrade(cmd, d, fcode, flen);
19068b04b48aSJung-uk Kim 	}
1907afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
19086c74ff0eSAlexander V. Chernikov 	if (d->bd_bif != NULL)
1909e4b3229aSAlexander V. Chernikov 		BPFIF_WUNLOCK(d->bd_bif);
1910572bde2aSRobert Watson 	if (old != NULL)
19119b7d4a7fSJung-uk Kim 		free(old, M_BPF);
1912293c06a1SRuslan Ermilov #ifdef BPF_JITTER
1913ae275efcSJung-uk Kim 	if (ofunc != NULL)
1914ae275efcSJung-uk Kim 		bpf_destroy_jit_filter(ofunc);
1915ae275efcSJung-uk Kim #endif
1916df8bae1dSRodney W. Grimes 
19179b7d4a7fSJung-uk Kim 	/* Move d to active readers list. */
1918402000ffSAlexander V. Chernikov 	if (need_upgrade != 0)
191951ec1eb7SAlexander V. Chernikov 		bpf_upgraded(d);
192051ec1eb7SAlexander V. Chernikov 
19216c74ff0eSAlexander V. Chernikov 	BPF_UNLOCK();
1922df8bae1dSRodney W. Grimes 	return (0);
1923df8bae1dSRodney W. Grimes }
1924df8bae1dSRodney W. Grimes 
1925df8bae1dSRodney W. Grimes /*
1926df8bae1dSRodney W. Grimes  * Detach a file from its current interface (if attached at all) and attach
1927df8bae1dSRodney W. Grimes  * to the interface indicated by the name stored in ifr.
1928df8bae1dSRodney W. Grimes  * Return an errno or 0.
1929df8bae1dSRodney W. Grimes  */
1930df8bae1dSRodney W. Grimes static int
193119ba8395SChristian S.J. Peron bpf_setif(struct bpf_d *d, struct ifreq *ifr)
1932df8bae1dSRodney W. Grimes {
1933df8bae1dSRodney W. Grimes 	struct bpf_if *bp;
19349b44ff22SGarrett Wollman 	struct ifnet *theywant;
1935df8bae1dSRodney W. Grimes 
19366c74ff0eSAlexander V. Chernikov 	BPF_LOCK_ASSERT();
19376c74ff0eSAlexander V. Chernikov 
19389b44ff22SGarrett Wollman 	theywant = ifunit(ifr->ifr_name);
193916d878ccSChristian S.J. Peron 	if (theywant == NULL || theywant->if_bpf == NULL)
194016d878ccSChristian S.J. Peron 		return (ENXIO);
19419b44ff22SGarrett Wollman 
194216d878ccSChristian S.J. Peron 	bp = theywant->if_bpf;
19434d621040SChristian S.J. Peron 
1944afa85850SAlexander V. Chernikov 	/* Check if interface is not being detached from BPF */
1945afa85850SAlexander V. Chernikov 	BPFIF_RLOCK(bp);
1946b23cbbe6SMark Johnston 	if (bp->bif_flags & BPFIF_FLAG_DYING) {
1947afa85850SAlexander V. Chernikov 		BPFIF_RUNLOCK(bp);
1948afa85850SAlexander V. Chernikov 		return (ENXIO);
1949afa85850SAlexander V. Chernikov 	}
1950afa85850SAlexander V. Chernikov 	BPFIF_RUNLOCK(bp);
1951afa85850SAlexander V. Chernikov 
1952df8bae1dSRodney W. Grimes 	/*
19534f42daa4SLuiz Otavio O Souza 	 * At this point, we expect the buffer is already allocated.  If not,
19544f42daa4SLuiz Otavio O Souza 	 * return an error.
1955df8bae1dSRodney W. Grimes 	 */
19564d621040SChristian S.J. Peron 	switch (d->bd_bufmode) {
19574d621040SChristian S.J. Peron 	case BPF_BUFMODE_BUFFER:
19584d621040SChristian S.J. Peron 	case BPF_BUFMODE_ZBUF:
19594d621040SChristian S.J. Peron 		if (d->bd_sbuf == NULL)
19604d621040SChristian S.J. Peron 			return (EINVAL);
19614d621040SChristian S.J. Peron 		break;
19624d621040SChristian S.J. Peron 
19634d621040SChristian S.J. Peron 	default:
19644d621040SChristian S.J. Peron 		panic("bpf_setif: bufmode %d", d->bd_bufmode);
19654d621040SChristian S.J. Peron 	}
19666c74ff0eSAlexander V. Chernikov 	if (bp != d->bd_bif)
1967df8bae1dSRodney W. Grimes 		bpf_attachd(d, bp);
1968afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
1969df8bae1dSRodney W. Grimes 	reset_d(d);
1970afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
1971df8bae1dSRodney W. Grimes 	return (0);
1972df8bae1dSRodney W. Grimes }
1973df8bae1dSRodney W. Grimes 
1974df8bae1dSRodney W. Grimes /*
1975243ac7d8SPeter Wemm  * Support for select() and poll() system calls
1976df8bae1dSRodney W. Grimes  *
1977df8bae1dSRodney W. Grimes  * Return true iff the specific operation will not block indefinitely.
1978df8bae1dSRodney W. Grimes  * Otherwise, return false but make a note that a selwakeup() must be done.
1979df8bae1dSRodney W. Grimes  */
198037c84183SPoul-Henning Kamp static int
198119ba8395SChristian S.J. Peron bpfpoll(struct cdev *dev, int events, struct thread *td)
1982df8bae1dSRodney W. Grimes {
1983e7bb21b3SJonathan Lemon 	struct bpf_d *d;
19840832fc64SGarance A Drosehn 	int revents;
1985df8bae1dSRodney W. Grimes 
1986136600feSEd Schouten 	if (devfs_get_cdevpriv((void **)&d) != 0 || d->bd_bif == NULL)
1987136600feSEd Schouten 		return (events &
1988136600feSEd Schouten 		    (POLLHUP|POLLIN|POLLRDNORM|POLLOUT|POLLWRNORM));
1989de5d9935SRobert Watson 
1990b75a24a0SChristian S.J. Peron 	/*
1991b75a24a0SChristian S.J. Peron 	 * Refresh PID associated with this descriptor.
1992b75a24a0SChristian S.J. Peron 	 */
19930832fc64SGarance A Drosehn 	revents = events & (POLLOUT | POLLWRNORM);
1994afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
1995e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH(d, td);
199675c13541SPoul-Henning Kamp 	if (events & (POLLIN | POLLRDNORM)) {
199795aab9ccSJohn-Mark Gurney 		if (bpf_ready(d))
1998243ac7d8SPeter Wemm 			revents |= events & (POLLIN | POLLRDNORM);
199981bda851SJohn Polstra 		else {
2000ed01445dSJohn Baldwin 			selrecord(td, &d->bd_sel);
200181bda851SJohn Polstra 			/* Start the read timeout if necessary. */
200281bda851SJohn Polstra 			if (d->bd_rtout > 0 && d->bd_state == BPF_IDLE) {
200381bda851SJohn Polstra 				callout_reset(&d->bd_callout, d->bd_rtout,
200481bda851SJohn Polstra 				    bpf_timed_out, d);
200581bda851SJohn Polstra 				d->bd_state = BPF_WAITING;
200681bda851SJohn Polstra 			}
200781bda851SJohn Polstra 		}
200875c13541SPoul-Henning Kamp 	}
2009afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
2010243ac7d8SPeter Wemm 	return (revents);
2011df8bae1dSRodney W. Grimes }
2012df8bae1dSRodney W. Grimes 
2013df8bae1dSRodney W. Grimes /*
201495aab9ccSJohn-Mark Gurney  * Support for kevent() system call.  Register EVFILT_READ filters and
201595aab9ccSJohn-Mark Gurney  * reject all others.
201695aab9ccSJohn-Mark Gurney  */
201795aab9ccSJohn-Mark Gurney int
201819ba8395SChristian S.J. Peron bpfkqfilter(struct cdev *dev, struct knote *kn)
201995aab9ccSJohn-Mark Gurney {
2020136600feSEd Schouten 	struct bpf_d *d;
202195aab9ccSJohn-Mark Gurney 
2022136600feSEd Schouten 	if (devfs_get_cdevpriv((void **)&d) != 0 ||
2023136600feSEd Schouten 	    kn->kn_filter != EVFILT_READ)
202495aab9ccSJohn-Mark Gurney 		return (1);
202595aab9ccSJohn-Mark Gurney 
2026b75a24a0SChristian S.J. Peron 	/*
2027b75a24a0SChristian S.J. Peron 	 * Refresh PID associated with this descriptor.
2028b75a24a0SChristian S.J. Peron 	 */
2029afa85850SAlexander V. Chernikov 	BPFD_LOCK(d);
2030e4b3229aSAlexander V. Chernikov 	BPF_PID_REFRESH_CUR(d);
203195aab9ccSJohn-Mark Gurney 	kn->kn_fop = &bpfread_filtops;
203295aab9ccSJohn-Mark Gurney 	kn->kn_hook = d;
20334b19419eSChristian S.J. Peron 	knlist_add(&d->bd_sel.si_note, kn, 1);
2034afa85850SAlexander V. Chernikov 	BPFD_UNLOCK(d);
203595aab9ccSJohn-Mark Gurney 
203695aab9ccSJohn-Mark Gurney 	return (0);
203795aab9ccSJohn-Mark Gurney }
203895aab9ccSJohn-Mark Gurney 
203995aab9ccSJohn-Mark Gurney static void
204019ba8395SChristian S.J. Peron filt_bpfdetach(struct knote *kn)
204195aab9ccSJohn-Mark Gurney {
204295aab9ccSJohn-Mark Gurney 	struct bpf_d *d = (struct bpf_d *)kn->kn_hook;
204395aab9ccSJohn-Mark Gurney 
2044ad3b9257SJohn-Mark Gurney 	knlist_remove(&d->bd_sel.si_note, kn, 0);
204595aab9ccSJohn-Mark Gurney }
204695aab9ccSJohn-Mark Gurney 
204795aab9ccSJohn-Mark Gurney static int
204819ba8395SChristian S.J. Peron filt_bpfread(struct knote *kn, long hint)
204995aab9ccSJohn-Mark Gurney {
205095aab9ccSJohn-Mark Gurney 	struct bpf_d *d = (struct bpf_d *)kn->kn_hook;
205195aab9ccSJohn-Mark Gurney 	int ready;
205295aab9ccSJohn-Mark Gurney 
2053afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
205495aab9ccSJohn-Mark Gurney 	ready = bpf_ready(d);
205595aab9ccSJohn-Mark Gurney 	if (ready) {
205695aab9ccSJohn-Mark Gurney 		kn->kn_data = d->bd_slen;
205792242172SLuiz Otavio O Souza 		/*
205892242172SLuiz Otavio O Souza 		 * Ignore the hold buffer if it is being copied to user space.
205992242172SLuiz Otavio O Souza 		 */
206092242172SLuiz Otavio O Souza 		if (!d->bd_hbuf_in_use && d->bd_hbuf)
206195aab9ccSJohn-Mark Gurney 			kn->kn_data += d->bd_hlen;
20625d7af3a1SJung-uk Kim 	} else if (d->bd_rtout > 0 && d->bd_state == BPF_IDLE) {
206395aab9ccSJohn-Mark Gurney 		callout_reset(&d->bd_callout, d->bd_rtout,
206495aab9ccSJohn-Mark Gurney 		    bpf_timed_out, d);
206595aab9ccSJohn-Mark Gurney 		d->bd_state = BPF_WAITING;
206695aab9ccSJohn-Mark Gurney 	}
206795aab9ccSJohn-Mark Gurney 
206895aab9ccSJohn-Mark Gurney 	return (ready);
206995aab9ccSJohn-Mark Gurney }
207095aab9ccSJohn-Mark Gurney 
2071253a3814SLawrence Stewart #define	BPF_TSTAMP_NONE		0
2072253a3814SLawrence Stewart #define	BPF_TSTAMP_FAST		1
2073253a3814SLawrence Stewart #define	BPF_TSTAMP_NORMAL	2
2074253a3814SLawrence Stewart #define	BPF_TSTAMP_EXTERN	3
2075253a3814SLawrence Stewart 
2076253a3814SLawrence Stewart static int
2077253a3814SLawrence Stewart bpf_ts_quality(int tstype)
2078253a3814SLawrence Stewart {
2079253a3814SLawrence Stewart 
2080253a3814SLawrence Stewart 	if (tstype == BPF_T_NONE)
2081253a3814SLawrence Stewart 		return (BPF_TSTAMP_NONE);
2082253a3814SLawrence Stewart 	if ((tstype & BPF_T_FAST) != 0)
2083253a3814SLawrence Stewart 		return (BPF_TSTAMP_FAST);
2084253a3814SLawrence Stewart 
2085253a3814SLawrence Stewart 	return (BPF_TSTAMP_NORMAL);
2086253a3814SLawrence Stewart }
2087253a3814SLawrence Stewart 
2088253a3814SLawrence Stewart static int
2089253a3814SLawrence Stewart bpf_gettime(struct bintime *bt, int tstype, struct mbuf *m)
2090253a3814SLawrence Stewart {
2091253a3814SLawrence Stewart 	struct m_tag *tag;
2092253a3814SLawrence Stewart 	int quality;
2093253a3814SLawrence Stewart 
2094253a3814SLawrence Stewart 	quality = bpf_ts_quality(tstype);
2095253a3814SLawrence Stewart 	if (quality == BPF_TSTAMP_NONE)
2096253a3814SLawrence Stewart 		return (quality);
2097253a3814SLawrence Stewart 
2098253a3814SLawrence Stewart 	if (m != NULL) {
2099253a3814SLawrence Stewart 		tag = m_tag_locate(m, MTAG_BPF, MTAG_BPF_TIMESTAMP, NULL);
2100253a3814SLawrence Stewart 		if (tag != NULL) {
2101253a3814SLawrence Stewart 			*bt = *(struct bintime *)(tag + 1);
2102253a3814SLawrence Stewart 			return (BPF_TSTAMP_EXTERN);
2103253a3814SLawrence Stewart 		}
2104253a3814SLawrence Stewart 	}
2105253a3814SLawrence Stewart 	if (quality == BPF_TSTAMP_NORMAL)
2106253a3814SLawrence Stewart 		binuptime(bt);
2107253a3814SLawrence Stewart 	else
2108253a3814SLawrence Stewart 		getbinuptime(bt);
2109253a3814SLawrence Stewart 
2110253a3814SLawrence Stewart 	return (quality);
2111253a3814SLawrence Stewart }
2112253a3814SLawrence Stewart 
211395aab9ccSJohn-Mark Gurney /*
2114df8bae1dSRodney W. Grimes  * Incoming linkage from device drivers.  Process the packet pkt, of length
2115df8bae1dSRodney W. Grimes  * pktlen, which is stored in a contiguous buffer.  The packet is parsed
2116df8bae1dSRodney W. Grimes  * by each process' filter, and if accepted, stashed into the corresponding
2117df8bae1dSRodney W. Grimes  * buffer.
2118df8bae1dSRodney W. Grimes  */
2119df8bae1dSRodney W. Grimes void
212019ba8395SChristian S.J. Peron bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen)
2121df8bae1dSRodney W. Grimes {
2122547d94bdSJung-uk Kim 	struct bintime bt;
21238994a245SDag-Erling Smørgrav 	struct bpf_d *d;
2124a36599ccSJung-uk Kim #ifdef BPF_JITTER
2125a36599ccSJung-uk Kim 	bpf_jit_filter *bf;
2126a36599ccSJung-uk Kim #endif
2127253a3814SLawrence Stewart 	u_int slen;
2128253a3814SLawrence Stewart 	int gottime;
2129e7bb21b3SJonathan Lemon 
2130253a3814SLawrence Stewart 	gottime = BPF_TSTAMP_NONE;
2131e4b3229aSAlexander V. Chernikov 
2132e4b3229aSAlexander V. Chernikov 	BPFIF_RLOCK(bp);
2133e4b3229aSAlexander V. Chernikov 
21344a3feeaaSRobert Watson 	LIST_FOREACH(d, &bp->bif_dlist, bd_next) {
2135e4b3229aSAlexander V. Chernikov 		/*
2136e4b3229aSAlexander V. Chernikov 		 * We are not using any locks for d here because:
2137e4b3229aSAlexander V. Chernikov 		 * 1) any filter change is protected by interface
2138e4b3229aSAlexander V. Chernikov 		 * write lock
2139e4b3229aSAlexander V. Chernikov 		 * 2) destroying/detaching d is protected by interface
2140e4b3229aSAlexander V. Chernikov 		 * write lock, too
2141e4b3229aSAlexander V. Chernikov 		 */
2142e4b3229aSAlexander V. Chernikov 
2143e4b3229aSAlexander V. Chernikov 		/* XXX: Do not protect counter for the sake of performance. */
2144df8bae1dSRodney W. Grimes 		++d->bd_rcount;
2145a05cf8c6SChristian S.J. Peron 		/*
2146a05cf8c6SChristian S.J. Peron 		 * NB: We dont call BPF_CHECK_DIRECTION() here since there is no
2147a05cf8c6SChristian S.J. Peron 		 * way for the caller to indiciate to us whether this packet
2148a05cf8c6SChristian S.J. Peron 		 * is inbound or outbound.  In the bpf_mtap() routines, we use
2149a05cf8c6SChristian S.J. Peron 		 * the interface pointers on the mbuf to figure it out.
2150a05cf8c6SChristian S.J. Peron 		 */
2151ae275efcSJung-uk Kim #ifdef BPF_JITTER
2152a36599ccSJung-uk Kim 		bf = bpf_jitter_enable != 0 ? d->bd_bfilter : NULL;
2153a36599ccSJung-uk Kim 		if (bf != NULL)
2154a36599ccSJung-uk Kim 			slen = (*(bf->func))(pkt, pktlen, pktlen);
2155ae275efcSJung-uk Kim 		else
2156ae275efcSJung-uk Kim #endif
215793e39f0bSChristian S.J. Peron 		slen = bpf_filter(d->bd_rfilter, pkt, pktlen, pktlen);
2158ec272d87SRobert Watson 		if (slen != 0) {
2159e4b3229aSAlexander V. Chernikov 			/*
2160e4b3229aSAlexander V. Chernikov 			 * Filter matches. Let's to acquire write lock.
2161e4b3229aSAlexander V. Chernikov 			 */
2162afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
2163e4b3229aSAlexander V. Chernikov 
216469f7644bSChristian S.J. Peron 			d->bd_fcount++;
2165253a3814SLawrence Stewart 			if (gottime < bpf_ts_quality(d->bd_tstamp))
2166253a3814SLawrence Stewart 				gottime = bpf_gettime(&bt, d->bd_tstamp, NULL);
2167ec272d87SRobert Watson #ifdef MAC
216830d239bcSRobert Watson 			if (mac_bpfdesc_check_receive(d, bp->bif_ifp) == 0)
2169ec272d87SRobert Watson #endif
21704d621040SChristian S.J. Peron 				catchpacket(d, pkt, pktlen, slen,
2171547d94bdSJung-uk Kim 				    bpf_append_bytes, &bt);
2172afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
2173ec272d87SRobert Watson 		}
2174df8bae1dSRodney W. Grimes 	}
2175e4b3229aSAlexander V. Chernikov 	BPFIF_RUNLOCK(bp);
2176df8bae1dSRodney W. Grimes }
2177df8bae1dSRodney W. Grimes 
2178f81a2a49SJung-uk Kim #define	BPF_CHECK_DIRECTION(d, r, i)				\
2179f81a2a49SJung-uk Kim 	    (((d)->bd_direction == BPF_D_IN && (r) != (i)) ||	\
2180f81a2a49SJung-uk Kim 	    ((d)->bd_direction == BPF_D_OUT && (r) == (i)))
2181560a54e1SJung-uk Kim 
2182df8bae1dSRodney W. Grimes /*
2183df8bae1dSRodney W. Grimes  * Incoming linkage from device drivers, when packet is in an mbuf chain.
2184e4b3229aSAlexander V. Chernikov  * Locking model is explained in bpf_tap().
2185df8bae1dSRodney W. Grimes  */
2186df8bae1dSRodney W. Grimes void
218719ba8395SChristian S.J. Peron bpf_mtap(struct bpf_if *bp, struct mbuf *m)
2188df8bae1dSRodney W. Grimes {
2189547d94bdSJung-uk Kim 	struct bintime bt;
2190df8bae1dSRodney W. Grimes 	struct bpf_d *d;
2191a36599ccSJung-uk Kim #ifdef BPF_JITTER
2192a36599ccSJung-uk Kim 	bpf_jit_filter *bf;
2193a36599ccSJung-uk Kim #endif
2194253a3814SLawrence Stewart 	u_int pktlen, slen;
2195253a3814SLawrence Stewart 	int gottime;
219691433904SDavid Malone 
21978cd892f7SJung-uk Kim 	/* Skip outgoing duplicate packets. */
21988cd892f7SJung-uk Kim 	if ((m->m_flags & M_PROMISC) != 0 && m->m_pkthdr.rcvif == NULL) {
21998cd892f7SJung-uk Kim 		m->m_flags &= ~M_PROMISC;
22008cd892f7SJung-uk Kim 		return;
22018cd892f7SJung-uk Kim 	}
22028cd892f7SJung-uk Kim 
2203f0e2422bSPoul-Henning Kamp 	pktlen = m_length(m, NULL);
2204253a3814SLawrence Stewart 	gottime = BPF_TSTAMP_NONE;
2205e4b3229aSAlexander V. Chernikov 
2206e4b3229aSAlexander V. Chernikov 	BPFIF_RLOCK(bp);
2207e4b3229aSAlexander V. Chernikov 
22084a3feeaaSRobert Watson 	LIST_FOREACH(d, &bp->bif_dlist, bd_next) {
2209f81a2a49SJung-uk Kim 		if (BPF_CHECK_DIRECTION(d, m->m_pkthdr.rcvif, bp->bif_ifp))
22108ed3828cSRobert Watson 			continue;
2211df8bae1dSRodney W. Grimes 		++d->bd_rcount;
2212ae275efcSJung-uk Kim #ifdef BPF_JITTER
2213a36599ccSJung-uk Kim 		bf = bpf_jitter_enable != 0 ? d->bd_bfilter : NULL;
2214ae275efcSJung-uk Kim 		/* XXX We cannot handle multiple mbufs. */
2215a36599ccSJung-uk Kim 		if (bf != NULL && m->m_next == NULL)
2216a36599ccSJung-uk Kim 			slen = (*(bf->func))(mtod(m, u_char *), pktlen, pktlen);
2217ae275efcSJung-uk Kim 		else
2218ae275efcSJung-uk Kim #endif
221993e39f0bSChristian S.J. Peron 		slen = bpf_filter(d->bd_rfilter, (u_char *)m, pktlen, 0);
22204ddfb531SChristian S.J. Peron 		if (slen != 0) {
2221afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
2222e4b3229aSAlexander V. Chernikov 
222369f7644bSChristian S.J. Peron 			d->bd_fcount++;
2224253a3814SLawrence Stewart 			if (gottime < bpf_ts_quality(d->bd_tstamp))
2225253a3814SLawrence Stewart 				gottime = bpf_gettime(&bt, d->bd_tstamp, m);
22260c7fb534SRobert Watson #ifdef MAC
222730d239bcSRobert Watson 			if (mac_bpfdesc_check_receive(d, bp->bif_ifp) == 0)
22280c7fb534SRobert Watson #endif
22290c7fb534SRobert Watson 				catchpacket(d, (u_char *)m, pktlen, slen,
2230547d94bdSJung-uk Kim 				    bpf_append_mbuf, &bt);
2231afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
22324ddfb531SChristian S.J. Peron 		}
2233df8bae1dSRodney W. Grimes 	}
2234e4b3229aSAlexander V. Chernikov 	BPFIF_RUNLOCK(bp);
2235df8bae1dSRodney W. Grimes }
2236df8bae1dSRodney W. Grimes 
2237df8bae1dSRodney W. Grimes /*
2238437ffe18SSam Leffler  * Incoming linkage from device drivers, when packet is in
2239437ffe18SSam Leffler  * an mbuf chain and to be prepended by a contiguous header.
2240437ffe18SSam Leffler  */
2241437ffe18SSam Leffler void
224219ba8395SChristian S.J. Peron bpf_mtap2(struct bpf_if *bp, void *data, u_int dlen, struct mbuf *m)
2243437ffe18SSam Leffler {
2244547d94bdSJung-uk Kim 	struct bintime bt;
2245437ffe18SSam Leffler 	struct mbuf mb;
2246437ffe18SSam Leffler 	struct bpf_d *d;
2247253a3814SLawrence Stewart 	u_int pktlen, slen;
2248253a3814SLawrence Stewart 	int gottime;
224991433904SDavid Malone 
22508cd892f7SJung-uk Kim 	/* Skip outgoing duplicate packets. */
22518cd892f7SJung-uk Kim 	if ((m->m_flags & M_PROMISC) != 0 && m->m_pkthdr.rcvif == NULL) {
22528cd892f7SJung-uk Kim 		m->m_flags &= ~M_PROMISC;
22538cd892f7SJung-uk Kim 		return;
22548cd892f7SJung-uk Kim 	}
22558cd892f7SJung-uk Kim 
2256437ffe18SSam Leffler 	pktlen = m_length(m, NULL);
2257437ffe18SSam Leffler 	/*
2258437ffe18SSam Leffler 	 * Craft on-stack mbuf suitable for passing to bpf_filter.
2259437ffe18SSam Leffler 	 * Note that we cut corners here; we only setup what's
2260437ffe18SSam Leffler 	 * absolutely needed--this mbuf should never go anywhere else.
2261437ffe18SSam Leffler 	 */
2262437ffe18SSam Leffler 	mb.m_next = m;
2263437ffe18SSam Leffler 	mb.m_data = data;
2264437ffe18SSam Leffler 	mb.m_len = dlen;
2265437ffe18SSam Leffler 	pktlen += dlen;
2266437ffe18SSam Leffler 
2267253a3814SLawrence Stewart 	gottime = BPF_TSTAMP_NONE;
2268e4b3229aSAlexander V. Chernikov 
2269e4b3229aSAlexander V. Chernikov 	BPFIF_RLOCK(bp);
2270e4b3229aSAlexander V. Chernikov 
22714a3feeaaSRobert Watson 	LIST_FOREACH(d, &bp->bif_dlist, bd_next) {
2272f81a2a49SJung-uk Kim 		if (BPF_CHECK_DIRECTION(d, m->m_pkthdr.rcvif, bp->bif_ifp))
2273437ffe18SSam Leffler 			continue;
2274437ffe18SSam Leffler 		++d->bd_rcount;
227593e39f0bSChristian S.J. Peron 		slen = bpf_filter(d->bd_rfilter, (u_char *)&mb, pktlen, 0);
22764ddfb531SChristian S.J. Peron 		if (slen != 0) {
2277afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
2278e4b3229aSAlexander V. Chernikov 
227969f7644bSChristian S.J. Peron 			d->bd_fcount++;
2280253a3814SLawrence Stewart 			if (gottime < bpf_ts_quality(d->bd_tstamp))
2281253a3814SLawrence Stewart 				gottime = bpf_gettime(&bt, d->bd_tstamp, m);
2282437ffe18SSam Leffler #ifdef MAC
228330d239bcSRobert Watson 			if (mac_bpfdesc_check_receive(d, bp->bif_ifp) == 0)
2284437ffe18SSam Leffler #endif
2285437ffe18SSam Leffler 				catchpacket(d, (u_char *)&mb, pktlen, slen,
2286547d94bdSJung-uk Kim 				    bpf_append_mbuf, &bt);
2287afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
22884ddfb531SChristian S.J. Peron 		}
2289437ffe18SSam Leffler 	}
2290e4b3229aSAlexander V. Chernikov 	BPFIF_RUNLOCK(bp);
2291437ffe18SSam Leffler }
2292437ffe18SSam Leffler 
2293560a54e1SJung-uk Kim #undef	BPF_CHECK_DIRECTION
2294560a54e1SJung-uk Kim 
2295253a3814SLawrence Stewart #undef	BPF_TSTAMP_NONE
2296253a3814SLawrence Stewart #undef	BPF_TSTAMP_FAST
2297253a3814SLawrence Stewart #undef	BPF_TSTAMP_NORMAL
2298253a3814SLawrence Stewart #undef	BPF_TSTAMP_EXTERN
2299253a3814SLawrence Stewart 
2300547d94bdSJung-uk Kim static int
2301547d94bdSJung-uk Kim bpf_hdrlen(struct bpf_d *d)
2302547d94bdSJung-uk Kim {
2303547d94bdSJung-uk Kim 	int hdrlen;
2304547d94bdSJung-uk Kim 
2305547d94bdSJung-uk Kim 	hdrlen = d->bd_bif->bif_hdrlen;
2306547d94bdSJung-uk Kim #ifndef BURN_BRIDGES
2307547d94bdSJung-uk Kim 	if (d->bd_tstamp == BPF_T_NONE ||
2308547d94bdSJung-uk Kim 	    BPF_T_FORMAT(d->bd_tstamp) == BPF_T_MICROTIME)
2309547d94bdSJung-uk Kim #ifdef COMPAT_FREEBSD32
2310547d94bdSJung-uk Kim 		if (d->bd_compat32)
2311547d94bdSJung-uk Kim 			hdrlen += SIZEOF_BPF_HDR(struct bpf_hdr32);
2312547d94bdSJung-uk Kim 		else
2313547d94bdSJung-uk Kim #endif
2314547d94bdSJung-uk Kim 			hdrlen += SIZEOF_BPF_HDR(struct bpf_hdr);
2315547d94bdSJung-uk Kim 	else
2316547d94bdSJung-uk Kim #endif
2317547d94bdSJung-uk Kim 		hdrlen += SIZEOF_BPF_HDR(struct bpf_xhdr);
2318547d94bdSJung-uk Kim #ifdef COMPAT_FREEBSD32
2319547d94bdSJung-uk Kim 	if (d->bd_compat32)
2320547d94bdSJung-uk Kim 		hdrlen = BPF_WORDALIGN32(hdrlen);
2321547d94bdSJung-uk Kim 	else
2322547d94bdSJung-uk Kim #endif
2323547d94bdSJung-uk Kim 		hdrlen = BPF_WORDALIGN(hdrlen);
2324547d94bdSJung-uk Kim 
2325547d94bdSJung-uk Kim 	return (hdrlen - d->bd_bif->bif_hdrlen);
2326547d94bdSJung-uk Kim }
2327547d94bdSJung-uk Kim 
2328547d94bdSJung-uk Kim static void
2329547d94bdSJung-uk Kim bpf_bintime2ts(struct bintime *bt, struct bpf_ts *ts, int tstype)
2330547d94bdSJung-uk Kim {
2331584b675eSKonstantin Belousov 	struct bintime bt2, boottimebin;
2332547d94bdSJung-uk Kim 	struct timeval tsm;
2333547d94bdSJung-uk Kim 	struct timespec tsn;
2334547d94bdSJung-uk Kim 
2335253a3814SLawrence Stewart 	if ((tstype & BPF_T_MONOTONIC) == 0) {
2336253a3814SLawrence Stewart 		bt2 = *bt;
2337584b675eSKonstantin Belousov 		getboottimebin(&boottimebin);
2338253a3814SLawrence Stewart 		bintime_add(&bt2, &boottimebin);
2339253a3814SLawrence Stewart 		bt = &bt2;
2340253a3814SLawrence Stewart 	}
2341547d94bdSJung-uk Kim 	switch (BPF_T_FORMAT(tstype)) {
2342547d94bdSJung-uk Kim 	case BPF_T_MICROTIME:
2343547d94bdSJung-uk Kim 		bintime2timeval(bt, &tsm);
2344547d94bdSJung-uk Kim 		ts->bt_sec = tsm.tv_sec;
2345547d94bdSJung-uk Kim 		ts->bt_frac = tsm.tv_usec;
2346547d94bdSJung-uk Kim 		break;
2347547d94bdSJung-uk Kim 	case BPF_T_NANOTIME:
2348547d94bdSJung-uk Kim 		bintime2timespec(bt, &tsn);
2349547d94bdSJung-uk Kim 		ts->bt_sec = tsn.tv_sec;
2350547d94bdSJung-uk Kim 		ts->bt_frac = tsn.tv_nsec;
2351547d94bdSJung-uk Kim 		break;
2352547d94bdSJung-uk Kim 	case BPF_T_BINTIME:
2353547d94bdSJung-uk Kim 		ts->bt_sec = bt->sec;
2354547d94bdSJung-uk Kim 		ts->bt_frac = bt->frac;
2355547d94bdSJung-uk Kim 		break;
2356547d94bdSJung-uk Kim 	}
2357547d94bdSJung-uk Kim }
2358547d94bdSJung-uk Kim 
2359437ffe18SSam Leffler /*
2360df8bae1dSRodney W. Grimes  * Move the packet data from interface memory (pkt) into the
23619e610888SDag-Erling Smørgrav  * store buffer.  "cpfn" is the routine called to do the actual data
2362df8bae1dSRodney W. Grimes  * transfer.  bcopy is passed in to copy contiguous chunks, while
23634d621040SChristian S.J. Peron  * bpf_append_mbuf is passed in to copy mbuf chains.  In the latter case,
2364df8bae1dSRodney W. Grimes  * pkt is really an mbuf.
2365df8bae1dSRodney W. Grimes  */
2366df8bae1dSRodney W. Grimes static void
236719ba8395SChristian S.J. Peron catchpacket(struct bpf_d *d, u_char *pkt, u_int pktlen, u_int snaplen,
23684d621040SChristian S.J. Peron     void (*cpfn)(struct bpf_d *, caddr_t, u_int, void *, u_int),
2369547d94bdSJung-uk Kim     struct bintime *bt)
2370df8bae1dSRodney W. Grimes {
2371547d94bdSJung-uk Kim 	struct bpf_xhdr hdr;
2372547d94bdSJung-uk Kim #ifndef BURN_BRIDGES
2373547d94bdSJung-uk Kim 	struct bpf_hdr hdr_old;
2374fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
2375547d94bdSJung-uk Kim 	struct bpf_hdr32 hdr32_old;
2376fc0a61a4SKonstantin Belousov #endif
2377547d94bdSJung-uk Kim #endif
2378547d94bdSJung-uk Kim 	int caplen, curlen, hdrlen, totlen;
23797819da79SJohn-Mark Gurney 	int do_wakeup = 0;
2380547d94bdSJung-uk Kim 	int do_timestamp;
2381547d94bdSJung-uk Kim 	int tstype;
23829e610888SDag-Erling Smørgrav 
2383afa85850SAlexander V. Chernikov 	BPFD_LOCK_ASSERT(d);
23844d621040SChristian S.J. Peron 
23854d621040SChristian S.J. Peron 	/*
23864d621040SChristian S.J. Peron 	 * Detect whether user space has released a buffer back to us, and if
23874d621040SChristian S.J. Peron 	 * so, move it from being a hold buffer to a free buffer.  This may
23884d621040SChristian S.J. Peron 	 * not be the best place to do it (for example, we might only want to
23894d621040SChristian S.J. Peron 	 * run this check if we need the space), but for now it's a reliable
23904d621040SChristian S.J. Peron 	 * spot to do it.
23914d621040SChristian S.J. Peron 	 */
2392fa0c2b34SRobert Watson 	if (d->bd_fbuf == NULL && bpf_canfreebuf(d)) {
23934d621040SChristian S.J. Peron 		d->bd_fbuf = d->bd_hbuf;
23944d621040SChristian S.J. Peron 		d->bd_hbuf = NULL;
23954d621040SChristian S.J. Peron 		d->bd_hlen = 0;
239629f612ecSChristian S.J. Peron 		bpf_buf_reclaimed(d);
23974d621040SChristian S.J. Peron 	}
23984d621040SChristian S.J. Peron 
2399df8bae1dSRodney W. Grimes 	/*
2400df8bae1dSRodney W. Grimes 	 * Figure out how many bytes to move.  If the packet is
2401df8bae1dSRodney W. Grimes 	 * greater or equal to the snapshot length, transfer that
2402df8bae1dSRodney W. Grimes 	 * much.  Otherwise, transfer the whole packet (unless
2403df8bae1dSRodney W. Grimes 	 * we hit the buffer size limit).
2404df8bae1dSRodney W. Grimes 	 */
2405547d94bdSJung-uk Kim 	hdrlen = bpf_hdrlen(d);
2406df8bae1dSRodney W. Grimes 	totlen = hdrlen + min(snaplen, pktlen);
2407df8bae1dSRodney W. Grimes 	if (totlen > d->bd_bufsize)
2408df8bae1dSRodney W. Grimes 		totlen = d->bd_bufsize;
2409df8bae1dSRodney W. Grimes 
2410df8bae1dSRodney W. Grimes 	/*
2411df8bae1dSRodney W. Grimes 	 * Round up the end of the previous packet to the next longword.
2412a7a91e65SRobert Watson 	 *
2413a7a91e65SRobert Watson 	 * Drop the packet if there's no room and no hope of room
2414a7a91e65SRobert Watson 	 * If the packet would overflow the storage buffer or the storage
2415a7a91e65SRobert Watson 	 * buffer is considered immutable by the buffer model, try to rotate
2416a7a91e65SRobert Watson 	 * the buffer and wakeup pending processes.
2417df8bae1dSRodney W. Grimes 	 */
2418fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
2419fc0a61a4SKonstantin Belousov 	if (d->bd_compat32)
2420fc0a61a4SKonstantin Belousov 		curlen = BPF_WORDALIGN32(d->bd_slen);
2421fc0a61a4SKonstantin Belousov 	else
2422fc0a61a4SKonstantin Belousov #endif
2423df8bae1dSRodney W. Grimes 		curlen = BPF_WORDALIGN(d->bd_slen);
2424a7a91e65SRobert Watson 	if (curlen + totlen > d->bd_bufsize || !bpf_canwritebuf(d)) {
2425572bde2aSRobert Watson 		if (d->bd_fbuf == NULL) {
2426df8bae1dSRodney W. Grimes 			/*
2427a7a91e65SRobert Watson 			 * There's no room in the store buffer, and no
2428a7a91e65SRobert Watson 			 * prospect of room, so drop the packet.  Notify the
2429a7a91e65SRobert Watson 			 * buffer model.
2430df8bae1dSRodney W. Grimes 			 */
2431a7a91e65SRobert Watson 			bpf_buffull(d);
2432df8bae1dSRodney W. Grimes 			++d->bd_dcount;
2433df8bae1dSRodney W. Grimes 			return;
2434df8bae1dSRodney W. Grimes 		}
243598fa5d85SLuiz Otavio O Souza 		KASSERT(!d->bd_hbuf_in_use, ("hold buffer is in use"));
2436df8bae1dSRodney W. Grimes 		ROTATE_BUFFERS(d);
24377819da79SJohn-Mark Gurney 		do_wakeup = 1;
2438df8bae1dSRodney W. Grimes 		curlen = 0;
2439a7a91e65SRobert Watson 	} else if (d->bd_immediate || d->bd_state == BPF_TIMED_OUT)
2440df8bae1dSRodney W. Grimes 		/*
24414d621040SChristian S.J. Peron 		 * Immediate mode is set, or the read timeout has already
24424d621040SChristian S.J. Peron 		 * expired during a select call.  A packet arrived, so the
24434d621040SChristian S.J. Peron 		 * reader should be woken up.
2444df8bae1dSRodney W. Grimes 		 */
24457819da79SJohn-Mark Gurney 		do_wakeup = 1;
2446547d94bdSJung-uk Kim 	caplen = totlen - hdrlen;
2447547d94bdSJung-uk Kim 	tstype = d->bd_tstamp;
2448547d94bdSJung-uk Kim 	do_timestamp = tstype != BPF_T_NONE;
2449547d94bdSJung-uk Kim #ifndef BURN_BRIDGES
2450547d94bdSJung-uk Kim 	if (tstype == BPF_T_NONE || BPF_T_FORMAT(tstype) == BPF_T_MICROTIME) {
2451547d94bdSJung-uk Kim 		struct bpf_ts ts;
2452547d94bdSJung-uk Kim 		if (do_timestamp)
2453547d94bdSJung-uk Kim 			bpf_bintime2ts(bt, &ts, tstype);
2454fc0a61a4SKonstantin Belousov #ifdef COMPAT_FREEBSD32
2455fc0a61a4SKonstantin Belousov 		if (d->bd_compat32) {
2456547d94bdSJung-uk Kim 			bzero(&hdr32_old, sizeof(hdr32_old));
2457547d94bdSJung-uk Kim 			if (do_timestamp) {
2458547d94bdSJung-uk Kim 				hdr32_old.bh_tstamp.tv_sec = ts.bt_sec;
2459547d94bdSJung-uk Kim 				hdr32_old.bh_tstamp.tv_usec = ts.bt_frac;
2460547d94bdSJung-uk Kim 			}
2461547d94bdSJung-uk Kim 			hdr32_old.bh_datalen = pktlen;
2462547d94bdSJung-uk Kim 			hdr32_old.bh_hdrlen = hdrlen;
2463547d94bdSJung-uk Kim 			hdr32_old.bh_caplen = caplen;
2464547d94bdSJung-uk Kim 			bpf_append_bytes(d, d->bd_sbuf, curlen, &hdr32_old,
2465547d94bdSJung-uk Kim 			    sizeof(hdr32_old));
2466547d94bdSJung-uk Kim 			goto copy;
2467547d94bdSJung-uk Kim 		}
2468547d94bdSJung-uk Kim #endif
2469547d94bdSJung-uk Kim 		bzero(&hdr_old, sizeof(hdr_old));
2470547d94bdSJung-uk Kim 		if (do_timestamp) {
2471547d94bdSJung-uk Kim 			hdr_old.bh_tstamp.tv_sec = ts.bt_sec;
2472547d94bdSJung-uk Kim 			hdr_old.bh_tstamp.tv_usec = ts.bt_frac;
2473547d94bdSJung-uk Kim 		}
2474547d94bdSJung-uk Kim 		hdr_old.bh_datalen = pktlen;
2475547d94bdSJung-uk Kim 		hdr_old.bh_hdrlen = hdrlen;
2476547d94bdSJung-uk Kim 		hdr_old.bh_caplen = caplen;
2477547d94bdSJung-uk Kim 		bpf_append_bytes(d, d->bd_sbuf, curlen, &hdr_old,
2478547d94bdSJung-uk Kim 		    sizeof(hdr_old));
2479fc0a61a4SKonstantin Belousov 		goto copy;
2480fc0a61a4SKonstantin Belousov 	}
2481fc0a61a4SKonstantin Belousov #endif
2482df8bae1dSRodney W. Grimes 
2483df8bae1dSRodney W. Grimes 	/*
24844d621040SChristian S.J. Peron 	 * Append the bpf header.  Note we append the actual header size, but
24854d621040SChristian S.J. Peron 	 * move forward the length of the header plus padding.
2486df8bae1dSRodney W. Grimes 	 */
24874d621040SChristian S.J. Peron 	bzero(&hdr, sizeof(hdr));
2488547d94bdSJung-uk Kim 	if (do_timestamp)
2489547d94bdSJung-uk Kim 		bpf_bintime2ts(bt, &hdr.bh_tstamp, tstype);
24904d621040SChristian S.J. Peron 	hdr.bh_datalen = pktlen;
24914d621040SChristian S.J. Peron 	hdr.bh_hdrlen = hdrlen;
2492547d94bdSJung-uk Kim 	hdr.bh_caplen = caplen;
24934d621040SChristian S.J. Peron 	bpf_append_bytes(d, d->bd_sbuf, curlen, &hdr, sizeof(hdr));
24944d621040SChristian S.J. Peron 
2495df8bae1dSRodney W. Grimes 	/*
2496df8bae1dSRodney W. Grimes 	 * Copy the packet data into the store buffer and update its length.
2497df8bae1dSRodney W. Grimes 	 */
2498547d94bdSJung-uk Kim #ifndef BURN_BRIDGES
2499fc0a61a4SKonstantin Belousov copy:
2500fc0a61a4SKonstantin Belousov #endif
2501547d94bdSJung-uk Kim 	(*cpfn)(d, d->bd_sbuf, curlen + hdrlen, pkt, caplen);
2502df8bae1dSRodney W. Grimes 	d->bd_slen = curlen + totlen;
25037819da79SJohn-Mark Gurney 
25047819da79SJohn-Mark Gurney 	if (do_wakeup)
25057819da79SJohn-Mark Gurney 		bpf_wakeup(d);
2506df8bae1dSRodney W. Grimes }
2507df8bae1dSRodney W. Grimes 
2508df8bae1dSRodney W. Grimes /*
2509df8bae1dSRodney W. Grimes  * Free buffers currently in use by a descriptor.
2510df8bae1dSRodney W. Grimes  * Called on close.
2511df8bae1dSRodney W. Grimes  */
2512df8bae1dSRodney W. Grimes static void
251319ba8395SChristian S.J. Peron bpf_freed(struct bpf_d *d)
2514df8bae1dSRodney W. Grimes {
25154d621040SChristian S.J. Peron 
2516df8bae1dSRodney W. Grimes 	/*
2517df8bae1dSRodney W. Grimes 	 * We don't need to lock out interrupts since this descriptor has
2518df8bae1dSRodney W. Grimes 	 * been detached from its interface and it yet hasn't been marked
2519df8bae1dSRodney W. Grimes 	 * free.
2520df8bae1dSRodney W. Grimes 	 */
25214d621040SChristian S.J. Peron 	bpf_free(d);
252270485847SJung-uk Kim 	if (d->bd_rfilter != NULL) {
252393e39f0bSChristian S.J. Peron 		free((caddr_t)d->bd_rfilter, M_BPF);
2524ae275efcSJung-uk Kim #ifdef BPF_JITTER
252570485847SJung-uk Kim 		if (d->bd_bfilter != NULL)
2526ae275efcSJung-uk Kim 			bpf_destroy_jit_filter(d->bd_bfilter);
2527ae275efcSJung-uk Kim #endif
2528ae275efcSJung-uk Kim 	}
252970485847SJung-uk Kim 	if (d->bd_wfilter != NULL)
253093e39f0bSChristian S.J. Peron 		free((caddr_t)d->bd_wfilter, M_BPF);
2531afa85850SAlexander V. Chernikov 	mtx_destroy(&d->bd_lock);
2532df8bae1dSRodney W. Grimes }
2533df8bae1dSRodney W. Grimes 
2534df8bae1dSRodney W. Grimes /*
253524a229f4SSam Leffler  * Attach an interface to bpf.  dlt is the link layer type; hdrlen is the
253624a229f4SSam Leffler  * fixed size of the link header (variable length headers not yet supported).
2537df8bae1dSRodney W. Grimes  */
2538df8bae1dSRodney W. Grimes void
253919ba8395SChristian S.J. Peron bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
2540df8bae1dSRodney W. Grimes {
254124a229f4SSam Leffler 
254224a229f4SSam Leffler 	bpfattach2(ifp, dlt, hdrlen, &ifp->if_bpf);
254324a229f4SSam Leffler }
254424a229f4SSam Leffler 
254524a229f4SSam Leffler /*
254624a229f4SSam Leffler  * Attach an interface to bpf.  ifp is a pointer to the structure
254724a229f4SSam Leffler  * defining the interface to be attached, dlt is the link layer type,
254824a229f4SSam Leffler  * and hdrlen is the fixed size of the link header (variable length
254924a229f4SSam Leffler  * headers are not yet supporrted).
255024a229f4SSam Leffler  */
255124a229f4SSam Leffler void
255219ba8395SChristian S.J. Peron bpfattach2(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp)
255324a229f4SSam Leffler {
2554df8bae1dSRodney W. Grimes 	struct bpf_if *bp;
255519ba8395SChristian S.J. Peron 
255619ba8395SChristian S.J. Peron 	bp = malloc(sizeof(*bp), M_BPF, M_NOWAIT | M_ZERO);
2557572bde2aSRobert Watson 	if (bp == NULL)
2558df8bae1dSRodney W. Grimes 		panic("bpfattach");
2559df8bae1dSRodney W. Grimes 
25604a3feeaaSRobert Watson 	LIST_INIT(&bp->bif_dlist);
256151ec1eb7SAlexander V. Chernikov 	LIST_INIT(&bp->bif_wlist);
2562df8bae1dSRodney W. Grimes 	bp->bif_ifp = ifp;
2563df8bae1dSRodney W. Grimes 	bp->bif_dlt = dlt;
2564e4b3229aSAlexander V. Chernikov 	rw_init(&bp->bif_lock, "bpf interface lock");
256516d878ccSChristian S.J. Peron 	KASSERT(*driverp == NULL, ("bpfattach2: driverp already initialized"));
256616d878ccSChristian S.J. Peron 	*driverp = bp;
2567df8bae1dSRodney W. Grimes 
2568e4b3229aSAlexander V. Chernikov 	BPF_LOCK();
25694a3feeaaSRobert Watson 	LIST_INSERT_HEAD(&bpf_iflist, bp, bif_next);
2570e4b3229aSAlexander V. Chernikov 	BPF_UNLOCK();
2571df8bae1dSRodney W. Grimes 
2572547d94bdSJung-uk Kim 	bp->bif_hdrlen = hdrlen;
2573df8bae1dSRodney W. Grimes 
2574616bc4f4SBjoern A. Zeeb 	if (bootverbose && IS_DEFAULT_VNET(curvnet))
257524a229f4SSam Leffler 		if_printf(ifp, "bpf attached\n");
2576df8bae1dSRodney W. Grimes }
257753ac6efbSJulian Elischer 
257805fc4164SBjoern A. Zeeb #ifdef VIMAGE
257905fc4164SBjoern A. Zeeb /*
258005fc4164SBjoern A. Zeeb  * When moving interfaces between vnet instances we need a way to
258105fc4164SBjoern A. Zeeb  * query the dlt and hdrlen before detach so we can re-attch the if_bpf
258205fc4164SBjoern A. Zeeb  * after the vmove.  We unfortunately have no device driver infrastructure
258305fc4164SBjoern A. Zeeb  * to query the interface for these values after creation/attach, thus
258405fc4164SBjoern A. Zeeb  * add this as a workaround.
258505fc4164SBjoern A. Zeeb  */
258605fc4164SBjoern A. Zeeb int
258705fc4164SBjoern A. Zeeb bpf_get_bp_params(struct bpf_if *bp, u_int *bif_dlt, u_int *bif_hdrlen)
258805fc4164SBjoern A. Zeeb {
258905fc4164SBjoern A. Zeeb 
259005fc4164SBjoern A. Zeeb 	if (bp == NULL)
259105fc4164SBjoern A. Zeeb 		return (ENXIO);
259205fc4164SBjoern A. Zeeb 	if (bif_dlt == NULL && bif_hdrlen == NULL)
259305fc4164SBjoern A. Zeeb 		return (0);
259405fc4164SBjoern A. Zeeb 
259505fc4164SBjoern A. Zeeb 	if (bif_dlt != NULL)
259605fc4164SBjoern A. Zeeb 		*bif_dlt = bp->bif_dlt;
259705fc4164SBjoern A. Zeeb 	if (bif_hdrlen != NULL)
259805fc4164SBjoern A. Zeeb 		*bif_hdrlen = bp->bif_hdrlen;
259905fc4164SBjoern A. Zeeb 
260005fc4164SBjoern A. Zeeb 	return (0);
260105fc4164SBjoern A. Zeeb }
260205fc4164SBjoern A. Zeeb #endif
260305fc4164SBjoern A. Zeeb 
2604de5d9935SRobert Watson /*
2605de5d9935SRobert Watson  * Detach bpf from an interface. This involves detaching each descriptor
26066c74ff0eSAlexander V. Chernikov  * associated with the interface. Notify each descriptor as it's detached
26076c74ff0eSAlexander V. Chernikov  * so that any sleepers wake up and get ENXIO.
2608de5d9935SRobert Watson  */
2609de5d9935SRobert Watson void
261019ba8395SChristian S.J. Peron bpfdetach(struct ifnet *ifp)
2611de5d9935SRobert Watson {
2612f079a0faSAlexander V. Chernikov 	struct bpf_if	*bp, *bp_temp;
2613de5d9935SRobert Watson 	struct bpf_d	*d;
26149a7e6bacSLawrence Stewart 	int ndetached;
2615de5d9935SRobert Watson 
26169a7e6bacSLawrence Stewart 	ndetached = 0;
26179a7e6bacSLawrence Stewart 
2618afa85850SAlexander V. Chernikov 	BPF_LOCK();
26199a7e6bacSLawrence Stewart 	/* Find all bpf_if struct's which reference ifp and detach them. */
2620f079a0faSAlexander V. Chernikov 	LIST_FOREACH_SAFE(bp, &bpf_iflist, bif_next, bp_temp) {
2621f079a0faSAlexander V. Chernikov 		if (ifp != bp->bif_ifp)
2622f079a0faSAlexander V. Chernikov 			continue;
2623de5d9935SRobert Watson 
2624f079a0faSAlexander V. Chernikov 		LIST_REMOVE(bp, bif_next);
2625f079a0faSAlexander V. Chernikov 		/* Add to to-be-freed list */
2626f079a0faSAlexander V. Chernikov 		LIST_INSERT_HEAD(&bpf_freelist, bp, bif_next);
2627f079a0faSAlexander V. Chernikov 
26289a7e6bacSLawrence Stewart 		ndetached++;
2629f079a0faSAlexander V. Chernikov 		/*
2630f079a0faSAlexander V. Chernikov 		 * Delay freeing bp till interface is detached
2631f079a0faSAlexander V. Chernikov 		 * and all routes through this interface are removed.
2632f079a0faSAlexander V. Chernikov 		 * Mark bp as detached to restrict new consumers.
2633f079a0faSAlexander V. Chernikov 		 */
2634f079a0faSAlexander V. Chernikov 		BPFIF_WLOCK(bp);
2635b23cbbe6SMark Johnston 		bp->bif_flags |= BPFIF_FLAG_DYING;
2636f079a0faSAlexander V. Chernikov 		BPFIF_WUNLOCK(bp);
2637f079a0faSAlexander V. Chernikov 
2638f079a0faSAlexander V. Chernikov 		CTR4(KTR_NET, "%s: sheduling free for encap %d (%p) for if %p",
2639f079a0faSAlexander V. Chernikov 		    __func__, bp->bif_dlt, bp, ifp);
2640f079a0faSAlexander V. Chernikov 
2641f079a0faSAlexander V. Chernikov 		/* Free common descriptors */
26424a3feeaaSRobert Watson 		while ((d = LIST_FIRST(&bp->bif_dlist)) != NULL) {
2643afa85850SAlexander V. Chernikov 			bpf_detachd_locked(d);
2644afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
2645e7bb21b3SJonathan Lemon 			bpf_wakeup(d);
2646afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
2647e7bb21b3SJonathan Lemon 		}
2648f079a0faSAlexander V. Chernikov 
26496c74ff0eSAlexander V. Chernikov 		/* Free writer-only descriptors */
26506c74ff0eSAlexander V. Chernikov 		while ((d = LIST_FIRST(&bp->bif_wlist)) != NULL) {
2651afa85850SAlexander V. Chernikov 			bpf_detachd_locked(d);
2652afa85850SAlexander V. Chernikov 			BPFD_LOCK(d);
26536c74ff0eSAlexander V. Chernikov 			bpf_wakeup(d);
2654afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(d);
26556c74ff0eSAlexander V. Chernikov 		}
26568eab61f3SSam Leffler 	}
2657afa85850SAlexander V. Chernikov 	BPF_UNLOCK();
26589a7e6bacSLawrence Stewart 
26599a7e6bacSLawrence Stewart #ifdef INVARIANTS
26609a7e6bacSLawrence Stewart 	if (ndetached == 0)
26619a7e6bacSLawrence Stewart 		printf("bpfdetach: %s was not attached\n", ifp->if_xname);
26629a7e6bacSLawrence Stewart #endif
26639a7e6bacSLawrence Stewart }
2664de5d9935SRobert Watson 
26658eab61f3SSam Leffler /*
2666784292f8SAlexander V. Chernikov  * Interface departure handler.
26674fe83b81SAlexander V. Chernikov  * Note departure event does not guarantee interface is going down.
2668f079a0faSAlexander V. Chernikov  * Interface renaming is currently done via departure/arrival event set.
2669f079a0faSAlexander V. Chernikov  *
2670f079a0faSAlexander V. Chernikov  * Departure handled is called after all routes pointing to
2671f079a0faSAlexander V. Chernikov  * given interface are removed and interface is in down state
2672f079a0faSAlexander V. Chernikov  * restricting any packets to be sent/received. We assume it is now safe
2673f079a0faSAlexander V. Chernikov  * to free data allocated by BPF.
2674afa85850SAlexander V. Chernikov  */
2675afa85850SAlexander V. Chernikov static void
2676afa85850SAlexander V. Chernikov bpf_ifdetach(void *arg __unused, struct ifnet *ifp)
2677afa85850SAlexander V. Chernikov {
2678f079a0faSAlexander V. Chernikov 	struct bpf_if *bp, *bp_temp;
2679f079a0faSAlexander V. Chernikov 	int nmatched = 0;
2680afa85850SAlexander V. Chernikov 
2681250a8e27SAndrey V. Elsukov 	/* Ignore ifnet renaming. */
2682250a8e27SAndrey V. Elsukov 	if (ifp->if_flags & IFF_RENAMING)
2683250a8e27SAndrey V. Elsukov 		return;
2684250a8e27SAndrey V. Elsukov 
2685784292f8SAlexander V. Chernikov 	BPF_LOCK();
2686f079a0faSAlexander V. Chernikov 	/*
2687f079a0faSAlexander V. Chernikov 	 * Find matching entries in free list.
2688f079a0faSAlexander V. Chernikov 	 * Nothing should be found if bpfdetach() was not called.
2689f079a0faSAlexander V. Chernikov 	 */
2690f079a0faSAlexander V. Chernikov 	LIST_FOREACH_SAFE(bp, &bpf_freelist, bif_next, bp_temp) {
2691f079a0faSAlexander V. Chernikov 		if (ifp != bp->bif_ifp)
2692f079a0faSAlexander V. Chernikov 			continue;
2693784292f8SAlexander V. Chernikov 
2694f079a0faSAlexander V. Chernikov 		CTR3(KTR_NET, "%s: freeing BPF instance %p for interface %p",
2695afa85850SAlexander V. Chernikov 		    __func__, bp, ifp);
2696afa85850SAlexander V. Chernikov 
2697f079a0faSAlexander V. Chernikov 		LIST_REMOVE(bp, bif_next);
2698784292f8SAlexander V. Chernikov 
2699afa85850SAlexander V. Chernikov 		rw_destroy(&bp->bif_lock);
2700afa85850SAlexander V. Chernikov 		free(bp, M_BPF);
2701f079a0faSAlexander V. Chernikov 
2702f079a0faSAlexander V. Chernikov 		nmatched++;
2703f079a0faSAlexander V. Chernikov 	}
2704f079a0faSAlexander V. Chernikov 	BPF_UNLOCK();
2705f079a0faSAlexander V. Chernikov 
2706f079a0faSAlexander V. Chernikov 	/*
2707f079a0faSAlexander V. Chernikov 	 * Note that we cannot zero other pointers to
2708f079a0faSAlexander V. Chernikov 	 * custom DLTs possibly used by given interface.
2709f079a0faSAlexander V. Chernikov 	 */
2710f079a0faSAlexander V. Chernikov 	if (nmatched != 0)
2711f079a0faSAlexander V. Chernikov 		ifp->if_bpf = NULL;
2712afa85850SAlexander V. Chernikov }
2713afa85850SAlexander V. Chernikov 
2714afa85850SAlexander V. Chernikov /*
27158eab61f3SSam Leffler  * Get a list of available data link type of the interface.
27168eab61f3SSam Leffler  */
27178eab61f3SSam Leffler static int
271819ba8395SChristian S.J. Peron bpf_getdltlist(struct bpf_d *d, struct bpf_dltlist *bfl)
27198eab61f3SSam Leffler {
27208eab61f3SSam Leffler 	struct ifnet *ifp;
27218eab61f3SSam Leffler 	struct bpf_if *bp;
272270209acaSKonstantin Belousov 	u_int *lst;
272370209acaSKonstantin Belousov 	int error, n, n1;
27248eab61f3SSam Leffler 
272597aacec6SAlexander V. Chernikov 	BPF_LOCK_ASSERT();
272697aacec6SAlexander V. Chernikov 
27278eab61f3SSam Leffler 	ifp = d->bd_bif->bif_ifp;
272870209acaSKonstantin Belousov again:
272970209acaSKonstantin Belousov 	n1 = 0;
273070209acaSKonstantin Belousov 	LIST_FOREACH(bp, &bpf_iflist, bif_next) {
273170209acaSKonstantin Belousov 		if (bp->bif_ifp == ifp)
273270209acaSKonstantin Belousov 			n1++;
273370209acaSKonstantin Belousov 	}
273470209acaSKonstantin Belousov 	if (bfl->bfl_list == NULL) {
273570209acaSKonstantin Belousov 		bfl->bfl_len = n1;
273670209acaSKonstantin Belousov 		return (0);
273770209acaSKonstantin Belousov 	}
273870209acaSKonstantin Belousov 	if (n1 > bfl->bfl_len)
273970209acaSKonstantin Belousov 		return (ENOMEM);
274070209acaSKonstantin Belousov 	BPF_UNLOCK();
274170209acaSKonstantin Belousov 	lst = malloc(n1 * sizeof(u_int), M_TEMP, M_WAITOK);
27428eab61f3SSam Leffler 	n = 0;
274370209acaSKonstantin Belousov 	BPF_LOCK();
27444a3feeaaSRobert Watson 	LIST_FOREACH(bp, &bpf_iflist, bif_next) {
27458eab61f3SSam Leffler 		if (bp->bif_ifp != ifp)
27468eab61f3SSam Leffler 			continue;
27475412ec6eSConrad Meyer 		if (n >= n1) {
274870209acaSKonstantin Belousov 			free(lst, M_TEMP);
274970209acaSKonstantin Belousov 			goto again;
27508eab61f3SSam Leffler 		}
275170209acaSKonstantin Belousov 		lst[n] = bp->bif_dlt;
27528eab61f3SSam Leffler 		n++;
27538eab61f3SSam Leffler 	}
275470209acaSKonstantin Belousov 	BPF_UNLOCK();
275570209acaSKonstantin Belousov 	error = copyout(lst, bfl->bfl_list, sizeof(u_int) * n);
275670209acaSKonstantin Belousov 	free(lst, M_TEMP);
275770209acaSKonstantin Belousov 	BPF_LOCK();
27588eab61f3SSam Leffler 	bfl->bfl_len = n;
27598eab61f3SSam Leffler 	return (error);
27608eab61f3SSam Leffler }
27618eab61f3SSam Leffler 
27628eab61f3SSam Leffler /*
27638eab61f3SSam Leffler  * Set the data link type of a BPF instance.
27648eab61f3SSam Leffler  */
27658eab61f3SSam Leffler static int
276619ba8395SChristian S.J. Peron bpf_setdlt(struct bpf_d *d, u_int dlt)
27678eab61f3SSam Leffler {
27688eab61f3SSam Leffler 	int error, opromisc;
27698eab61f3SSam Leffler 	struct ifnet *ifp;
27708eab61f3SSam Leffler 	struct bpf_if *bp;
27718eab61f3SSam Leffler 
27726c74ff0eSAlexander V. Chernikov 	BPF_LOCK_ASSERT();
27736c74ff0eSAlexander V. Chernikov 
27748eab61f3SSam Leffler 	if (d->bd_bif->bif_dlt == dlt)
27758eab61f3SSam Leffler 		return (0);
27768eab61f3SSam Leffler 	ifp = d->bd_bif->bif_ifp;
27776c74ff0eSAlexander V. Chernikov 
27784a3feeaaSRobert Watson 	LIST_FOREACH(bp, &bpf_iflist, bif_next) {
27798eab61f3SSam Leffler 		if (bp->bif_ifp == ifp && bp->bif_dlt == dlt)
27808eab61f3SSam Leffler 			break;
27818eab61f3SSam Leffler 	}
27826c74ff0eSAlexander V. Chernikov 
27838eab61f3SSam Leffler 	if (bp != NULL) {
27848eab61f3SSam Leffler 		opromisc = d->bd_promisc;
27858eab61f3SSam Leffler 		bpf_attachd(d, bp);
2786afa85850SAlexander V. Chernikov 		BPFD_LOCK(d);
27878eab61f3SSam Leffler 		reset_d(d);
2788afa85850SAlexander V. Chernikov 		BPFD_UNLOCK(d);
27898eab61f3SSam Leffler 		if (opromisc) {
27908eab61f3SSam Leffler 			error = ifpromisc(bp->bif_ifp, 1);
27918eab61f3SSam Leffler 			if (error)
27928eab61f3SSam Leffler 				if_printf(bp->bif_ifp,
27938eab61f3SSam Leffler 					"bpf_setdlt: ifpromisc failed (%d)\n",
27948eab61f3SSam Leffler 					error);
27958eab61f3SSam Leffler 			else
27968eab61f3SSam Leffler 				d->bd_promisc = 1;
27978eab61f3SSam Leffler 		}
27988eab61f3SSam Leffler 	}
27998eab61f3SSam Leffler 	return (bp == NULL ? EINVAL : 0);
2800de5d9935SRobert Watson }
2801de5d9935SRobert Watson 
28023f54a085SPoul-Henning Kamp static void
280319ba8395SChristian S.J. Peron bpf_drvinit(void *unused)
280453ac6efbSJulian Elischer {
2805136600feSEd Schouten 	struct cdev *dev;
280653ac6efbSJulian Elischer 
28076008862bSJohn Baldwin 	mtx_init(&bpf_mtx, "bpf global lock", NULL, MTX_DEF);
28084a3feeaaSRobert Watson 	LIST_INIT(&bpf_iflist);
2809f079a0faSAlexander V. Chernikov 	LIST_INIT(&bpf_freelist);
2810136600feSEd Schouten 
2811136600feSEd Schouten 	dev = make_dev(&bpf_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, "bpf");
2812136600feSEd Schouten 	/* For compatibility */
2813136600feSEd Schouten 	make_dev_alias(dev, "bpf0");
2814afa85850SAlexander V. Chernikov 
2815afa85850SAlexander V. Chernikov 	/* Register interface departure handler */
2816afa85850SAlexander V. Chernikov 	bpf_ifdetach_cookie = EVENTHANDLER_REGISTER(
2817afa85850SAlexander V. Chernikov 		    ifnet_departure_event, bpf_ifdetach, NULL,
2818afa85850SAlexander V. Chernikov 		    EVENTHANDLER_PRI_ANY);
28197198bf47SJulian Elischer }
282053ac6efbSJulian Elischer 
28210e37f3e1SChristian S.J. Peron /*
28220e37f3e1SChristian S.J. Peron  * Zero out the various packet counters associated with all of the bpf
28230e37f3e1SChristian S.J. Peron  * descriptors.  At some point, we will probably want to get a bit more
28240e37f3e1SChristian S.J. Peron  * granular and allow the user to specify descriptors to be zeroed.
28250e37f3e1SChristian S.J. Peron  */
28260e37f3e1SChristian S.J. Peron static void
28270e37f3e1SChristian S.J. Peron bpf_zero_counters(void)
28280e37f3e1SChristian S.J. Peron {
28290e37f3e1SChristian S.J. Peron 	struct bpf_if *bp;
28300e37f3e1SChristian S.J. Peron 	struct bpf_d *bd;
28310e37f3e1SChristian S.J. Peron 
2832e4b3229aSAlexander V. Chernikov 	BPF_LOCK();
28330e37f3e1SChristian S.J. Peron 	LIST_FOREACH(bp, &bpf_iflist, bif_next) {
2834e4b3229aSAlexander V. Chernikov 		BPFIF_RLOCK(bp);
28350e37f3e1SChristian S.J. Peron 		LIST_FOREACH(bd, &bp->bif_dlist, bd_next) {
2836afa85850SAlexander V. Chernikov 			BPFD_LOCK(bd);
28370e37f3e1SChristian S.J. Peron 			bd->bd_rcount = 0;
28380e37f3e1SChristian S.J. Peron 			bd->bd_dcount = 0;
28390e37f3e1SChristian S.J. Peron 			bd->bd_fcount = 0;
28400e37f3e1SChristian S.J. Peron 			bd->bd_wcount = 0;
28410e37f3e1SChristian S.J. Peron 			bd->bd_wfcount = 0;
28420e37f3e1SChristian S.J. Peron 			bd->bd_zcopy = 0;
2843afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(bd);
28440e37f3e1SChristian S.J. Peron 		}
2845e4b3229aSAlexander V. Chernikov 		BPFIF_RUNLOCK(bp);
28460e37f3e1SChristian S.J. Peron 	}
2847e4b3229aSAlexander V. Chernikov 	BPF_UNLOCK();
28480e37f3e1SChristian S.J. Peron }
28490e37f3e1SChristian S.J. Peron 
28506c74ff0eSAlexander V. Chernikov /*
28516c74ff0eSAlexander V. Chernikov  * Fill filter statistics
28526c74ff0eSAlexander V. Chernikov  */
285369f7644bSChristian S.J. Peron static void
285469f7644bSChristian S.J. Peron bpfstats_fill_xbpf(struct xbpf_d *d, struct bpf_d *bd)
285569f7644bSChristian S.J. Peron {
285669f7644bSChristian S.J. Peron 
285769f7644bSChristian S.J. Peron 	bzero(d, sizeof(*d));
285869f7644bSChristian S.J. Peron 	BPFD_LOCK_ASSERT(bd);
28594d621040SChristian S.J. Peron 	d->bd_structsize = sizeof(*d);
28606c74ff0eSAlexander V. Chernikov 	/* XXX: reading should be protected by global lock */
286169f7644bSChristian S.J. Peron 	d->bd_immediate = bd->bd_immediate;
286269f7644bSChristian S.J. Peron 	d->bd_promisc = bd->bd_promisc;
286369f7644bSChristian S.J. Peron 	d->bd_hdrcmplt = bd->bd_hdrcmplt;
2864560a54e1SJung-uk Kim 	d->bd_direction = bd->bd_direction;
2865560a54e1SJung-uk Kim 	d->bd_feedback = bd->bd_feedback;
286669f7644bSChristian S.J. Peron 	d->bd_async = bd->bd_async;
286769f7644bSChristian S.J. Peron 	d->bd_rcount = bd->bd_rcount;
286869f7644bSChristian S.J. Peron 	d->bd_dcount = bd->bd_dcount;
286969f7644bSChristian S.J. Peron 	d->bd_fcount = bd->bd_fcount;
287069f7644bSChristian S.J. Peron 	d->bd_sig = bd->bd_sig;
287169f7644bSChristian S.J. Peron 	d->bd_slen = bd->bd_slen;
287269f7644bSChristian S.J. Peron 	d->bd_hlen = bd->bd_hlen;
287369f7644bSChristian S.J. Peron 	d->bd_bufsize = bd->bd_bufsize;
287469f7644bSChristian S.J. Peron 	d->bd_pid = bd->bd_pid;
287569f7644bSChristian S.J. Peron 	strlcpy(d->bd_ifname,
287669f7644bSChristian S.J. Peron 	    bd->bd_bif->bif_ifp->if_xname, IFNAMSIZ);
287793e39f0bSChristian S.J. Peron 	d->bd_locked = bd->bd_locked;
28784d621040SChristian S.J. Peron 	d->bd_wcount = bd->bd_wcount;
28794d621040SChristian S.J. Peron 	d->bd_wdcount = bd->bd_wdcount;
28804d621040SChristian S.J. Peron 	d->bd_wfcount = bd->bd_wfcount;
28814d621040SChristian S.J. Peron 	d->bd_zcopy = bd->bd_zcopy;
28824d621040SChristian S.J. Peron 	d->bd_bufmode = bd->bd_bufmode;
288369f7644bSChristian S.J. Peron }
288469f7644bSChristian S.J. Peron 
28856c74ff0eSAlexander V. Chernikov /*
28866c74ff0eSAlexander V. Chernikov  * Handle `netstat -B' stats request
28876c74ff0eSAlexander V. Chernikov  */
288869f7644bSChristian S.J. Peron static int
288969f7644bSChristian S.J. Peron bpf_stats_sysctl(SYSCTL_HANDLER_ARGS)
289069f7644bSChristian S.J. Peron {
28910e1152fcSHans Petter Selasky 	static const struct xbpf_d zerostats;
28920e1152fcSHans Petter Selasky 	struct xbpf_d *xbdbuf, *xbd, tempstats;
2893422a63daSChristian S.J. Peron 	int index, error;
289469f7644bSChristian S.J. Peron 	struct bpf_if *bp;
289569f7644bSChristian S.J. Peron 	struct bpf_d *bd;
289669f7644bSChristian S.J. Peron 
289769f7644bSChristian S.J. Peron 	/*
289869f7644bSChristian S.J. Peron 	 * XXX This is not technically correct. It is possible for non
289969f7644bSChristian S.J. Peron 	 * privileged users to open bpf devices. It would make sense
290069f7644bSChristian S.J. Peron 	 * if the users who opened the devices were able to retrieve
290169f7644bSChristian S.J. Peron 	 * the statistics for them, too.
290269f7644bSChristian S.J. Peron 	 */
2903acd3428bSRobert Watson 	error = priv_check(req->td, PRIV_NET_BPF);
290469f7644bSChristian S.J. Peron 	if (error)
290569f7644bSChristian S.J. Peron 		return (error);
29060e37f3e1SChristian S.J. Peron 	/*
29070e37f3e1SChristian S.J. Peron 	 * Check to see if the user is requesting that the counters be
29080e37f3e1SChristian S.J. Peron 	 * zeroed out.  Explicitly check that the supplied data is zeroed,
29090e37f3e1SChristian S.J. Peron 	 * as we aren't allowing the user to set the counters currently.
29100e37f3e1SChristian S.J. Peron 	 */
29110e37f3e1SChristian S.J. Peron 	if (req->newptr != NULL) {
29120e1152fcSHans Petter Selasky 		if (req->newlen != sizeof(tempstats))
29130e37f3e1SChristian S.J. Peron 			return (EINVAL);
29140e1152fcSHans Petter Selasky 		memset(&tempstats, 0, sizeof(tempstats));
29150e1152fcSHans Petter Selasky 		error = SYSCTL_IN(req, &tempstats, sizeof(tempstats));
29160e1152fcSHans Petter Selasky 		if (error)
29170e1152fcSHans Petter Selasky 			return (error);
29180e1152fcSHans Petter Selasky 		if (bcmp(&tempstats, &zerostats, sizeof(tempstats)) != 0)
29190e37f3e1SChristian S.J. Peron 			return (EINVAL);
29200e37f3e1SChristian S.J. Peron 		bpf_zero_counters();
29210e37f3e1SChristian S.J. Peron 		return (0);
29220e37f3e1SChristian S.J. Peron 	}
292369f7644bSChristian S.J. Peron 	if (req->oldptr == NULL)
2924422a63daSChristian S.J. Peron 		return (SYSCTL_OUT(req, 0, bpf_bpfd_cnt * sizeof(*xbd)));
292569f7644bSChristian S.J. Peron 	if (bpf_bpfd_cnt == 0)
292669f7644bSChristian S.J. Peron 		return (SYSCTL_OUT(req, 0, 0));
2927422a63daSChristian S.J. Peron 	xbdbuf = malloc(req->oldlen, M_BPF, M_WAITOK);
2928e4b3229aSAlexander V. Chernikov 	BPF_LOCK();
2929422a63daSChristian S.J. Peron 	if (req->oldlen < (bpf_bpfd_cnt * sizeof(*xbd))) {
2930e4b3229aSAlexander V. Chernikov 		BPF_UNLOCK();
2931422a63daSChristian S.J. Peron 		free(xbdbuf, M_BPF);
2932422a63daSChristian S.J. Peron 		return (ENOMEM);
2933422a63daSChristian S.J. Peron 	}
2934422a63daSChristian S.J. Peron 	index = 0;
293569f7644bSChristian S.J. Peron 	LIST_FOREACH(bp, &bpf_iflist, bif_next) {
2936e4b3229aSAlexander V. Chernikov 		BPFIF_RLOCK(bp);
293751ec1eb7SAlexander V. Chernikov 		/* Send writers-only first */
293851ec1eb7SAlexander V. Chernikov 		LIST_FOREACH(bd, &bp->bif_wlist, bd_next) {
293951ec1eb7SAlexander V. Chernikov 			xbd = &xbdbuf[index++];
2940afa85850SAlexander V. Chernikov 			BPFD_LOCK(bd);
294151ec1eb7SAlexander V. Chernikov 			bpfstats_fill_xbpf(xbd, bd);
2942afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(bd);
294351ec1eb7SAlexander V. Chernikov 		}
294469f7644bSChristian S.J. Peron 		LIST_FOREACH(bd, &bp->bif_dlist, bd_next) {
2945422a63daSChristian S.J. Peron 			xbd = &xbdbuf[index++];
2946afa85850SAlexander V. Chernikov 			BPFD_LOCK(bd);
2947422a63daSChristian S.J. Peron 			bpfstats_fill_xbpf(xbd, bd);
2948afa85850SAlexander V. Chernikov 			BPFD_UNLOCK(bd);
294969f7644bSChristian S.J. Peron 		}
2950e4b3229aSAlexander V. Chernikov 		BPFIF_RUNLOCK(bp);
295169f7644bSChristian S.J. Peron 	}
2952e4b3229aSAlexander V. Chernikov 	BPF_UNLOCK();
2953422a63daSChristian S.J. Peron 	error = SYSCTL_OUT(req, xbdbuf, index * sizeof(*xbd));
2954422a63daSChristian S.J. Peron 	free(xbdbuf, M_BPF);
295569f7644bSChristian S.J. Peron 	return (error);
295669f7644bSChristian S.J. Peron }
295769f7644bSChristian S.J. Peron 
2958237fdd78SRobert Watson SYSINIT(bpfdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE,bpf_drvinit,NULL);
295953ac6efbSJulian Elischer 
29605bb5f2c9SPeter Wemm #else /* !DEV_BPF && !NETGRAPH_BPF */
2961f8dc4716SMike Smith /*
2962f8dc4716SMike Smith  * NOP stubs to allow bpf-using drivers to load and function.
2963f8dc4716SMike Smith  *
2964f8dc4716SMike Smith  * A 'better' implementation would allow the core bpf functionality
2965f8dc4716SMike Smith  * to be loaded at runtime.
2966f8dc4716SMike Smith  */
29677eae78a4SChristian S.J. Peron static struct bpf_if bp_null;
2968f8dc4716SMike Smith 
2969f8dc4716SMike Smith void
297019ba8395SChristian S.J. Peron bpf_tap(struct bpf_if *bp, u_char *pkt, u_int pktlen)
2971f8dc4716SMike Smith {
2972f8dc4716SMike Smith }
2973f8dc4716SMike Smith 
2974f8dc4716SMike Smith void
297519ba8395SChristian S.J. Peron bpf_mtap(struct bpf_if *bp, struct mbuf *m)
2976f8dc4716SMike Smith {
2977f8dc4716SMike Smith }
2978f8dc4716SMike Smith 
2979f8dc4716SMike Smith void
298019ba8395SChristian S.J. Peron bpf_mtap2(struct bpf_if *bp, void *d, u_int l, struct mbuf *m)
2981437ffe18SSam Leffler {
2982437ffe18SSam Leffler }
2983437ffe18SSam Leffler 
2984437ffe18SSam Leffler void
298519ba8395SChristian S.J. Peron bpfattach(struct ifnet *ifp, u_int dlt, u_int hdrlen)
2986f8dc4716SMike Smith {
29877eae78a4SChristian S.J. Peron 
29887eae78a4SChristian S.J. Peron 	bpfattach2(ifp, dlt, hdrlen, &ifp->if_bpf);
2989f8dc4716SMike Smith }
2990f8dc4716SMike Smith 
2991da626c17SBill Paul void
299219ba8395SChristian S.J. Peron bpfattach2(struct ifnet *ifp, u_int dlt, u_int hdrlen, struct bpf_if **driverp)
29935f7a7923SSam Leffler {
29947eae78a4SChristian S.J. Peron 
29957eae78a4SChristian S.J. Peron 	*driverp = &bp_null;
29965f7a7923SSam Leffler }
29975f7a7923SSam Leffler 
29985f7a7923SSam Leffler void
299919ba8395SChristian S.J. Peron bpfdetach(struct ifnet *ifp)
3000da626c17SBill Paul {
3001da626c17SBill Paul }
3002da626c17SBill Paul 
3003f8dc4716SMike Smith u_int
300419ba8395SChristian S.J. Peron bpf_filter(const struct bpf_insn *pc, u_char *p, u_int wirelen, u_int buflen)
3005f8dc4716SMike Smith {
3006f8dc4716SMike Smith 	return -1;	/* "no filter" behaviour */
3007f8dc4716SMike Smith }
3008f8dc4716SMike Smith 
30095bb5f2c9SPeter Wemm int
301019ba8395SChristian S.J. Peron bpf_validate(const struct bpf_insn *f, int len)
30115bb5f2c9SPeter Wemm {
30125bb5f2c9SPeter Wemm 	return 0;		/* false */
30135bb5f2c9SPeter Wemm }
30145bb5f2c9SPeter Wemm 
30155bb5f2c9SPeter Wemm #endif /* !DEV_BPF && !NETGRAPH_BPF */
301605fc4164SBjoern A. Zeeb 
301705fc4164SBjoern A. Zeeb #ifdef DDB
301805fc4164SBjoern A. Zeeb static void
301905fc4164SBjoern A. Zeeb bpf_show_bpf_if(struct bpf_if *bpf_if)
302005fc4164SBjoern A. Zeeb {
302105fc4164SBjoern A. Zeeb 
302205fc4164SBjoern A. Zeeb 	if (bpf_if == NULL)
302305fc4164SBjoern A. Zeeb 		return;
302405fc4164SBjoern A. Zeeb 	db_printf("%p:\n", bpf_if);
302505fc4164SBjoern A. Zeeb #define	BPF_DB_PRINTF(f, e)	db_printf("   %s = " f "\n", #e, bpf_if->e);
302605fc4164SBjoern A. Zeeb 	/* bif_ext.bif_next */
302705fc4164SBjoern A. Zeeb 	/* bif_ext.bif_dlist */
302805fc4164SBjoern A. Zeeb 	BPF_DB_PRINTF("%#x", bif_dlt);
302905fc4164SBjoern A. Zeeb 	BPF_DB_PRINTF("%u", bif_hdrlen);
303005fc4164SBjoern A. Zeeb 	BPF_DB_PRINTF("%p", bif_ifp);
303105fc4164SBjoern A. Zeeb 	/* bif_lock */
303205fc4164SBjoern A. Zeeb 	/* bif_wlist */
303305fc4164SBjoern A. Zeeb 	BPF_DB_PRINTF("%#x", bif_flags);
303405fc4164SBjoern A. Zeeb }
303505fc4164SBjoern A. Zeeb 
303605fc4164SBjoern A. Zeeb DB_SHOW_COMMAND(bpf_if, db_show_bpf_if)
303705fc4164SBjoern A. Zeeb {
303805fc4164SBjoern A. Zeeb 
303905fc4164SBjoern A. Zeeb 	if (!have_addr) {
304005fc4164SBjoern A. Zeeb 		db_printf("usage: show bpf_if <struct bpf_if *>\n");
304105fc4164SBjoern A. Zeeb 		return;
304205fc4164SBjoern A. Zeeb 	}
304305fc4164SBjoern A. Zeeb 
304405fc4164SBjoern A. Zeeb 	bpf_show_bpf_if((struct bpf_if *)addr);
304505fc4164SBjoern A. Zeeb }
304605fc4164SBjoern A. Zeeb #endif
3047