xref: /freebsd/sys/net/ifq.h (revision eac7052fdebb90caf2f653e06187bdbca837b9c7)
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  */
57 struct	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 
155 int	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 
162 void	if_start(struct ifnet *);
163 
164 #define	IFQ_ENQUEUE(ifq, m, err)					\
165 do {									\
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)					\
182 do {									\
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)						\
192 do {									\
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)						\
199 do {									\
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)						\
209 do {									\
210 	IF_LOCK(ifq);							\
211 	IFQ_POLL_NOLOCK(ifq, m);					\
212 	IF_UNLOCK(ifq);							\
213 } while (0)
214 
215 #define	IFQ_PURGE_NOLOCK(ifq)						\
216 do {									\
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)							\
224 do {									\
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)				\
246 do {									\
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)						\
267 do {									\
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)						\
295 do {									\
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)						\
307 do {									\
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 
318 static __inline int
319 drbr_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 
338 static __inline void
339 drbr_putback(struct ifnet *ifp, struct buf_ring *br, struct mbuf *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, new);
352 		return;
353 	}
354 #endif
355 	buf_ring_putback_sc(br, new);
356 }
357 
358 static __inline struct mbuf *
359 drbr_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(buf_ring_peek_clear_sc(br));
375 }
376 
377 static __inline void
378 drbr_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 = buf_ring_dequeue_sc(br)) != NULL)
387 		m_freem(m);
388 }
389 
390 static __inline void
391 drbr_free(struct buf_ring *br, struct malloc_type *type)
392 {
393 
394 	drbr_flush(NULL, br);
395 	buf_ring_free(br, type);
396 }
397 
398 static __inline struct mbuf *
399 drbr_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 (buf_ring_dequeue_sc(br));
410 }
411 
412 static __inline void
413 drbr_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 
423 static __inline struct mbuf *
424 drbr_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 = buf_ring_peek(br);
442 	if (m == NULL || func(m, arg) == 0)
443 		return (NULL);
444 
445 	return (buf_ring_dequeue_sc(br));
446 }
447 
448 static __inline int
449 drbr_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 
458 static __inline int
459 drbr_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 
468 static __inline int
469 drbr_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 
478 extern	int ifqmaxlen;
479 
480 void	if_qflush(struct ifnet *);
481 void	ifq_init(struct ifaltq *, struct ifnet *ifp);
482 void	ifq_delete(struct ifaltq *);
483 
484 #endif /* _KERNEL */
485 #endif /* !_NET_IFQ_H_ */
486