cc3c519d7f48785a2f7e00e63de1e3ac09757dad
[dragonfly.git] / sys / net / ifq_var.h
1 /*-
2  * Copyright (c) 2005 The DragonFly Project.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
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
12  *    the documentation and/or other materials provided with the
13  *    distribution.
14  * 3. Neither the name of The DragonFly Project nor the names of its
15  *    contributors may be used to endorse or promote products derived
16  *    from this software without specific, prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
22  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
24  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
26  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
27  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
28  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  */
31
32 #ifndef _NET_IFQ_VAR_H_
33 #define _NET_IFQ_VAR_H_
34
35 #ifndef _KERNEL
36
37 #error "This file should not be included by userland programs."
38
39 #else
40
41 #ifndef _SYS_SYSTM_H_
42 #include <sys/systm.h>
43 #endif
44 #ifndef _SYS_THREAD2_H_
45 #include <sys/thread2.h>
46 #endif
47 #ifndef _SYS_SERIALIZE_H_
48 #include <sys/serialize.h>
49 #endif
50 #ifndef _SYS_MBUF_H_
51 #include <sys/mbuf.h>
52 #endif
53 #ifndef _NET_IF_VAR_H_
54 #include <net/if_var.h>
55 #endif
56 #ifndef _NET_ALTQ_IF_ALTQ_H_
57 #include <net/altq/if_altq.h>
58 #endif
59
60 #define ASSERT_ALTQ_SQ_DEFAULT(ifp, ifsq) \
61         KASSERT(ifsq_get_ifp((ifsq)) == (ifp) && \
62             ifsq_get_index((ifsq)) == ALTQ_SUBQ_INDEX_DEFAULT, \
63             ("not ifp's default subqueue"));
64
65 struct ifaltq;
66 struct ifaltq_subque;
67
68 typedef void    (*ifsq_watchdog_t)(struct ifaltq_subque *);
69
70 struct ifsubq_watchdog {
71         struct callout  wd_callout;
72         int             wd_timer;
73         struct ifaltq_subque *wd_subq;
74         ifsq_watchdog_t wd_watchdog;
75 };
76
77 /*
78  * Support for "classic" ALTQ interfaces.
79  */
80 int             ifsq_classic_enqueue(struct ifaltq_subque *, struct mbuf *,
81                     struct altq_pktattr *);
82 struct mbuf     *ifsq_classic_dequeue(struct ifaltq_subque *, struct mbuf *,
83                     int);
84 int             ifsq_classic_request(struct ifaltq_subque *, int, void *);
85 void            ifq_set_classic(struct ifaltq *);
86
87 void            ifq_set_maxlen(struct ifaltq *, int);
88 void            ifq_set_methods(struct ifaltq *, altq_mapsubq_t,
89                     ifsq_enqueue_t, ifsq_dequeue_t, ifsq_request_t);
90 int             ifq_mapsubq_default(struct ifaltq *, int);
91
92 void            ifsq_devstart(struct ifaltq_subque *ifsq);
93 void            ifsq_devstart_sched(struct ifaltq_subque *ifsq);
94
95 void            ifsq_watchdog_init(struct ifsubq_watchdog *,
96                     struct ifaltq_subque *, ifsq_watchdog_t);
97 void            ifsq_watchdog_start(struct ifsubq_watchdog *);
98 void            ifsq_watchdog_stop(struct ifsubq_watchdog *);
99
100 /*
101  * Dispatch a packet to an interface.
102  */
103 int             ifq_dispatch(struct ifnet *, struct mbuf *,
104                     struct altq_pktattr *);
105
106 #ifdef ALTQ
107
108 static __inline int
109 ifq_is_enabled(struct ifaltq *_ifq)
110 {
111         return(_ifq->altq_flags & ALTQF_ENABLED);
112 }
113
114 static __inline int
115 ifq_is_attached(struct ifaltq *_ifq)
116 {
117         return(_ifq->altq_disc != NULL);
118 }
119
120 #else   /* !ALTQ */
121
122 static __inline int
123 ifq_is_enabled(struct ifaltq *_ifq)
124 {
125         return(0);
126 }
127
128 static __inline int
129 ifq_is_attached(struct ifaltq *_ifq)
130 {
131         return(0);
132 }
133
134 #endif  /* ALTQ */
135
136 static __inline int
137 ifq_is_ready(struct ifaltq *_ifq)
138 {
139         return(_ifq->altq_flags & ALTQF_READY);
140 }
141
142 static __inline void
143 ifq_set_ready(struct ifaltq *_ifq)
144 {
145         _ifq->altq_flags |= ALTQF_READY;
146 }
147
148 /*
149  * ALTQ lock must be held
150  */
151 static __inline int
152 ifsq_enqueue_locked(struct ifaltq_subque *_ifsq, struct mbuf *_m,
153     struct altq_pktattr *_pa)
154 {
155 #ifdef ALTQ
156         if (!ifq_is_enabled(_ifsq->ifsq_altq))
157                 return ifsq_classic_enqueue(_ifsq, _m, _pa);
158         else
159 #endif
160         return _ifsq->ifsq_enqueue(_ifsq, _m, _pa);
161 }
162
163 static __inline int
164 ifsq_enqueue(struct ifaltq_subque *_ifsq, struct mbuf *_m,
165     struct altq_pktattr *_pa)
166 {
167         int _error;
168
169         ALTQ_SQ_LOCK(_ifsq);
170         _error = ifsq_enqueue_locked(_ifsq, _m, _pa);
171         ALTQ_SQ_UNLOCK(_ifsq);
172         return _error;
173 }
174
175 static __inline struct mbuf *
176 ifsq_dequeue(struct ifaltq_subque *_ifsq, struct mbuf *_mpolled)
177 {
178         struct mbuf *_m;
179
180         ALTQ_SQ_LOCK(_ifsq);
181         if (_ifsq->ifsq_prepended != NULL) {
182                 _m = _ifsq->ifsq_prepended;
183                 _ifsq->ifsq_prepended = NULL;
184                 KKASSERT(_ifsq->ifq_len > 0);
185                 _ifsq->ifq_len--;
186                 ALTQ_SQ_UNLOCK(_ifsq);
187                 return _m;
188         }
189
190 #ifdef ALTQ
191         if (_ifsq->ifsq_altq->altq_tbr != NULL)
192                 _m = tbr_dequeue(_ifsq, _mpolled, ALTDQ_REMOVE);
193         else if (!ifq_is_enabled(_ifsq->ifsq_altq))
194                 _m = ifsq_classic_dequeue(_ifsq, _mpolled, ALTDQ_REMOVE);
195         else
196 #endif
197         _m = _ifsq->ifsq_dequeue(_ifsq, _mpolled, ALTDQ_REMOVE);
198         ALTQ_SQ_UNLOCK(_ifsq);
199         return _m;
200 }
201
202 /*
203  * ALTQ lock must be held
204  */
205 static __inline struct mbuf *
206 ifsq_poll_locked(struct ifaltq_subque *_ifsq)
207 {
208         if (_ifsq->ifsq_prepended != NULL)
209                 return _ifsq->ifsq_prepended;
210
211 #ifdef ALTQ
212         if (_ifsq->ifsq_altq->altq_tbr != NULL)
213                 return tbr_dequeue(_ifsq, NULL, ALTDQ_POLL);
214         else if (!ifq_is_enabled(_ifsq->ifsq_altq))
215                 return ifsq_classic_dequeue(_ifsq, NULL, ALTDQ_POLL);
216         else
217 #endif
218         return _ifsq->ifsq_dequeue(_ifsq, NULL, ALTDQ_POLL);
219 }
220
221 static __inline struct mbuf *
222 ifsq_poll(struct ifaltq_subque *_ifsq)
223 {
224         struct mbuf *_m;
225
226         ALTQ_SQ_LOCK(_ifsq);
227         _m = ifsq_poll_locked(_ifsq);
228         ALTQ_SQ_UNLOCK(_ifsq);
229         return _m;
230 }
231
232 /*
233  * ALTQ lock must be held
234  */
235 static __inline void
236 ifsq_purge_locked(struct ifaltq_subque *_ifsq)
237 {
238         if (_ifsq->ifsq_prepended != NULL) {
239                 m_freem(_ifsq->ifsq_prepended);
240                 _ifsq->ifsq_prepended = NULL;
241                 KKASSERT(_ifsq->ifq_len > 0);
242                 _ifsq->ifq_len--;
243         }
244
245 #ifdef ALTQ
246         if (!ifq_is_enabled(_ifsq->ifsq_altq))
247                 ifsq_classic_request(_ifsq, ALTRQ_PURGE, NULL);
248         else
249 #endif
250         _ifsq->ifsq_request(_ifsq, ALTRQ_PURGE, NULL);
251 }
252
253 static __inline void
254 ifsq_purge(struct ifaltq_subque *_ifsq)
255 {
256         ALTQ_SQ_LOCK(_ifsq);
257         ifsq_purge_locked(_ifsq);
258         ALTQ_SQ_UNLOCK(_ifsq);
259 }
260
261 static __inline void
262 ifq_lock_all(struct ifaltq *_ifq)
263 {
264         int _q;
265
266         for (_q = 0; _q < _ifq->altq_subq_cnt; ++_q)
267                 ALTQ_SQ_LOCK(&_ifq->altq_subq[_q]);
268 }
269
270 static __inline void
271 ifq_unlock_all(struct ifaltq *_ifq)
272 {
273         int _q;
274
275         for (_q = _ifq->altq_subq_cnt - 1; _q >= 0; --_q)
276                 ALTQ_SQ_UNLOCK(&_ifq->altq_subq[_q]);
277 }
278
279 /*
280  * ALTQ lock must be held
281  */
282 static __inline void
283 ifq_purge_all_locked(struct ifaltq *_ifq)
284 {
285         int _q;
286
287         for (_q = 0; _q < _ifq->altq_subq_cnt; ++_q)
288                 ifsq_purge_locked(&_ifq->altq_subq[_q]);
289 }
290
291 static __inline void
292 ifq_purge_all(struct ifaltq *_ifq)
293 {
294         ifq_lock_all(_ifq);
295         ifq_purge_all_locked(_ifq);
296         ifq_unlock_all(_ifq);
297 }
298
299 static __inline void
300 ifq_classify(struct ifaltq *_ifq, struct mbuf *_m, uint8_t _af,
301     struct altq_pktattr *_pa)
302 {
303 #ifdef ALTQ
304         if (ifq_is_enabled(_ifq)) {
305                 _pa->pattr_af = _af;
306                 _pa->pattr_hdr = mtod(_m, caddr_t);
307                 if (ifq_is_enabled(_ifq) &&
308                     (_ifq->altq_flags & ALTQF_CLASSIFY)) {
309                         /* XXX default subqueue */
310                         struct ifaltq_subque *_ifsq =
311                             &_ifq->altq_subq[ALTQ_SUBQ_INDEX_DEFAULT];
312
313                         ALTQ_SQ_LOCK(_ifsq);
314                         if (ifq_is_enabled(_ifq) &&
315                             (_ifq->altq_flags & ALTQF_CLASSIFY))
316                                 _ifq->altq_classify(_ifq, _m, _pa);
317                         ALTQ_SQ_UNLOCK(_ifsq);
318                 }
319         }
320 #endif
321 }
322
323 static __inline void
324 ifsq_prepend(struct ifaltq_subque *_ifsq, struct mbuf *_m)
325 {
326         ALTQ_SQ_LOCK(_ifsq);
327         KASSERT(_ifsq->ifsq_prepended == NULL, ("pending prepended mbuf"));
328         _ifsq->ifsq_prepended = _m;
329         _ifsq->ifq_len++;
330         ALTQ_SQ_UNLOCK(_ifsq);
331 }
332
333 /*
334  * Interface TX serializer must be held
335  */
336 static __inline void
337 ifsq_set_oactive(struct ifaltq_subque *_ifsq)
338 {
339         _ifsq->ifsq_hw_oactive = 1;
340 }
341
342 /*
343  * Interface TX serializer must be held
344  */
345 static __inline void
346 ifsq_clr_oactive(struct ifaltq_subque *_ifsq)
347 {
348         _ifsq->ifsq_hw_oactive = 0;
349 }
350
351 /*
352  * Interface TX serializer must be held
353  */
354 static __inline int
355 ifsq_is_oactive(const struct ifaltq_subque *_ifsq)
356 {
357         return _ifsq->ifsq_hw_oactive;
358 }
359
360 /*
361  * Hand a packet to an interface.
362  *
363  * Interface TX serializer must be held.  If the interface TX
364  * serializer is not held yet, ifq_dispatch() should be used
365  * to get better performance.
366  */
367 static __inline int
368 ifq_handoff(struct ifnet *_ifp, struct mbuf *_m, struct altq_pktattr *_pa)
369 {
370         struct ifaltq_subque *_ifsq;
371         int _error;
372         int _qid = ALTQ_SUBQ_INDEX_DEFAULT; /* XXX default subqueue */
373
374         _ifsq = &_ifp->if_snd.altq_subq[_qid];
375
376         ASSERT_IFNET_SERIALIZED_TX(_ifp, _ifsq);
377         _error = ifsq_enqueue(_ifsq, _m, _pa);
378         if (_error == 0) {
379                 _ifp->if_obytes += _m->m_pkthdr.len;
380                 if (_m->m_flags & M_MCAST)
381                         _ifp->if_omcasts++;
382                 if (!ifsq_is_oactive(_ifsq))
383                         (*_ifp->if_start)(_ifp, _ifsq);
384         }
385         return(_error);
386 }
387
388 static __inline int
389 ifsq_is_empty(const struct ifaltq_subque *_ifsq)
390 {
391         return(_ifsq->ifq_len == 0);
392 }
393
394 /*
395  * ALTQ lock must be held
396  */
397 static __inline int
398 ifsq_data_ready(struct ifaltq_subque *_ifsq)
399 {
400 #ifdef ALTQ
401         if (_ifsq->ifsq_altq->altq_tbr != NULL)
402                 return (ifsq_poll_locked(_ifsq) != NULL);
403         else
404 #endif
405         return !ifsq_is_empty(_ifsq);
406 }
407
408 /*
409  * ALTQ lock must be held
410  */
411 static __inline int
412 ifsq_is_started(const struct ifaltq_subque *_ifsq)
413 {
414         return _ifsq->ifsq_started;
415 }
416
417 /*
418  * ALTQ lock must be held
419  */
420 static __inline void
421 ifsq_set_started(struct ifaltq_subque *_ifsq)
422 {
423         _ifsq->ifsq_started = 1;
424 }
425
426 /*
427  * ALTQ lock must be held
428  */
429 static __inline void
430 ifsq_clr_started(struct ifaltq_subque *_ifsq)
431 {
432         _ifsq->ifsq_started = 0;
433 }
434
435 static __inline struct ifsubq_stage *
436 ifsq_get_stage(struct ifaltq_subque *_ifsq, int _cpuid)
437 {
438         return &_ifsq->ifsq_stage[_cpuid];
439 }
440
441 static __inline int
442 ifsq_get_cpuid(const struct ifaltq_subque *_ifsq)
443 {
444         return _ifsq->ifsq_cpuid;
445 }
446
447 static __inline void
448 ifsq_set_cpuid(struct ifaltq_subque *_ifsq, int _cpuid)
449 {
450         KASSERT(_cpuid >= 0 && _cpuid < ncpus,
451             ("invalid ifsq_cpuid %d", _cpuid));
452         _ifsq->ifsq_cpuid = _cpuid;
453 }
454
455 static __inline struct lwkt_msg *
456 ifsq_get_ifstart_lmsg(struct ifaltq_subque *_ifsq, int _cpuid)
457 {
458         return &_ifsq->ifsq_ifstart_nmsg[_cpuid].lmsg;
459 }
460
461 static __inline int
462 ifsq_get_index(const struct ifaltq_subque *_ifsq)
463 {
464         return _ifsq->ifsq_index;
465 }
466
467 static __inline void
468 ifsq_set_priv(struct ifaltq_subque *_ifsq, void *_priv)
469 {
470         _ifsq->ifsq_hw_priv = _priv;
471 }
472
473 static __inline void *
474 ifsq_get_priv(const struct ifaltq_subque *_ifsq)
475 {
476         return _ifsq->ifsq_hw_priv;
477 }
478
479 static __inline struct ifnet *
480 ifsq_get_ifp(const struct ifaltq_subque *_ifsq)
481 {
482         return _ifsq->ifsq_ifp;
483 }
484
485 static __inline struct ifaltq_subque *
486 ifq_get_subq_default(const struct ifaltq *_ifq)
487 {
488         return &_ifq->altq_subq[ALTQ_SUBQ_INDEX_DEFAULT];
489 }
490
491 static __inline struct ifaltq_subque *
492 ifq_get_subq(const struct ifaltq *_ifq, int _idx)
493 {
494         KASSERT(_idx >= 0 && _idx < _ifq->altq_subq_cnt,
495             ("invalid qid %d", _idx));
496         return &_ifq->altq_subq[_idx];
497 }
498
499 static __inline struct ifaltq_subque *
500 ifq_map_subq(struct ifaltq *_ifq, int _cpuid)
501
502         int _idx = _ifq->altq_mapsubq(_ifq, _cpuid);
503         return ifq_get_subq(_ifq, _idx);
504 }
505
506 static __inline void
507 ifq_set_subq_cnt(struct ifaltq *_ifq, int _cnt)
508 {
509         _ifq->altq_subq_cnt = _cnt;
510 }
511
512 /* COMPAT */
513 static __inline int
514 ifq_is_oactive(const struct ifaltq *_ifq)
515 {
516         return ifsq_is_oactive(ifq_get_subq_default(_ifq));
517 }
518
519 /* COMPAT */
520 static __inline void
521 ifq_set_oactive(struct ifaltq *_ifq)
522 {
523         ifsq_set_oactive(ifq_get_subq_default(_ifq));
524 }
525
526 /* COMPAT */
527 static __inline void
528 ifq_clr_oactive(struct ifaltq *_ifq)
529 {
530         ifsq_clr_oactive(ifq_get_subq_default(_ifq));
531 }
532
533 /* COMPAT */
534 static __inline int
535 ifq_is_empty(struct ifaltq *_ifq)
536 {
537         return ifsq_is_empty(ifq_get_subq_default(_ifq));
538 }
539
540 /* COMPAT */
541 static __inline void
542 ifq_purge(struct ifaltq *_ifq)
543 {
544         ifsq_purge(ifq_get_subq_default(_ifq));
545 }
546
547 /* COMPAT */
548 static __inline struct mbuf *
549 ifq_dequeue(struct ifaltq *_ifq, struct mbuf *_mpolled)
550 {
551         return ifsq_dequeue(ifq_get_subq_default(_ifq), _mpolled);
552 }
553
554 /* COMPAT */
555 static __inline void
556 ifq_prepend(struct ifaltq *_ifq, struct mbuf *_m)
557 {
558         ifsq_prepend(ifq_get_subq_default(_ifq), _m);
559 }
560
561 /* COMPAT */
562 static __inline void
563 ifq_set_cpuid(struct ifaltq *_ifq, int _cpuid)
564 {
565         KASSERT(_ifq->altq_subq_cnt == 1,
566             ("invalid subqueue count %d", _ifq->altq_subq_cnt));
567         ifsq_set_cpuid(ifq_get_subq_default(_ifq), _cpuid);
568 }
569
570 #endif  /* _KERNEL */
571 #endif  /* _NET_IFQ_VAR_H_ */