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