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