1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1982, 1986, 1989, 1993
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 *    may be used to endorse or promote products derived from this software
17 *    without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 *	From: @(#)if.h	8.1 (Berkeley) 6/10/93
32 * $FreeBSD$
33 */
34
35#ifndef	_NET_IFQ_H_
36#define	_NET_IFQ_H_
37
38#ifdef _KERNEL
39#include <sys/mbuf.h>		/* ifqueue only? */
40#include <sys/buf_ring.h>
41#include <net/vnet.h>
42#endif /* _KERNEL */
43#include <sys/lock.h>		/* XXX */
44#include <sys/mutex.h>		/* struct ifqueue */
45
46/*
47 * Couple of ugly extra definitions that are required since ifq.h
48 * is splitted from if_var.h.
49 */
50#define	IF_DUNIT_NONE	-1
51
52#include <net/altq/if_altq.h>
53
54/*
55 * Structure defining a queue for a network interface.
56 */
57struct	ifqueue {
58	struct	mbuf *ifq_head;
59	struct	mbuf *ifq_tail;
60	int	ifq_len;
61	int	ifq_maxlen;
62	struct	mtx ifq_mtx;
63};
64
65#ifdef _KERNEL
66/*
67 * Output queues (ifp->if_snd) and slow device input queues (*ifp->if_slowq)
68 * are queues of messages stored on ifqueue structures
69 * (defined above).  Entries are added to and deleted from these structures
70 * by these macros.
71 */
72#define IF_LOCK(ifq)		mtx_lock(&(ifq)->ifq_mtx)
73#define IF_UNLOCK(ifq)		mtx_unlock(&(ifq)->ifq_mtx)
74#define	IF_LOCK_ASSERT(ifq)	mtx_assert(&(ifq)->ifq_mtx, MA_OWNED)
75#define	_IF_QFULL(ifq)		((ifq)->ifq_len >= (ifq)->ifq_maxlen)
76#define	_IF_QLEN(ifq)		((ifq)->ifq_len)
77
78#define	_IF_ENQUEUE(ifq, m) do { 				\
79	(m)->m_nextpkt = NULL;					\
80	if ((ifq)->ifq_tail == NULL) 				\
81		(ifq)->ifq_head = m; 				\
82	else 							\
83		(ifq)->ifq_tail->m_nextpkt = m; 		\
84	(ifq)->ifq_tail = m; 					\
85	(ifq)->ifq_len++; 					\
86} while (0)
87
88#define IF_ENQUEUE(ifq, m) do {					\
89	IF_LOCK(ifq); 						\
90	_IF_ENQUEUE(ifq, m); 					\
91	IF_UNLOCK(ifq); 					\
92} while (0)
93
94#define	_IF_PREPEND(ifq, m) do {				\
95	(m)->m_nextpkt = (ifq)->ifq_head; 			\
96	if ((ifq)->ifq_tail == NULL) 				\
97		(ifq)->ifq_tail = (m); 				\
98	(ifq)->ifq_head = (m); 					\
99	(ifq)->ifq_len++; 					\
100} while (0)
101
102#define IF_PREPEND(ifq, m) do {		 			\
103	IF_LOCK(ifq); 						\
104	_IF_PREPEND(ifq, m); 					\
105	IF_UNLOCK(ifq); 					\
106} while (0)
107
108#define	_IF_DEQUEUE(ifq, m) do { 				\
109	(m) = (ifq)->ifq_head; 					\
110	if (m) { 						\
111		if (((ifq)->ifq_head = (m)->m_nextpkt) == NULL)	\
112			(ifq)->ifq_tail = NULL; 		\
113		(m)->m_nextpkt = NULL; 				\
114		(ifq)->ifq_len--; 				\
115	} 							\
116} while (0)
117
118#define IF_DEQUEUE(ifq, m) do { 				\
119	IF_LOCK(ifq); 						\
120	_IF_DEQUEUE(ifq, m); 					\
121	IF_UNLOCK(ifq); 					\
122} while (0)
123
124#define	_IF_DEQUEUE_ALL(ifq, m) do {				\
125	(m) = (ifq)->ifq_head;					\
126	(ifq)->ifq_head = (ifq)->ifq_tail = NULL;		\
127	(ifq)->ifq_len = 0;					\
128} while (0)
129
130#define	IF_DEQUEUE_ALL(ifq, m) do {				\
131	IF_LOCK(ifq); 						\
132	_IF_DEQUEUE_ALL(ifq, m);				\
133	IF_UNLOCK(ifq); 					\
134} while (0)
135
136#define	_IF_POLL(ifq, m)	((m) = (ifq)->ifq_head)
137#define	IF_POLL(ifq, m)		_IF_POLL(ifq, m)
138
139#define _IF_DRAIN(ifq) do { 					\
140	struct mbuf *m; 					\
141	for (;;) { 						\
142		_IF_DEQUEUE(ifq, m); 				\
143		if (m == NULL) 					\
144			break; 					\
145		m_freem(m); 					\
146	} 							\
147} while (0)
148
149#define IF_DRAIN(ifq) do {					\
150	IF_LOCK(ifq);						\
151	_IF_DRAIN(ifq);						\
152	IF_UNLOCK(ifq);						\
153} while(0)
154
155int	if_handoff(struct ifqueue *ifq, struct mbuf *m, struct ifnet *ifp,
156	    int adjust);
157#define	IF_HANDOFF(ifq, m, ifp)			\
158	if_handoff((struct ifqueue *)ifq, m, ifp, 0)
159#define	IF_HANDOFF_ADJ(ifq, m, ifp, adj)	\
160	if_handoff((struct ifqueue *)ifq, m, ifp, adj)
161
162void	if_start(struct ifnet *);
163
164#define	IFQ_ENQUEUE(ifq, m, err)					\
165do {									\
166	IF_LOCK(ifq);							\
167	if (ALTQ_IS_ENABLED(ifq))					\
168		ALTQ_ENQUEUE(ifq, m, NULL, err);			\
169	else {								\
170		if (_IF_QFULL(ifq)) {					\
171			m_freem(m);					\
172			(err) = ENOBUFS;				\
173		} else {						\
174			_IF_ENQUEUE(ifq, m);				\
175			(err) = 0;					\
176		}							\
177	}								\
178	IF_UNLOCK(ifq);							\
179} while (0)
180
181#define	IFQ_DEQUEUE_NOLOCK(ifq, m)					\
182do {									\
183	if (TBR_IS_ENABLED(ifq))					\
184		(m) = tbr_dequeue_ptr(ifq, ALTDQ_REMOVE);		\
185	else if (ALTQ_IS_ENABLED(ifq))					\
186		ALTQ_DEQUEUE(ifq, m);					\
187	else								\
188		_IF_DEQUEUE(ifq, m);					\
189} while (0)
190
191#define	IFQ_DEQUEUE(ifq, m)						\
192do {									\
193	IF_LOCK(ifq);							\
194	IFQ_DEQUEUE_NOLOCK(ifq, m);					\
195	IF_UNLOCK(ifq);							\
196} while (0)
197
198#define	IFQ_POLL_NOLOCK(ifq, m)						\
199do {									\
200	if (TBR_IS_ENABLED(ifq))					\
201		(m) = tbr_dequeue_ptr(ifq, ALTDQ_POLL);			\
202	else if (ALTQ_IS_ENABLED(ifq))					\
203		ALTQ_POLL(ifq, m);					\
204	else								\
205		_IF_POLL(ifq, m);					\
206} while (0)
207
208#define	IFQ_POLL(ifq, m)						\
209do {									\
210	IF_LOCK(ifq);							\
211	IFQ_POLL_NOLOCK(ifq, m);					\
212	IF_UNLOCK(ifq);							\
213} while (0)
214
215#define	IFQ_PURGE_NOLOCK(ifq)						\
216do {									\
217	if (ALTQ_IS_ENABLED(ifq)) {					\
218		ALTQ_PURGE(ifq);					\
219	} else								\
220		_IF_DRAIN(ifq);						\
221} while (0)
222
223#define	IFQ_PURGE(ifq)							\
224do {									\
225	IF_LOCK(ifq);							\
226	IFQ_PURGE_NOLOCK(ifq);						\
227	IF_UNLOCK(ifq);							\
228} while (0)
229
230#define	IFQ_SET_READY(ifq)						\
231	do { ((ifq)->altq_flags |= ALTQF_READY); } while (0)
232
233#define	IFQ_LOCK(ifq)			IF_LOCK(ifq)
234#define	IFQ_UNLOCK(ifq)			IF_UNLOCK(ifq)
235#define	IFQ_LOCK_ASSERT(ifq)		IF_LOCK_ASSERT(ifq)
236#define	IFQ_IS_EMPTY(ifq)		((ifq)->ifq_len == 0)
237#define	IFQ_INC_LEN(ifq)		((ifq)->ifq_len++)
238#define	IFQ_DEC_LEN(ifq)		(--(ifq)->ifq_len)
239#define	IFQ_SET_MAXLEN(ifq, len)	((ifq)->ifq_maxlen = (len))
240
241/*
242 * The IFF_DRV_OACTIVE test should really occur in the device driver, not in
243 * the handoff logic, as that flag is locked by the device driver.
244 */
245#define	IFQ_HANDOFF_ADJ(ifp, m, adj, err)				\
246do {									\
247	int len;							\
248	short mflags;							\
249									\
250	len = (m)->m_pkthdr.len;					\
251	mflags = (m)->m_flags;						\
252	IFQ_ENQUEUE(&(ifp)->if_snd, m, err);				\
253	if ((err) == 0) {						\
254		if_inc_counter((ifp), IFCOUNTER_OBYTES, len + (adj));	\
255		if (mflags & M_MCAST)					\
256			if_inc_counter((ifp), IFCOUNTER_OMCASTS, 1);	\
257		if (((ifp)->if_drv_flags & IFF_DRV_OACTIVE) == 0)	\
258			if_start(ifp);					\
259	} else								\
260		if_inc_counter((ifp), IFCOUNTER_OQDROPS, 1);		\
261} while (0)
262
263#define	IFQ_HANDOFF(ifp, m, err)					\
264	IFQ_HANDOFF_ADJ(ifp, m, 0, err)
265
266#define	IFQ_DRV_DEQUEUE(ifq, m)						\
267do {									\
268	(m) = (ifq)->ifq_drv_head;					\
269	if (m) {							\
270		if (((ifq)->ifq_drv_head = (m)->m_nextpkt) == NULL)	\
271			(ifq)->ifq_drv_tail = NULL;			\
272		(m)->m_nextpkt = NULL;					\
273		(ifq)->ifq_drv_len--;					\
274	} else {							\
275		IFQ_LOCK(ifq);						\
276		IFQ_DEQUEUE_NOLOCK(ifq, m);				\
277		while ((ifq)->ifq_drv_len < (ifq)->ifq_drv_maxlen) {	\
278			struct mbuf *m0;				\
279			IFQ_DEQUEUE_NOLOCK(ifq, m0);			\
280			if (m0 == NULL)					\
281				break;					\
282			m0->m_nextpkt = NULL;				\
283			if ((ifq)->ifq_drv_tail == NULL)		\
284				(ifq)->ifq_drv_head = m0;		\
285			else						\
286				(ifq)->ifq_drv_tail->m_nextpkt = m0;	\
287			(ifq)->ifq_drv_tail = m0;			\
288			(ifq)->ifq_drv_len++;				\
289		}							\
290		IFQ_UNLOCK(ifq);					\
291	}								\
292} while (0)
293
294#define	IFQ_DRV_PREPEND(ifq, m)						\
295do {									\
296	(m)->m_nextpkt = (ifq)->ifq_drv_head;				\
297	if ((ifq)->ifq_drv_tail == NULL)				\
298		(ifq)->ifq_drv_tail = (m);				\
299	(ifq)->ifq_drv_head = (m);					\
300	(ifq)->ifq_drv_len++;						\
301} while (0)
302
303#define	IFQ_DRV_IS_EMPTY(ifq)						\
304	(((ifq)->ifq_drv_len == 0) && ((ifq)->ifq_len == 0))
305
306#define	IFQ_DRV_PURGE(ifq)						\
307do {									\
308	struct mbuf *m, *n = (ifq)->ifq_drv_head;			\
309	while((m = n) != NULL) {					\
310		n = m->m_nextpkt;					\
311		m_freem(m);						\
312	}								\
313	(ifq)->ifq_drv_head = (ifq)->ifq_drv_tail = NULL;		\
314	(ifq)->ifq_drv_len = 0;						\
315	IFQ_PURGE(ifq);							\
316} while (0)
317
318static __inline int
319drbr_enqueue(struct ifnet *ifp, struct buf_ring *br, struct mbuf *m)
320{
321	int error = 0;
322
323#ifdef ALTQ
324	if (ALTQ_IS_ENABLED(&ifp->if_snd)) {
325		IFQ_ENQUEUE(&ifp->if_snd, m, error);
326		if (error)
327			if_inc_counter((ifp), IFCOUNTER_OQDROPS, 1);
328		return (error);
329	}
330#endif
331	error = buf_ring_enqueue(br, m);
332	if (error)
333		m_freem(m);
334
335	return (error);
336}
337
338static __inline void
339drbr_putback(struct ifnet *ifp, struct buf_ring *br, struct mbuf *m_new)
340{
341	/*
342	 * The top of the list needs to be swapped
343	 * for this one.
344	 */
345#ifdef ALTQ
346	if (ifp != NULL && ALTQ_IS_ENABLED(&ifp->if_snd)) {
347		/*
348		 * Peek in altq case dequeued it
349		 * so put it back.
350		 */
351		IFQ_DRV_PREPEND(&ifp->if_snd, m_new);
352		return;
353	}
354#endif
355	buf_ring_putback_sc(br, m_new);
356}
357
358static __inline struct mbuf *
359drbr_peek(struct ifnet *ifp, struct buf_ring *br)
360{
361#ifdef ALTQ
362	struct mbuf *m;
363	if (ifp != NULL && ALTQ_IS_ENABLED(&ifp->if_snd)) {
364		/*
365		 * Pull it off like a dequeue
366		 * since drbr_advance() does nothing
367		 * for altq and drbr_putback() will
368		 * use the old prepend function.
369		 */
370		IFQ_DEQUEUE(&ifp->if_snd, m);
371		return (m);
372	}
373#endif
374	return ((struct mbuf *)buf_ring_peek_clear_sc(br));
375}
376
377static __inline void
378drbr_flush(struct ifnet *ifp, struct buf_ring *br)
379{
380	struct mbuf *m;
381
382#ifdef ALTQ
383	if (ifp != NULL && ALTQ_IS_ENABLED(&ifp->if_snd))
384		IFQ_PURGE(&ifp->if_snd);
385#endif
386	while ((m = (struct mbuf *)buf_ring_dequeue_sc(br)) != NULL)
387		m_freem(m);
388}
389
390static __inline void
391drbr_free(struct buf_ring *br, struct malloc_type *type)
392{
393
394	drbr_flush(NULL, br);
395	buf_ring_free(br, type);
396}
397
398static __inline struct mbuf *
399drbr_dequeue(struct ifnet *ifp, struct buf_ring *br)
400{
401#ifdef ALTQ
402	struct mbuf *m;
403
404	if (ifp != NULL && ALTQ_IS_ENABLED(&ifp->if_snd)) {
405		IFQ_DEQUEUE(&ifp->if_snd, m);
406		return (m);
407	}
408#endif
409	return ((struct mbuf *)buf_ring_dequeue_sc(br));
410}
411
412static __inline void
413drbr_advance(struct ifnet *ifp, struct buf_ring *br)
414{
415#ifdef ALTQ
416	/* Nothing to do here since peek dequeues in altq case */
417	if (ifp != NULL && ALTQ_IS_ENABLED(&ifp->if_snd))
418		return;
419#endif
420	return (buf_ring_advance_sc(br));
421}
422
423static __inline struct mbuf *
424drbr_dequeue_cond(struct ifnet *ifp, struct buf_ring *br,
425    int (*func) (struct mbuf *, void *), void *arg)
426{
427	struct mbuf *m;
428#ifdef ALTQ
429	if (ALTQ_IS_ENABLED(&ifp->if_snd)) {
430		IFQ_LOCK(&ifp->if_snd);
431		IFQ_POLL_NOLOCK(&ifp->if_snd, m);
432		if (m != NULL && func(m, arg) == 0) {
433			IFQ_UNLOCK(&ifp->if_snd);
434			return (NULL);
435		}
436		IFQ_DEQUEUE_NOLOCK(&ifp->if_snd, m);
437		IFQ_UNLOCK(&ifp->if_snd);
438		return (m);
439	}
440#endif
441	m = (struct mbuf *)buf_ring_peek(br);
442	if (m == NULL || func(m, arg) == 0)
443		return (NULL);
444
445	return ((struct mbuf *)buf_ring_dequeue_sc(br));
446}
447
448static __inline int
449drbr_empty(struct ifnet *ifp, struct buf_ring *br)
450{
451#ifdef ALTQ
452	if (ALTQ_IS_ENABLED(&ifp->if_snd))
453		return (IFQ_IS_EMPTY(&ifp->if_snd));
454#endif
455	return (buf_ring_empty(br));
456}
457
458static __inline int
459drbr_needs_enqueue(struct ifnet *ifp, struct buf_ring *br)
460{
461#ifdef ALTQ
462	if (ALTQ_IS_ENABLED(&ifp->if_snd))
463		return (1);
464#endif
465	return (!buf_ring_empty(br));
466}
467
468static __inline int
469drbr_inuse(struct ifnet *ifp, struct buf_ring *br)
470{
471#ifdef ALTQ
472	if (ALTQ_IS_ENABLED(&ifp->if_snd))
473		return (ifp->if_snd.ifq_len);
474#endif
475	return (buf_ring_count(br));
476}
477
478extern	int ifqmaxlen;
479
480void	if_qflush(struct ifnet *);
481void	ifq_init(struct ifaltq *, struct ifnet *ifp);
482void	ifq_delete(struct ifaltq *);
483
484#endif /* _KERNEL */
485#endif /* !_NET_IFQ_H_ */
486