ifq.h revision 238990
1/*-
2 * Copyright (c) 1982, 1986, 1989, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 *	From: @(#)if.h	8.1 (Berkeley) 6/10/93
30 * $FreeBSD: head/sys/net/if_var.h 238990 2012-08-02 13:57:49Z glebius $
31 */
32
33#ifndef	_NET_IF_VAR_H_
34#define	_NET_IF_VAR_H_
35
36/*
37 * Structures defining a network interface, providing a packet
38 * transport mechanism (ala level 0 of the PUP protocols).
39 *
40 * Each interface accepts output datagrams of a specified maximum
41 * length, and provides higher level routines with input datagrams
42 * received from its medium.
43 *
44 * Output occurs when the routine if_output is called, with three parameters:
45 *	(*ifp->if_output)(ifp, m, dst, rt)
46 * Here m is the mbuf chain to be sent and dst is the destination address.
47 * The output routine encapsulates the supplied datagram if necessary,
48 * and then transmits it on its medium.
49 *
50 * On input, each interface unwraps the data received by it, and either
51 * places it on the input queue of an internetwork datagram routine
52 * and posts the associated software interrupt, or passes the datagram to a raw
53 * packet input routine.
54 *
55 * Routines exist for locating interfaces by their addresses
56 * or for locating an interface on a certain network, as well as more general
57 * routing and gateway routines maintaining information used to locate
58 * interfaces.  These routines live in the files if.c and route.c
59 */
60
61#ifdef __STDC__
62/*
63 * Forward structure declarations for function prototypes [sic].
64 */
65struct	mbuf;
66struct	thread;
67struct	rtentry;
68struct	rt_addrinfo;
69struct	socket;
70struct	ether_header;
71struct	carp_if;
72struct	carp_softc;
73struct  ifvlantrunk;
74struct	route;
75struct	vnet;
76#endif
77
78#include <sys/queue.h>		/* get TAILQ macros */
79
80#ifdef _KERNEL
81#include <sys/mbuf.h>
82#include <sys/eventhandler.h>
83#include <sys/buf_ring.h>
84#include <net/vnet.h>
85#endif /* _KERNEL */
86#include <sys/lock.h>		/* XXX */
87#include <sys/mutex.h>		/* XXX */
88#include <sys/rwlock.h>		/* XXX */
89#include <sys/sx.h>		/* XXX */
90#include <sys/event.h>		/* XXX */
91#include <sys/_task.h>
92
93#define	IF_DUNIT_NONE	-1
94
95#include <altq/if_altq.h>
96
97TAILQ_HEAD(ifnethead, ifnet);	/* we use TAILQs so that the order of */
98TAILQ_HEAD(ifaddrhead, ifaddr);	/* instantiation is preserved in the list */
99TAILQ_HEAD(ifmultihead, ifmultiaddr);
100TAILQ_HEAD(ifgrouphead, ifg_group);
101
102/*
103 * Structure defining a queue for a network interface.
104 */
105struct	ifqueue {
106	struct	mbuf *ifq_head;
107	struct	mbuf *ifq_tail;
108	int	ifq_len;
109	int	ifq_maxlen;
110	int	ifq_drops;
111	struct	mtx ifq_mtx;
112};
113
114/*
115 * Structure defining a network interface.
116 *
117 * (Would like to call this struct ``if'', but C isn't PL/1.)
118 */
119
120struct ifnet {
121	void	*if_softc;		/* pointer to driver state */
122	void	*if_l2com;		/* pointer to protocol bits */
123	struct vnet *if_vnet;		/* pointer to network stack instance */
124	TAILQ_ENTRY(ifnet) if_link; 	/* all struct ifnets are chained */
125	char	if_xname[IFNAMSIZ];	/* external name (name + unit) */
126	const char *if_dname;		/* driver name */
127	int	if_dunit;		/* unit or IF_DUNIT_NONE */
128	u_int	if_refcount;		/* reference count */
129	struct	ifaddrhead if_addrhead;	/* linked list of addresses per if */
130		/*
131		 * if_addrhead is the list of all addresses associated to
132		 * an interface.
133		 * Some code in the kernel assumes that first element
134		 * of the list has type AF_LINK, and contains sockaddr_dl
135		 * addresses which store the link-level address and the name
136		 * of the interface.
137		 * However, access to the AF_LINK address through this
138		 * field is deprecated. Use if_addr or ifaddr_byindex() instead.
139		 */
140	int	if_pcount;		/* number of promiscuous listeners */
141	struct	carp_if *if_carp;	/* carp interface structure */
142	struct	bpf_if *if_bpf;		/* packet filter structure */
143	u_short	if_index;		/* numeric abbreviation for this if  */
144	short	if_index_reserved;	/* spare space to grow if_index */
145	struct  ifvlantrunk *if_vlantrunk; /* pointer to 802.1q data */
146	int	if_flags;		/* up/down, broadcast, etc. */
147	int	if_capabilities;	/* interface features & capabilities */
148	int	if_capenable;		/* enabled features & capabilities */
149	void	*if_linkmib;		/* link-type-specific MIB data */
150	size_t	if_linkmiblen;		/* length of above data */
151	struct	if_data if_data;
152	struct	ifmultihead if_multiaddrs; /* multicast addresses configured */
153	int	if_amcount;		/* number of all-multicast requests */
154/* procedure handles */
155	int	(*if_output)		/* output routine (enqueue) */
156		(struct ifnet *, struct mbuf *, struct sockaddr *,
157		     struct route *);
158	void	(*if_input)		/* input routine (from h/w driver) */
159		(struct ifnet *, struct mbuf *);
160	void	(*if_start)		/* initiate output routine */
161		(struct ifnet *);
162	int	(*if_ioctl)		/* ioctl routine */
163		(struct ifnet *, u_long, caddr_t);
164	void	(*if_init)		/* Init routine */
165		(void *);
166	int	(*if_resolvemulti)	/* validate/resolve multicast */
167		(struct ifnet *, struct sockaddr **, struct sockaddr *);
168	void	(*if_qflush)		/* flush any queues */
169		(struct ifnet *);
170	int	(*if_transmit)		/* initiate output routine */
171		(struct ifnet *, struct mbuf *);
172	void	(*if_reassign)		/* reassign to vnet routine */
173		(struct ifnet *, struct vnet *, char *);
174	struct	vnet *if_home_vnet;	/* where this ifnet originates from */
175	struct	ifaddr	*if_addr;	/* pointer to link-level address */
176	void	*if_llsoftc;		/* link layer softc */
177	int	if_drv_flags;		/* driver-managed status flags */
178	struct  ifaltq if_snd;		/* output queue (includes altq) */
179	const u_int8_t *if_broadcastaddr; /* linklevel broadcast bytestring */
180
181	void	*if_bridge;		/* bridge glue */
182
183	struct	label *if_label;	/* interface MAC label */
184
185	/* these are only used by IPv6 */
186	void	*if_unused[2];
187	void	*if_afdata[AF_MAX];
188	int	if_afdata_initialized;
189	struct	rwlock if_afdata_lock;
190	struct	task if_linktask;	/* task for link change events */
191	struct	rwlock if_addr_lock;	/* lock to protect address lists */
192
193	LIST_ENTRY(ifnet) if_clones;	/* interfaces of a cloner */
194	TAILQ_HEAD(, ifg_list) if_groups; /* linked list of groups per if */
195					/* protected by if_addr_lock */
196	void	*if_pf_kif;
197	void	*if_lagg;		/* lagg glue */
198	char	*if_description;	/* interface description */
199	u_int	if_fib;			/* interface FIB */
200	u_char	if_alloctype;		/* if_type at time of allocation */
201
202	/*
203	 * Spare fields are added so that we can modify sensitive data
204	 * structures without changing the kernel binary interface, and must
205	 * be used with care where binary compatibility is required.
206	 */
207	char	if_cspare[3];
208	int	if_ispare[4];
209	void	*if_pspare[8];		/* 1 netmap, 7 TDB */
210};
211
212typedef void if_init_f_t(void *);
213
214/*
215 * XXX These aliases are terribly dangerous because they could apply
216 * to anything.
217 */
218#define	if_mtu		if_data.ifi_mtu
219#define	if_type		if_data.ifi_type
220#define if_physical	if_data.ifi_physical
221#define	if_addrlen	if_data.ifi_addrlen
222#define	if_hdrlen	if_data.ifi_hdrlen
223#define	if_metric	if_data.ifi_metric
224#define	if_link_state	if_data.ifi_link_state
225#define	if_baudrate	if_data.ifi_baudrate
226#define	if_hwassist	if_data.ifi_hwassist
227#define	if_ipackets	if_data.ifi_ipackets
228#define	if_ierrors	if_data.ifi_ierrors
229#define	if_opackets	if_data.ifi_opackets
230#define	if_oerrors	if_data.ifi_oerrors
231#define	if_collisions	if_data.ifi_collisions
232#define	if_ibytes	if_data.ifi_ibytes
233#define	if_obytes	if_data.ifi_obytes
234#define	if_imcasts	if_data.ifi_imcasts
235#define	if_omcasts	if_data.ifi_omcasts
236#define	if_iqdrops	if_data.ifi_iqdrops
237#define	if_noproto	if_data.ifi_noproto
238#define	if_lastchange	if_data.ifi_lastchange
239
240/* for compatibility with other BSDs */
241#define	if_addrlist	if_addrhead
242#define	if_list		if_link
243#define	if_name(ifp)	((ifp)->if_xname)
244
245/*
246 * Locks for address lists on the network interface.
247 */
248#define	IF_ADDR_LOCK_INIT(if)	rw_init(&(if)->if_addr_lock, "if_addr_lock")
249#define	IF_ADDR_LOCK_DESTROY(if)	rw_destroy(&(if)->if_addr_lock)
250#define	IF_ADDR_WLOCK(if)	rw_wlock(&(if)->if_addr_lock)
251#define	IF_ADDR_WUNLOCK(if)	rw_wunlock(&(if)->if_addr_lock)
252#define	IF_ADDR_RLOCK(if)	rw_rlock(&(if)->if_addr_lock)
253#define	IF_ADDR_RUNLOCK(if)	rw_runlock(&(if)->if_addr_lock)
254#define	IF_ADDR_LOCK_ASSERT(if)	rw_assert(&(if)->if_addr_lock, RA_LOCKED)
255#define	IF_ADDR_WLOCK_ASSERT(if) rw_assert(&(if)->if_addr_lock, RA_WLOCKED)
256
257/*
258 * Function variations on locking macros intended to be used by loadable
259 * kernel modules in order to divorce them from the internals of address list
260 * locking.
261 */
262void	if_addr_rlock(struct ifnet *ifp);	/* if_addrhead */
263void	if_addr_runlock(struct ifnet *ifp);	/* if_addrhead */
264void	if_maddr_rlock(struct ifnet *ifp);	/* if_multiaddrs */
265void	if_maddr_runlock(struct ifnet *ifp);	/* if_multiaddrs */
266
267/*
268 * Output queues (ifp->if_snd) and slow device input queues (*ifp->if_slowq)
269 * are queues of messages stored on ifqueue structures
270 * (defined above).  Entries are added to and deleted from these structures
271 * by these macros, which should be called with ipl raised to splimp().
272 */
273#define IF_LOCK(ifq)		mtx_lock(&(ifq)->ifq_mtx)
274#define IF_UNLOCK(ifq)		mtx_unlock(&(ifq)->ifq_mtx)
275#define	IF_LOCK_ASSERT(ifq)	mtx_assert(&(ifq)->ifq_mtx, MA_OWNED)
276#define	_IF_QFULL(ifq)		((ifq)->ifq_len >= (ifq)->ifq_maxlen)
277#define	_IF_DROP(ifq)		((ifq)->ifq_drops++)
278#define	_IF_QLEN(ifq)		((ifq)->ifq_len)
279
280#define	_IF_ENQUEUE(ifq, m) do { 				\
281	(m)->m_nextpkt = NULL;					\
282	if ((ifq)->ifq_tail == NULL) 				\
283		(ifq)->ifq_head = m; 				\
284	else 							\
285		(ifq)->ifq_tail->m_nextpkt = m; 		\
286	(ifq)->ifq_tail = m; 					\
287	(ifq)->ifq_len++; 					\
288} while (0)
289
290#define IF_ENQUEUE(ifq, m) do {					\
291	IF_LOCK(ifq); 						\
292	_IF_ENQUEUE(ifq, m); 					\
293	IF_UNLOCK(ifq); 					\
294} while (0)
295
296#define	_IF_PREPEND(ifq, m) do {				\
297	(m)->m_nextpkt = (ifq)->ifq_head; 			\
298	if ((ifq)->ifq_tail == NULL) 				\
299		(ifq)->ifq_tail = (m); 				\
300	(ifq)->ifq_head = (m); 					\
301	(ifq)->ifq_len++; 					\
302} while (0)
303
304#define IF_PREPEND(ifq, m) do {		 			\
305	IF_LOCK(ifq); 						\
306	_IF_PREPEND(ifq, m); 					\
307	IF_UNLOCK(ifq); 					\
308} while (0)
309
310#define	_IF_DEQUEUE(ifq, m) do { 				\
311	(m) = (ifq)->ifq_head; 					\
312	if (m) { 						\
313		if (((ifq)->ifq_head = (m)->m_nextpkt) == NULL)	\
314			(ifq)->ifq_tail = NULL; 		\
315		(m)->m_nextpkt = NULL; 				\
316		(ifq)->ifq_len--; 				\
317	} 							\
318} while (0)
319
320#define IF_DEQUEUE(ifq, m) do { 				\
321	IF_LOCK(ifq); 						\
322	_IF_DEQUEUE(ifq, m); 					\
323	IF_UNLOCK(ifq); 					\
324} while (0)
325
326#define	_IF_DEQUEUE_ALL(ifq, m) do {				\
327	(m) = (ifq)->ifq_head;					\
328	(ifq)->ifq_head = (ifq)->ifq_tail = NULL;		\
329	(ifq)->ifq_len = 0;					\
330} while (0)
331
332#define	IF_DEQUEUE_ALL(ifq, m) do {				\
333	IF_LOCK(ifq); 						\
334	_IF_DEQUEUE_ALL(ifq, m);				\
335	IF_UNLOCK(ifq); 					\
336} while (0)
337
338#define	_IF_POLL(ifq, m)	((m) = (ifq)->ifq_head)
339#define	IF_POLL(ifq, m)		_IF_POLL(ifq, m)
340
341#define _IF_DRAIN(ifq) do { 					\
342	struct mbuf *m; 					\
343	for (;;) { 						\
344		_IF_DEQUEUE(ifq, m); 				\
345		if (m == NULL) 					\
346			break; 					\
347		m_freem(m); 					\
348	} 							\
349} while (0)
350
351#define IF_DRAIN(ifq) do {					\
352	IF_LOCK(ifq);						\
353	_IF_DRAIN(ifq);						\
354	IF_UNLOCK(ifq);						\
355} while(0)
356
357#ifdef _KERNEL
358/* interface link layer address change event */
359typedef void (*iflladdr_event_handler_t)(void *, struct ifnet *);
360EVENTHANDLER_DECLARE(iflladdr_event, iflladdr_event_handler_t);
361/* interface address change event */
362typedef void (*ifaddr_event_handler_t)(void *, struct ifnet *);
363EVENTHANDLER_DECLARE(ifaddr_event, ifaddr_event_handler_t);
364/* new interface arrival event */
365typedef void (*ifnet_arrival_event_handler_t)(void *, struct ifnet *);
366EVENTHANDLER_DECLARE(ifnet_arrival_event, ifnet_arrival_event_handler_t);
367/* interface departure event */
368typedef void (*ifnet_departure_event_handler_t)(void *, struct ifnet *);
369EVENTHANDLER_DECLARE(ifnet_departure_event, ifnet_departure_event_handler_t);
370/* Interface link state change event */
371typedef void (*ifnet_link_event_handler_t)(void *, struct ifnet *, int);
372EVENTHANDLER_DECLARE(ifnet_link_event, ifnet_link_event_handler_t);
373
374/*
375 * interface groups
376 */
377struct ifg_group {
378	char				 ifg_group[IFNAMSIZ];
379	u_int				 ifg_refcnt;
380	void				*ifg_pf_kif;
381	TAILQ_HEAD(, ifg_member)	 ifg_members;
382	TAILQ_ENTRY(ifg_group)		 ifg_next;
383};
384
385struct ifg_member {
386	TAILQ_ENTRY(ifg_member)	 ifgm_next;
387	struct ifnet		*ifgm_ifp;
388};
389
390struct ifg_list {
391	struct ifg_group	*ifgl_group;
392	TAILQ_ENTRY(ifg_list)	 ifgl_next;
393};
394
395/* group attach event */
396typedef void (*group_attach_event_handler_t)(void *, struct ifg_group *);
397EVENTHANDLER_DECLARE(group_attach_event, group_attach_event_handler_t);
398/* group detach event */
399typedef void (*group_detach_event_handler_t)(void *, struct ifg_group *);
400EVENTHANDLER_DECLARE(group_detach_event, group_detach_event_handler_t);
401/* group change event */
402typedef void (*group_change_event_handler_t)(void *, const char *);
403EVENTHANDLER_DECLARE(group_change_event, group_change_event_handler_t);
404
405#define	IF_AFDATA_LOCK_INIT(ifp)	\
406	rw_init(&(ifp)->if_afdata_lock, "if_afdata")
407
408#define	IF_AFDATA_WLOCK(ifp)	rw_wlock(&(ifp)->if_afdata_lock)
409#define	IF_AFDATA_RLOCK(ifp)	rw_rlock(&(ifp)->if_afdata_lock)
410#define	IF_AFDATA_WUNLOCK(ifp)	rw_wunlock(&(ifp)->if_afdata_lock)
411#define	IF_AFDATA_RUNLOCK(ifp)	rw_runlock(&(ifp)->if_afdata_lock)
412#define	IF_AFDATA_LOCK(ifp)	IF_AFDATA_WLOCK(ifp)
413#define	IF_AFDATA_UNLOCK(ifp)	IF_AFDATA_WUNLOCK(ifp)
414#define	IF_AFDATA_TRYLOCK(ifp)	rw_try_wlock(&(ifp)->if_afdata_lock)
415#define	IF_AFDATA_DESTROY(ifp)	rw_destroy(&(ifp)->if_afdata_lock)
416
417#define	IF_AFDATA_LOCK_ASSERT(ifp)	rw_assert(&(ifp)->if_afdata_lock, RA_LOCKED)
418#define	IF_AFDATA_RLOCK_ASSERT(ifp)	rw_assert(&(ifp)->if_afdata_lock, RA_RLOCKED)
419#define	IF_AFDATA_WLOCK_ASSERT(ifp)	rw_assert(&(ifp)->if_afdata_lock, RA_WLOCKED)
420#define	IF_AFDATA_UNLOCK_ASSERT(ifp)	rw_assert(&(ifp)->if_afdata_lock, RA_UNLOCKED)
421
422int	if_handoff(struct ifqueue *ifq, struct mbuf *m, struct ifnet *ifp,
423	    int adjust);
424#define	IF_HANDOFF(ifq, m, ifp)			\
425	if_handoff((struct ifqueue *)ifq, m, ifp, 0)
426#define	IF_HANDOFF_ADJ(ifq, m, ifp, adj)	\
427	if_handoff((struct ifqueue *)ifq, m, ifp, adj)
428
429void	if_start(struct ifnet *);
430
431#define	IFQ_ENQUEUE(ifq, m, err)					\
432do {									\
433	IF_LOCK(ifq);							\
434	if (ALTQ_IS_ENABLED(ifq))					\
435		ALTQ_ENQUEUE(ifq, m, NULL, err);			\
436	else {								\
437		if (_IF_QFULL(ifq)) {					\
438			m_freem(m);					\
439			(err) = ENOBUFS;				\
440		} else {						\
441			_IF_ENQUEUE(ifq, m);				\
442			(err) = 0;					\
443		}							\
444	}								\
445	if (err)							\
446		(ifq)->ifq_drops++;					\
447	IF_UNLOCK(ifq);							\
448} while (0)
449
450#define	IFQ_DEQUEUE_NOLOCK(ifq, m)					\
451do {									\
452	if (TBR_IS_ENABLED(ifq))					\
453		(m) = tbr_dequeue_ptr(ifq, ALTDQ_REMOVE);		\
454	else if (ALTQ_IS_ENABLED(ifq))					\
455		ALTQ_DEQUEUE(ifq, m);					\
456	else								\
457		_IF_DEQUEUE(ifq, m);					\
458} while (0)
459
460#define	IFQ_DEQUEUE(ifq, m)						\
461do {									\
462	IF_LOCK(ifq);							\
463	IFQ_DEQUEUE_NOLOCK(ifq, m);					\
464	IF_UNLOCK(ifq);							\
465} while (0)
466
467#define	IFQ_POLL_NOLOCK(ifq, m)						\
468do {									\
469	if (TBR_IS_ENABLED(ifq))					\
470		(m) = tbr_dequeue_ptr(ifq, ALTDQ_POLL);			\
471	else if (ALTQ_IS_ENABLED(ifq))					\
472		ALTQ_POLL(ifq, m);					\
473	else								\
474		_IF_POLL(ifq, m);					\
475} while (0)
476
477#define	IFQ_POLL(ifq, m)						\
478do {									\
479	IF_LOCK(ifq);							\
480	IFQ_POLL_NOLOCK(ifq, m);					\
481	IF_UNLOCK(ifq);							\
482} while (0)
483
484#define	IFQ_PURGE_NOLOCK(ifq)						\
485do {									\
486	if (ALTQ_IS_ENABLED(ifq)) {					\
487		ALTQ_PURGE(ifq);					\
488	} else								\
489		_IF_DRAIN(ifq);						\
490} while (0)
491
492#define	IFQ_PURGE(ifq)							\
493do {									\
494	IF_LOCK(ifq);							\
495	IFQ_PURGE_NOLOCK(ifq);						\
496	IF_UNLOCK(ifq);							\
497} while (0)
498
499#define	IFQ_SET_READY(ifq)						\
500	do { ((ifq)->altq_flags |= ALTQF_READY); } while (0)
501
502#define	IFQ_LOCK(ifq)			IF_LOCK(ifq)
503#define	IFQ_UNLOCK(ifq)			IF_UNLOCK(ifq)
504#define	IFQ_LOCK_ASSERT(ifq)		IF_LOCK_ASSERT(ifq)
505#define	IFQ_IS_EMPTY(ifq)		((ifq)->ifq_len == 0)
506#define	IFQ_INC_LEN(ifq)		((ifq)->ifq_len++)
507#define	IFQ_DEC_LEN(ifq)		(--(ifq)->ifq_len)
508#define	IFQ_INC_DROPS(ifq)		((ifq)->ifq_drops++)
509#define	IFQ_SET_MAXLEN(ifq, len)	((ifq)->ifq_maxlen = (len))
510
511/*
512 * The IFF_DRV_OACTIVE test should really occur in the device driver, not in
513 * the handoff logic, as that flag is locked by the device driver.
514 */
515#define	IFQ_HANDOFF_ADJ(ifp, m, adj, err)				\
516do {									\
517	int len;							\
518	short mflags;							\
519									\
520	len = (m)->m_pkthdr.len;					\
521	mflags = (m)->m_flags;						\
522	IFQ_ENQUEUE(&(ifp)->if_snd, m, err);				\
523	if ((err) == 0) {						\
524		(ifp)->if_obytes += len + (adj);			\
525		if (mflags & M_MCAST)					\
526			(ifp)->if_omcasts++;				\
527		if (((ifp)->if_drv_flags & IFF_DRV_OACTIVE) == 0)	\
528			if_start(ifp);					\
529	}								\
530} while (0)
531
532#define	IFQ_HANDOFF(ifp, m, err)					\
533	IFQ_HANDOFF_ADJ(ifp, m, 0, err)
534
535#define	IFQ_DRV_DEQUEUE(ifq, m)						\
536do {									\
537	(m) = (ifq)->ifq_drv_head;					\
538	if (m) {							\
539		if (((ifq)->ifq_drv_head = (m)->m_nextpkt) == NULL)	\
540			(ifq)->ifq_drv_tail = NULL;			\
541		(m)->m_nextpkt = NULL;					\
542		(ifq)->ifq_drv_len--;					\
543	} else {							\
544		IFQ_LOCK(ifq);						\
545		IFQ_DEQUEUE_NOLOCK(ifq, m);				\
546		while ((ifq)->ifq_drv_len < (ifq)->ifq_drv_maxlen) {	\
547			struct mbuf *m0;				\
548			IFQ_DEQUEUE_NOLOCK(ifq, m0);			\
549			if (m0 == NULL)					\
550				break;					\
551			m0->m_nextpkt = NULL;				\
552			if ((ifq)->ifq_drv_tail == NULL)		\
553				(ifq)->ifq_drv_head = m0;		\
554			else						\
555				(ifq)->ifq_drv_tail->m_nextpkt = m0;	\
556			(ifq)->ifq_drv_tail = m0;			\
557			(ifq)->ifq_drv_len++;				\
558		}							\
559		IFQ_UNLOCK(ifq);					\
560	}								\
561} while (0)
562
563#define	IFQ_DRV_PREPEND(ifq, m)						\
564do {									\
565	(m)->m_nextpkt = (ifq)->ifq_drv_head;				\
566	if ((ifq)->ifq_drv_tail == NULL)				\
567		(ifq)->ifq_drv_tail = (m);				\
568	(ifq)->ifq_drv_head = (m);					\
569	(ifq)->ifq_drv_len++;						\
570} while (0)
571
572#define	IFQ_DRV_IS_EMPTY(ifq)						\
573	(((ifq)->ifq_drv_len == 0) && ((ifq)->ifq_len == 0))
574
575#define	IFQ_DRV_PURGE(ifq)						\
576do {									\
577	struct mbuf *m, *n = (ifq)->ifq_drv_head;			\
578	while((m = n) != NULL) {					\
579		n = m->m_nextpkt;					\
580		m_freem(m);						\
581	}								\
582	(ifq)->ifq_drv_head = (ifq)->ifq_drv_tail = NULL;		\
583	(ifq)->ifq_drv_len = 0;						\
584	IFQ_PURGE(ifq);							\
585} while (0)
586
587#ifdef _KERNEL
588static __inline void
589drbr_stats_update(struct ifnet *ifp, int len, int mflags)
590{
591#ifndef NO_SLOW_STATS
592	ifp->if_obytes += len;
593	if (mflags & M_MCAST)
594		ifp->if_omcasts++;
595#endif
596}
597
598static __inline int
599drbr_enqueue(struct ifnet *ifp, struct buf_ring *br, struct mbuf *m)
600{
601	int error = 0;
602	int len = m->m_pkthdr.len;
603	int mflags = m->m_flags;
604
605#ifdef ALTQ
606	if (ALTQ_IS_ENABLED(&ifp->if_snd)) {
607		IFQ_ENQUEUE(&ifp->if_snd, m, error);
608		return (error);
609	}
610#endif
611	if ((error = buf_ring_enqueue_bytes(br, m, len)) == ENOBUFS) {
612		br->br_drops++;
613		m_freem(m);
614	} else
615		drbr_stats_update(ifp, len, mflags);
616
617	return (error);
618}
619
620static __inline void
621drbr_flush(struct ifnet *ifp, struct buf_ring *br)
622{
623	struct mbuf *m;
624
625#ifdef ALTQ
626	if (ifp != NULL && ALTQ_IS_ENABLED(&ifp->if_snd))
627		IFQ_PURGE(&ifp->if_snd);
628#endif
629	while ((m = buf_ring_dequeue_sc(br)) != NULL)
630		m_freem(m);
631}
632
633static __inline void
634drbr_free(struct buf_ring *br, struct malloc_type *type)
635{
636
637	drbr_flush(NULL, br);
638	buf_ring_free(br, type);
639}
640
641static __inline struct mbuf *
642drbr_dequeue(struct ifnet *ifp, struct buf_ring *br)
643{
644#ifdef ALTQ
645	struct mbuf *m;
646
647	if (ALTQ_IS_ENABLED(&ifp->if_snd)) {
648		IFQ_DEQUEUE(&ifp->if_snd, m);
649		return (m);
650	}
651#endif
652	return (buf_ring_dequeue_sc(br));
653}
654
655static __inline struct mbuf *
656drbr_dequeue_cond(struct ifnet *ifp, struct buf_ring *br,
657    int (*func) (struct mbuf *, void *), void *arg)
658{
659	struct mbuf *m;
660#ifdef ALTQ
661	if (ALTQ_IS_ENABLED(&ifp->if_snd)) {
662		IFQ_LOCK(&ifp->if_snd);
663		IFQ_POLL_NOLOCK(&ifp->if_snd, m);
664		if (m != NULL && func(m, arg) == 0) {
665			IFQ_UNLOCK(&ifp->if_snd);
666			return (NULL);
667		}
668		IFQ_DEQUEUE_NOLOCK(&ifp->if_snd, m);
669		IFQ_UNLOCK(&ifp->if_snd);
670		return (m);
671	}
672#endif
673	m = buf_ring_peek(br);
674	if (m == NULL || func(m, arg) == 0)
675		return (NULL);
676
677	return (buf_ring_dequeue_sc(br));
678}
679
680static __inline int
681drbr_empty(struct ifnet *ifp, struct buf_ring *br)
682{
683#ifdef ALTQ
684	if (ALTQ_IS_ENABLED(&ifp->if_snd))
685		return (IFQ_IS_EMPTY(&ifp->if_snd));
686#endif
687	return (buf_ring_empty(br));
688}
689
690static __inline int
691drbr_needs_enqueue(struct ifnet *ifp, struct buf_ring *br)
692{
693#ifdef ALTQ
694	if (ALTQ_IS_ENABLED(&ifp->if_snd))
695		return (1);
696#endif
697	return (!buf_ring_empty(br));
698}
699
700static __inline int
701drbr_inuse(struct ifnet *ifp, struct buf_ring *br)
702{
703#ifdef ALTQ
704	if (ALTQ_IS_ENABLED(&ifp->if_snd))
705		return (ifp->if_snd.ifq_len);
706#endif
707	return (buf_ring_count(br));
708}
709#endif
710/*
711 * 72 was chosen below because it is the size of a TCP/IP
712 * header (40) + the minimum mss (32).
713 */
714#define	IF_MINMTU	72
715#define	IF_MAXMTU	65535
716
717#define	TOEDEV(ifp)	((ifp)->if_llsoftc)
718
719#endif /* _KERNEL */
720
721/*
722 * The ifaddr structure contains information about one address
723 * of an interface.  They are maintained by the different address families,
724 * are allocated and attached when an address is set, and are linked
725 * together so all addresses for an interface can be located.
726 *
727 * NOTE: a 'struct ifaddr' is always at the beginning of a larger
728 * chunk of malloc'ed memory, where we store the three addresses
729 * (ifa_addr, ifa_dstaddr and ifa_netmask) referenced here.
730 */
731struct ifaddr {
732	struct	sockaddr *ifa_addr;	/* address of interface */
733	struct	sockaddr *ifa_dstaddr;	/* other end of p-to-p link */
734#define	ifa_broadaddr	ifa_dstaddr	/* broadcast address interface */
735	struct	sockaddr *ifa_netmask;	/* used to determine subnet */
736	struct	if_data if_data;	/* not all members are meaningful */
737	struct	ifnet *ifa_ifp;		/* back-pointer to interface */
738	struct	carp_softc *ifa_carp;	/* pointer to CARP data */
739	TAILQ_ENTRY(ifaddr) ifa_link;	/* queue macro glue */
740	void	(*ifa_rtrequest)	/* check or clean routes (+ or -)'d */
741		(int, struct rtentry *, struct rt_addrinfo *);
742	u_short	ifa_flags;		/* mostly rt_flags for cloning */
743	u_int	ifa_refcnt;		/* references to this structure */
744	int	ifa_metric;		/* cost of going out this interface */
745	int (*ifa_claim_addr)		/* check if an addr goes to this if */
746		(struct ifaddr *, struct sockaddr *);
747	struct mtx ifa_mtx;
748};
749#define	IFA_ROUTE	RTF_UP		/* route installed */
750#define IFA_RTSELF	RTF_HOST	/* loopback route to self installed */
751
752/* for compatibility with other BSDs */
753#define	ifa_list	ifa_link
754
755#ifdef _KERNEL
756#define	IFA_LOCK(ifa)		mtx_lock(&(ifa)->ifa_mtx)
757#define	IFA_UNLOCK(ifa)		mtx_unlock(&(ifa)->ifa_mtx)
758
759void	ifa_free(struct ifaddr *ifa);
760void	ifa_init(struct ifaddr *ifa);
761void	ifa_ref(struct ifaddr *ifa);
762#endif
763
764/*
765 * Multicast address structure.  This is analogous to the ifaddr
766 * structure except that it keeps track of multicast addresses.
767 */
768struct ifmultiaddr {
769	TAILQ_ENTRY(ifmultiaddr) ifma_link; /* queue macro glue */
770	struct	sockaddr *ifma_addr; 	/* address this membership is for */
771	struct	sockaddr *ifma_lladdr;	/* link-layer translation, if any */
772	struct	ifnet *ifma_ifp;	/* back-pointer to interface */
773	u_int	ifma_refcount;		/* reference count */
774	void	*ifma_protospec;	/* protocol-specific state, if any */
775	struct	ifmultiaddr *ifma_llifma; /* pointer to ifma for ifma_lladdr */
776};
777
778#ifdef _KERNEL
779
780extern	struct rwlock ifnet_rwlock;
781extern	struct sx ifnet_sxlock;
782
783#define	IFNET_LOCK_INIT() do {						\
784	rw_init_flags(&ifnet_rwlock, "ifnet_rw",  RW_RECURSE);		\
785	sx_init_flags(&ifnet_sxlock, "ifnet_sx",  SX_RECURSE);		\
786} while(0)
787
788#define	IFNET_WLOCK() do {						\
789	sx_xlock(&ifnet_sxlock);					\
790	rw_wlock(&ifnet_rwlock);					\
791} while (0)
792
793#define	IFNET_WUNLOCK() do {						\
794	rw_wunlock(&ifnet_rwlock);					\
795	sx_xunlock(&ifnet_sxlock);					\
796} while (0)
797
798/*
799 * To assert the ifnet lock, you must know not only whether it's for read or
800 * write, but also whether it was acquired with sleep support or not.
801 */
802#define	IFNET_RLOCK_ASSERT()		sx_assert(&ifnet_sxlock, SA_SLOCKED)
803#define	IFNET_RLOCK_NOSLEEP_ASSERT()	rw_assert(&ifnet_rwlock, RA_RLOCKED)
804#define	IFNET_WLOCK_ASSERT() do {					\
805	sx_assert(&ifnet_sxlock, SA_XLOCKED);				\
806	rw_assert(&ifnet_rwlock, RA_WLOCKED);				\
807} while (0)
808
809#define	IFNET_RLOCK()		sx_slock(&ifnet_sxlock)
810#define	IFNET_RLOCK_NOSLEEP()	rw_rlock(&ifnet_rwlock)
811#define	IFNET_RUNLOCK()		sx_sunlock(&ifnet_sxlock)
812#define	IFNET_RUNLOCK_NOSLEEP()	rw_runlock(&ifnet_rwlock)
813
814/*
815 * Look up an ifnet given its index; the _ref variant also acquires a
816 * reference that must be freed using if_rele().  It is almost always a bug
817 * to call ifnet_byindex() instead if ifnet_byindex_ref().
818 */
819struct ifnet	*ifnet_byindex(u_short idx);
820struct ifnet	*ifnet_byindex_locked(u_short idx);
821struct ifnet	*ifnet_byindex_ref(u_short idx);
822
823/*
824 * Given the index, ifaddr_byindex() returns the one and only
825 * link-level ifaddr for the interface. You are not supposed to use
826 * it to traverse the list of addresses associated to the interface.
827 */
828struct ifaddr	*ifaddr_byindex(u_short idx);
829
830VNET_DECLARE(struct ifnethead, ifnet);
831VNET_DECLARE(struct ifgrouphead, ifg_head);
832VNET_DECLARE(int, if_index);
833VNET_DECLARE(struct ifnet *, loif);	/* first loopback interface */
834VNET_DECLARE(int, useloopback);
835
836#define	V_ifnet		VNET(ifnet)
837#define	V_ifg_head	VNET(ifg_head)
838#define	V_if_index	VNET(if_index)
839#define	V_loif		VNET(loif)
840#define	V_useloopback	VNET(useloopback)
841
842extern	int ifqmaxlen;
843
844int	if_addgroup(struct ifnet *, const char *);
845int	if_delgroup(struct ifnet *, const char *);
846int	if_addmulti(struct ifnet *, struct sockaddr *, struct ifmultiaddr **);
847int	if_allmulti(struct ifnet *, int);
848struct	ifnet* if_alloc(u_char);
849void	if_attach(struct ifnet *);
850void	if_dead(struct ifnet *);
851int	if_delmulti(struct ifnet *, struct sockaddr *);
852void	if_delmulti_ifma(struct ifmultiaddr *);
853void	if_detach(struct ifnet *);
854void	if_vmove(struct ifnet *, struct vnet *);
855void	if_purgeaddrs(struct ifnet *);
856void	if_delallmulti(struct ifnet *);
857void	if_down(struct ifnet *);
858struct ifmultiaddr *
859	if_findmulti(struct ifnet *, struct sockaddr *);
860void	if_free(struct ifnet *);
861void	if_initname(struct ifnet *, const char *, int);
862void	if_link_state_change(struct ifnet *, int);
863int	if_printf(struct ifnet *, const char *, ...) __printflike(2, 3);
864void	if_qflush(struct ifnet *);
865void	if_ref(struct ifnet *);
866void	if_rele(struct ifnet *);
867int	if_setlladdr(struct ifnet *, const u_char *, int);
868void	if_up(struct ifnet *);
869int	ifioctl(struct socket *, u_long, caddr_t, struct thread *);
870int	ifpromisc(struct ifnet *, int);
871struct	ifnet *ifunit(const char *);
872struct	ifnet *ifunit_ref(const char *);
873
874void	ifq_init(struct ifaltq *, struct ifnet *ifp);
875void	ifq_delete(struct ifaltq *);
876
877int	ifa_add_loopback_route(struct ifaddr *, struct sockaddr *);
878int	ifa_del_loopback_route(struct ifaddr *, struct sockaddr *);
879
880struct	ifaddr *ifa_ifwithaddr(struct sockaddr *);
881int		ifa_ifwithaddr_check(struct sockaddr *);
882struct	ifaddr *ifa_ifwithbroadaddr(struct sockaddr *);
883struct	ifaddr *ifa_ifwithdstaddr(struct sockaddr *);
884struct	ifaddr *ifa_ifwithnet(struct sockaddr *, int);
885struct	ifaddr *ifa_ifwithroute(int, struct sockaddr *, struct sockaddr *);
886struct	ifaddr *ifa_ifwithroute_fib(int, struct sockaddr *, struct sockaddr *, u_int);
887
888struct	ifaddr *ifaof_ifpforaddr(struct sockaddr *, struct ifnet *);
889
890int	if_simloop(struct ifnet *ifp, struct mbuf *m, int af, int hlen);
891
892typedef	void *if_com_alloc_t(u_char type, struct ifnet *ifp);
893typedef	void if_com_free_t(void *com, u_char type);
894void	if_register_com_alloc(u_char type, if_com_alloc_t *a, if_com_free_t *f);
895void	if_deregister_com_alloc(u_char type);
896
897#define IF_LLADDR(ifp)							\
898    LLADDR((struct sockaddr_dl *)((ifp)->if_addr->ifa_addr))
899
900#ifdef DEVICE_POLLING
901enum poll_cmd {	POLL_ONLY, POLL_AND_CHECK_STATUS };
902
903typedef	int poll_handler_t(struct ifnet *ifp, enum poll_cmd cmd, int count);
904int    ether_poll_register(poll_handler_t *h, struct ifnet *ifp);
905int    ether_poll_deregister(struct ifnet *ifp);
906#endif /* DEVICE_POLLING */
907
908#endif /* _KERNEL */
909
910#endif /* !_NET_IF_VAR_H_ */
911