c55d9dcf0bb296beb2adc75a70ff1f7ade287861
[dragonfly.git] / sys / net / altq / altq_fairq.c
1 /*
2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
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  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  * 
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sys/net/altq/altq_fairq.c,v 1.2 2008/05/14 11:59:23 sephe Exp $
35  */
36 /*
37  * Matt: I gutted altq_priq.c and used it as a skeleton on which to build
38  * fairq.  The fairq algorithm is completely different then priq, of course,
39  * but because I used priq's skeleton I believe I should include priq's
40  * copyright.
41  *
42  * Copyright (C) 2000-2003
43  *      Sony Computer Science Laboratories Inc.  All rights reserved.
44  *
45  * Redistribution and use in source and binary forms, with or without
46  * modification, are permitted provided that the following conditions
47  * are met:
48  * 1. Redistributions of source code must retain the above copyright
49  *    notice, this list of conditions and the following disclaimer.
50  * 2. Redistributions in binary form must reproduce the above copyright
51  *    notice, this list of conditions and the following disclaimer in the
52  *    documentation and/or other materials provided with the distribution.
53  *
54  * THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND
55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57  * ARE DISCLAIMED.  IN NO EVENT SHALL SONY CSL OR CONTRIBUTORS BE LIABLE
58  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64  * SUCH DAMAGE.
65  */
66
67 /*
68  * FAIRQ - take traffic classified by keep state (hashed into
69  *         pf->state_hash) and bucketize it.  Fairly extract
70  *         the first packet from each bucket in a round-robin fashion.
71  *
72  * TODO - better overall qlimit support (right now it is per-bucket).
73  *      - NOTE: red etc is per bucket, not overall.
74  *      - better service curve support.
75  *
76  * EXAMPLE:
77  *
78  *  altq on em0 fairq bandwidth 650Kb queue { std, bulk }
79  *  queue std  priority 3 bandwidth 200Kb \
80  *      fairq (buckets 64, default, hogs 1Kb) qlimit 50
81  *  queue bulk priority 2 bandwidth 100Kb \
82  *      fairq (buckets 64, hogs 1Kb) qlimit 50
83  *
84  *      NOTE: When the aggregate bandwidth is less than the link bandwidth
85  *            any remaining bandwidth is dynamically assigned using the
86  *            existing bandwidth specs as weightings.
87  *
88  *  pass out on em0 from any to any keep state queue std
89  *  pass out on em0 inet proto tcp ..... port ... keep state queue bulk
90  */
91 #include "opt_altq.h"
92 #include "opt_inet.h"
93 #include "opt_inet6.h"
94
95 #ifdef ALTQ_FAIRQ  /* fairq is enabled in the kernel conf */
96
97 #include <sys/param.h>
98 #include <sys/malloc.h>
99 #include <sys/mbuf.h>
100 #include <sys/socket.h>
101 #include <sys/sockio.h>
102 #include <sys/systm.h>
103 #include <sys/proc.h>
104 #include <sys/errno.h>
105 #include <sys/kernel.h>
106 #include <sys/queue.h>
107 #include <sys/thread.h>
108
109 #include <net/if.h>
110 #include <net/ifq_var.h>
111 #include <netinet/in.h>
112
113 #include <net/pf/pfvar.h>
114 #include <net/altq/altq.h>
115 #include <net/altq/altq_fairq.h>
116
117 #include <sys/thread2.h>
118
119 #define FAIRQ_SUBQ_INDEX        ALTQ_SUBQ_INDEX_DEFAULT
120 #define FAIRQ_LOCK(ifq) \
121     ALTQ_SQ_LOCK(&(ifq)->altq_subq[FAIRQ_SUBQ_INDEX])
122 #define FAIRQ_UNLOCK(ifq) \
123     ALTQ_SQ_UNLOCK(&(ifq)->altq_subq[FAIRQ_SUBQ_INDEX])
124
125 /*
126  * function prototypes
127  */
128 static int      fairq_clear_interface(struct fairq_if *);
129 static int      fairq_request(struct ifaltq_subque *, int, void *);
130 static void     fairq_purge(struct fairq_if *);
131 static struct fairq_class *fairq_class_create(struct fairq_if *, int,
132                                         int, u_int, struct fairq_opts *, int);
133 static int      fairq_class_destroy(struct fairq_class *);
134 static int      fairq_enqueue(struct ifaltq_subque *, struct mbuf *,
135                                         struct altq_pktattr *);
136 static struct mbuf *fairq_dequeue(struct ifaltq_subque *, struct mbuf *, int);
137
138 static int      fairq_addq(struct fairq_class *, struct mbuf *, int hash);
139 static struct mbuf *fairq_getq(struct fairq_class *, uint64_t);
140 static struct mbuf *fairq_pollq(struct fairq_class *, uint64_t, int *);
141 static fairq_bucket_t *fairq_selectq(struct fairq_class *, int);
142 static void     fairq_purgeq(struct fairq_class *);
143
144 static void     get_class_stats(struct fairq_classstats *,
145                                         struct fairq_class *);
146 static struct fairq_class *clh_to_clp(struct fairq_if *, uint32_t);
147
148 int
149 fairq_pfattach(struct pf_altq *a, struct ifaltq *ifq)
150 {
151         return altq_attach(ifq, ALTQT_FAIRQ, a->altq_disc,
152                            fairq_enqueue, fairq_dequeue,
153                            fairq_request, NULL, NULL);
154 }
155
156 int
157 fairq_add_altq(struct pf_altq *a)
158 {
159         struct fairq_if *pif;
160         struct ifnet *ifp;
161
162         if ((ifp = ifunit(a->ifname)) == NULL)
163                 return (EINVAL);
164         if (!ifq_is_ready(&ifp->if_snd))
165                 return (ENODEV);
166
167         pif = kmalloc(sizeof(*pif), M_ALTQ, M_WAITOK | M_ZERO);
168         pif->pif_bandwidth = a->ifbandwidth;
169         pif->pif_maxpri = -1;
170         pif->pif_ifq = &ifp->if_snd;
171         ifq_purge_all(&ifp->if_snd);
172
173         /* keep the state in pf_altq */
174         a->altq_disc = pif;
175
176         return (0);
177 }
178
179 int
180 fairq_remove_altq(struct pf_altq *a)
181 {
182         struct fairq_if *pif;
183
184         if ((pif = a->altq_disc) == NULL)
185                 return (EINVAL);
186         a->altq_disc = NULL;
187
188         fairq_clear_interface(pif);
189
190         kfree(pif, M_ALTQ);
191         return (0);
192 }
193
194 static int
195 fairq_add_queue_locked(struct pf_altq *a, struct fairq_if *pif)
196 {
197         struct fairq_class *cl;
198
199         KKASSERT(a->priority < FAIRQ_MAXPRI);
200         KKASSERT(a->qid != 0);
201
202         if (pif->pif_classes[a->priority] != NULL)
203                 return (EBUSY);
204         if (clh_to_clp(pif, a->qid) != NULL)
205                 return (EBUSY);
206
207         cl = fairq_class_create(pif, a->priority, a->qlimit, a->bandwidth,
208                                &a->pq_u.fairq_opts, a->qid);
209         if (cl == NULL)
210                 return (ENOMEM);
211
212         return (0);
213 }
214
215 int
216 fairq_add_queue(struct pf_altq *a)
217 {
218         struct fairq_if *pif;
219         struct ifaltq *ifq;
220         int error;
221
222         /* check parameters */
223         if (a->priority >= FAIRQ_MAXPRI)
224                 return (EINVAL);
225         if (a->qid == 0)
226                 return (EINVAL);
227
228         /* XXX not MP safe */
229         if ((pif = a->altq_disc) == NULL)
230                 return (EINVAL);
231         ifq = pif->pif_ifq;
232
233         FAIRQ_LOCK(ifq);
234         error = fairq_add_queue_locked(a, pif);
235         FAIRQ_UNLOCK(ifq);
236
237         return error;
238 }
239
240 static int
241 fairq_remove_queue_locked(struct pf_altq *a, struct fairq_if *pif)
242 {
243         struct fairq_class *cl;
244
245         if ((cl = clh_to_clp(pif, a->qid)) == NULL)
246                 return (EINVAL);
247
248         return (fairq_class_destroy(cl));
249 }
250
251 int
252 fairq_remove_queue(struct pf_altq *a)
253 {
254         struct fairq_if *pif;
255         struct ifaltq *ifq;
256         int error;
257
258         /* XXX not MP safe */
259         if ((pif = a->altq_disc) == NULL)
260                 return (EINVAL);
261         ifq = pif->pif_ifq;
262
263         FAIRQ_LOCK(ifq);
264         error = fairq_remove_queue_locked(a, pif);
265         FAIRQ_UNLOCK(ifq);
266
267         return error;
268 }
269
270 int
271 fairq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes)
272 {
273         struct fairq_if *pif;
274         struct fairq_class *cl;
275         struct fairq_classstats stats;
276         struct ifaltq *ifq;
277         int error = 0;
278
279         if (*nbytes < sizeof(stats))
280                 return (EINVAL);
281
282         /* XXX not MP safe */
283         if ((pif = altq_lookup(a->ifname, ALTQT_FAIRQ)) == NULL)
284                 return (EBADF);
285         ifq = pif->pif_ifq;
286
287         FAIRQ_LOCK(ifq);
288
289         if ((cl = clh_to_clp(pif, a->qid)) == NULL) {
290                 FAIRQ_UNLOCK(ifq);
291                 return (EINVAL);
292         }
293
294         get_class_stats(&stats, cl);
295
296         FAIRQ_UNLOCK(ifq);
297
298         if ((error = copyout((caddr_t)&stats, ubuf, sizeof(stats))) != 0)
299                 return (error);
300         *nbytes = sizeof(stats);
301         return (0);
302 }
303
304 /*
305  * bring the interface back to the initial state by discarding
306  * all the filters and classes.
307  */
308 static int
309 fairq_clear_interface(struct fairq_if *pif)
310 {
311         struct fairq_class *cl;
312         int pri;
313
314         /* clear out the classes */
315         for (pri = 0; pri <= pif->pif_maxpri; pri++) {
316                 if ((cl = pif->pif_classes[pri]) != NULL)
317                         fairq_class_destroy(cl);
318         }
319
320         return (0);
321 }
322
323 static int
324 fairq_request(struct ifaltq_subque *ifsq, int req, void *arg)
325 {
326         struct ifaltq *ifq = ifsq->ifsq_altq;
327         struct fairq_if *pif = (struct fairq_if *)ifq->altq_disc;
328
329         crit_enter();
330         switch (req) {
331         case ALTRQ_PURGE:
332                 if (ifsq_get_index(ifsq) == FAIRQ_SUBQ_INDEX) {
333                         fairq_purge(pif);
334                 } else {
335                         /*
336                          * Race happened, the unrelated subqueue was
337                          * picked during the packet scheduler transition.
338                          */
339                         ifsq_classic_request(ifsq, ALTRQ_PURGE, NULL);
340                 }
341                 break;
342         }
343         crit_exit();
344         return (0);
345 }
346
347 /* discard all the queued packets on the interface */
348 static void
349 fairq_purge(struct fairq_if *pif)
350 {
351         struct fairq_class *cl;
352         int pri;
353
354         for (pri = 0; pri <= pif->pif_maxpri; pri++) {
355                 if ((cl = pif->pif_classes[pri]) != NULL && cl->cl_head)
356                         fairq_purgeq(cl);
357         }
358         if (ifq_is_enabled(pif->pif_ifq))
359                 pif->pif_ifq->altq_subq[FAIRQ_SUBQ_INDEX].ifq_len = 0;
360 }
361
362 static struct fairq_class *
363 fairq_class_create(struct fairq_if *pif, int pri, int qlimit,
364                    u_int bandwidth, struct fairq_opts *opts, int qid)
365 {
366         struct fairq_class *cl;
367         int flags = opts->flags;
368         u_int nbuckets = opts->nbuckets;
369         int i;
370
371 #ifndef ALTQ_RED
372         if (flags & FARF_RED) {
373 #ifdef ALTQ_DEBUG
374                 kprintf("fairq_class_create: RED not configured for FAIRQ!\n");
375 #endif
376                 return (NULL);
377         }
378 #endif
379         if (nbuckets == 0)
380                 nbuckets = 256;
381         if (nbuckets > FAIRQ_MAX_BUCKETS)
382                 nbuckets = FAIRQ_MAX_BUCKETS;
383         /* enforce power-of-2 size */
384         while ((nbuckets ^ (nbuckets - 1)) != ((nbuckets << 1) - 1))
385                 ++nbuckets;
386
387         if ((cl = pif->pif_classes[pri]) != NULL) {
388                 /* modify the class instead of creating a new one */
389                 crit_enter();
390                 if (cl->cl_head)
391                         fairq_purgeq(cl);
392                 crit_exit();
393 #ifdef ALTQ_RIO
394                 if (cl->cl_qtype == Q_RIO)
395                         rio_destroy((rio_t *)cl->cl_red);
396 #endif
397 #ifdef ALTQ_RED
398                 if (cl->cl_qtype == Q_RED)
399                         red_destroy(cl->cl_red);
400 #endif
401         } else {
402                 cl = kmalloc(sizeof(*cl), M_ALTQ, M_WAITOK | M_ZERO);
403                 cl->cl_nbuckets = nbuckets;
404                 cl->cl_nbucket_mask = nbuckets - 1;
405
406                 cl->cl_buckets = kmalloc(sizeof(*cl->cl_buckets) *
407                                          cl->cl_nbuckets,
408                                          M_ALTQ, M_WAITOK | M_ZERO);
409                 cl->cl_head = NULL;
410         }
411
412         pif->pif_classes[pri] = cl;
413         if (flags & FARF_DEFAULTCLASS)
414                 pif->pif_default = cl;
415         if (qlimit == 0)
416                 qlimit = 50;  /* use default */
417         cl->cl_qlimit = qlimit;
418         for (i = 0; i < cl->cl_nbuckets; ++i) {
419                 qlimit(&cl->cl_buckets[i].queue) = qlimit;
420         }
421         cl->cl_bandwidth = bandwidth / 8;       /* cvt to bytes per second */
422         cl->cl_qtype = Q_DROPTAIL;
423         cl->cl_flags = flags & FARF_USERFLAGS;
424         cl->cl_pri = pri;
425         if (pri > pif->pif_maxpri)
426                 pif->pif_maxpri = pri;
427         cl->cl_pif = pif;
428         cl->cl_handle = qid;
429         cl->cl_hogs_m1 = opts->hogs_m1 / 8;
430         cl->cl_lssc_m1 = opts->lssc_m1 / 8;     /* NOT YET USED */
431         cl->cl_bw_current = 0;
432
433 #ifdef ALTQ_RED
434         if (flags & (FARF_RED|FARF_RIO)) {
435                 int red_flags, red_pkttime;
436
437                 red_flags = 0;
438                 if (flags & FARF_ECN)
439                         red_flags |= REDF_ECN;
440 #ifdef ALTQ_RIO
441                 if (flags & FARF_CLEARDSCP)
442                         red_flags |= RIOF_CLEARDSCP;
443 #endif
444                 if (pif->pif_bandwidth < 8)
445                         red_pkttime = 1000 * 1000 * 1000; /* 1 sec */
446                 else
447                         red_pkttime = (int64_t)pif->pif_ifq->altq_ifp->if_mtu
448                           * 1000 * 1000 * 1000 / (pif->pif_bandwidth / 8);
449 #ifdef ALTQ_RIO
450                 if (flags & FARF_RIO) {
451                         cl->cl_red = (red_t *)rio_alloc(0, NULL,
452                                                 red_flags, red_pkttime);
453                         if (cl->cl_red != NULL)
454                                 cl->cl_qtype = Q_RIO;
455                 } else
456 #endif
457                 if (flags & FARF_RED) {
458                         cl->cl_red = red_alloc(0, 0,
459                             cl->cl_qlimit * 10/100,
460                             cl->cl_qlimit * 30/100,
461                             red_flags, red_pkttime);
462                         if (cl->cl_red != NULL)
463                                 cl->cl_qtype = Q_RED;
464                 }
465         }
466 #endif /* ALTQ_RED */
467
468         return (cl);
469 }
470
471 static int
472 fairq_class_destroy(struct fairq_class *cl)
473 {
474         struct fairq_if *pif;
475         int pri;
476
477         crit_enter();
478
479         if (cl->cl_head)
480                 fairq_purgeq(cl);
481
482         pif = cl->cl_pif;
483         pif->pif_classes[cl->cl_pri] = NULL;
484         if (pif->pif_poll_cache == cl)
485                 pif->pif_poll_cache = NULL;
486         if (pif->pif_maxpri == cl->cl_pri) {
487                 for (pri = cl->cl_pri; pri >= 0; pri--)
488                         if (pif->pif_classes[pri] != NULL) {
489                                 pif->pif_maxpri = pri;
490                                 break;
491                         }
492                 if (pri < 0)
493                         pif->pif_maxpri = -1;
494         }
495         crit_exit();
496
497         if (cl->cl_red != NULL) {
498 #ifdef ALTQ_RIO
499                 if (cl->cl_qtype == Q_RIO)
500                         rio_destroy((rio_t *)cl->cl_red);
501 #endif
502 #ifdef ALTQ_RED
503                 if (cl->cl_qtype == Q_RED)
504                         red_destroy(cl->cl_red);
505 #endif
506         }
507         kfree(cl->cl_buckets, M_ALTQ);
508         cl->cl_head = NULL;     /* sanity */
509         cl->cl_polled = NULL;   /* sanity */
510         cl->cl_buckets = NULL;  /* sanity */
511         kfree(cl, M_ALTQ);
512
513         return (0);
514 }
515
516 /*
517  * fairq_enqueue is an enqueue function to be registered to
518  * (*altq_enqueue) in struct ifaltq.
519  */
520 static int
521 fairq_enqueue(struct ifaltq_subque *ifsq, struct mbuf *m,
522     struct altq_pktattr *pktattr)
523 {
524         struct ifaltq *ifq = ifsq->ifsq_altq;
525         struct fairq_if *pif = (struct fairq_if *)ifq->altq_disc;
526         struct fairq_class *cl;
527         int error;
528         int len;
529         int hash;
530
531         if (ifsq_get_index(ifsq) != FAIRQ_SUBQ_INDEX) {
532                 /*
533                  * Race happened, the unrelated subqueue was
534                  * picked during the packet scheduler transition.
535                  */
536                 ifsq_classic_request(ifsq, ALTRQ_PURGE, NULL);
537                 m_freem(m);
538                 return ENOBUFS;
539         }
540
541         crit_enter();
542
543         /* grab class set by classifier */
544         if ((m->m_flags & M_PKTHDR) == 0) {
545                 /* should not happen */
546                 if_printf(ifq->altq_ifp, "altq: packet does not have pkthdr\n");
547                 m_freem(m);
548                 error = ENOBUFS;
549                 goto done;
550         }
551
552         if (m->m_pkthdr.fw_flags & PF_MBUF_STRUCTURE) {
553                 cl = clh_to_clp(pif, m->m_pkthdr.pf.qid);
554                 if (m->m_pkthdr.pf.flags & PF_TAG_STATE_HASHED)
555                         hash = (int)m->m_pkthdr.pf.state_hash;
556                 else
557                         hash = 0;
558         } else {
559                 cl = NULL;
560                 hash = 0;
561         }
562         if (cl == NULL) {
563                 cl = pif->pif_default;
564                 if (cl == NULL) {
565                         m_freem(m);
566                         error = ENOBUFS;
567                         goto done;
568                 }
569         }
570         cl->cl_flags |= FARF_HAS_PACKETS;
571         cl->cl_pktattr = NULL;
572         len = m_pktlen(m);
573         if (fairq_addq(cl, m, hash) != 0) {
574                 /* drop occurred.  mbuf was freed in fairq_addq. */
575                 PKTCNTR_ADD(&cl->cl_dropcnt, len);
576                 error = ENOBUFS;
577                 goto done;
578         }
579         ifsq->ifq_len++;
580         error = 0;
581 done:
582         crit_exit();
583         return (error);
584 }
585
586 /*
587  * fairq_dequeue is a dequeue function to be registered to
588  * (*altq_dequeue) in struct ifaltq.
589  *
590  * note: ALTDQ_POLL returns the next packet without removing the packet
591  *      from the queue.  ALTDQ_REMOVE is a normal dequeue operation.
592  *      ALTDQ_REMOVE must return the same packet if called immediately
593  *      after ALTDQ_POLL.
594  */
595 static struct mbuf *
596 fairq_dequeue(struct ifaltq_subque *ifsq, struct mbuf *mpolled, int op)
597 {
598         struct ifaltq *ifq = ifsq->ifsq_altq;
599         struct fairq_if *pif = (struct fairq_if *)ifq->altq_disc;
600         struct fairq_class *cl;
601         struct fairq_class *best_cl;
602         struct mbuf *best_m;
603         struct mbuf *m;
604         uint64_t cur_time = read_machclk();
605         u_int best_scale;
606         u_int scale;
607         int pri;
608         int hit_limit;
609
610         if (ifsq_get_index(ifsq) != FAIRQ_SUBQ_INDEX) {
611                 /*
612                  * Race happened, the unrelated subqueue was
613                  * picked during the packet scheduler transition.
614                  */
615                 ifsq_classic_request(ifsq, ALTRQ_PURGE, NULL);
616                 return NULL;
617         }
618
619         if (ifsq_is_empty(ifsq)) {
620                 /* no packet in the queue */
621                 KKASSERT(mpolled == NULL);
622                 return (NULL);
623         }
624
625         crit_enter();
626         if (pif->pif_poll_cache && op == ALTDQ_REMOVE) {
627                 best_cl = pif->pif_poll_cache;
628                 m = fairq_getq(best_cl, cur_time);
629                 pif->pif_poll_cache = NULL;
630                 if (m) {
631                         ifsq->ifq_len--;
632                         PKTCNTR_ADD(&best_cl->cl_xmitcnt, m_pktlen(m));
633                 }
634         } else {
635                 best_cl = NULL;
636                 best_m = NULL;
637                 best_scale = 0xFFFFFFFFU;
638
639                 for (pri = pif->pif_maxpri;  pri >= 0; pri--) {
640                         if ((cl = pif->pif_classes[pri]) == NULL)
641                                 continue;
642                         if ((cl->cl_flags & FARF_HAS_PACKETS) == 0)
643                                 continue;
644                         m = fairq_pollq(cl, cur_time, &hit_limit);
645                         if (m == NULL) {
646                                 cl->cl_flags &= ~FARF_HAS_PACKETS;
647                                 continue;
648                         }
649
650                         /*
651                          * We can halt the search immediately if the queue
652                          * did not hit its bandwidth limit.
653                          */
654                         if (hit_limit == 0) {
655                                 best_cl = cl;
656                                 best_m = m;
657                                 break;
658                         }
659
660                         /*
661                          * Otherwise calculate the scale factor and select
662                          * the queue with the lowest scale factor.  This
663                          * apportions any unused bandwidth weighted by
664                          * the relative bandwidth specification.
665                          */
666                         scale = cl->cl_bw_current * 100 / cl->cl_bandwidth;
667                         if (scale < best_scale) {
668                                 best_cl = cl;
669                                 best_m = m;
670                                 best_scale = scale;
671                         }
672                 }
673
674                 if (op == ALTDQ_POLL) {
675                         pif->pif_poll_cache = best_cl;
676                         m = best_m;
677                 } else if (best_cl) {
678                         m = fairq_getq(best_cl, cur_time);
679                         KKASSERT(best_m == m);
680                         ifsq->ifq_len--;
681                         PKTCNTR_ADD(&best_cl->cl_xmitcnt, m_pktlen(m));
682                 } else {
683                         m = NULL;
684                 }
685         }
686         crit_exit();
687         KKASSERT(mpolled == NULL || mpolled == m);
688         return (m);
689 }
690
691 static int
692 fairq_addq(struct fairq_class *cl, struct mbuf *m, int hash)
693 {
694         fairq_bucket_t *b;
695         u_int hindex;
696         uint64_t bw;
697
698         /*
699          * If the packet doesn't have any keep state put it on the end of
700          * our queue.  XXX this can result in out of order delivery.
701          */
702         if (hash == 0) {
703                 if (cl->cl_head)
704                         b = cl->cl_head->prev;
705                 else
706                         b = &cl->cl_buckets[0];
707         } else {
708                 hindex = hash & cl->cl_nbucket_mask;
709                 b = &cl->cl_buckets[hindex];
710         }
711
712         /*
713          * Add the bucket to the end of the circular list of active buckets.
714          *
715          * As a special case we add the bucket to the beginning of the list
716          * instead of the end if it was not previously on the list and if
717          * its traffic is less then the hog level.
718          */
719         if (b->in_use == 0) {
720                 b->in_use = 1;
721                 if (cl->cl_head == NULL) {
722                         cl->cl_head = b;
723                         b->next = b;
724                         b->prev = b;
725                 } else {
726                         b->next = cl->cl_head;
727                         b->prev = cl->cl_head->prev;
728                         b->prev->next = b;
729                         b->next->prev = b;
730
731                         if (b->bw_delta && cl->cl_hogs_m1) {
732                                 bw = b->bw_bytes * machclk_freq / b->bw_delta;
733                                 if (bw < cl->cl_hogs_m1)
734                                         cl->cl_head = b;
735                         }
736                 }
737         }
738
739 #ifdef ALTQ_RIO
740         if (cl->cl_qtype == Q_RIO)
741                 return rio_addq((rio_t *)cl->cl_red, &b->queue, m, cl->cl_pktattr);
742 #endif
743 #ifdef ALTQ_RED
744         if (cl->cl_qtype == Q_RED)
745                 return red_addq(cl->cl_red, &b->queue, m, cl->cl_pktattr);
746 #endif
747         if (qlen(&b->queue) >= qlimit(&b->queue)) {
748                 m_freem(m);
749                 return (-1);
750         }
751
752         if (cl->cl_flags & FARF_CLEARDSCP)
753                 write_dsfield(m, cl->cl_pktattr, 0);
754
755         _addq(&b->queue, m);
756
757         return (0);
758 }
759
760 static struct mbuf *
761 fairq_getq(struct fairq_class *cl, uint64_t cur_time)
762 {
763         fairq_bucket_t *b;
764         struct mbuf *m;
765
766         b = fairq_selectq(cl, 0);
767         if (b == NULL)
768                 m = NULL;
769 #ifdef ALTQ_RIO
770         else if (cl->cl_qtype == Q_RIO)
771                 m = rio_getq((rio_t *)cl->cl_red, &b->queue);
772 #endif
773 #ifdef ALTQ_RED
774         else if (cl->cl_qtype == Q_RED)
775                 m = red_getq(cl->cl_red, &b->queue);
776 #endif
777         else
778                 m = _getq(&b->queue);
779
780         /*
781          * Calculate the BW change
782          */
783         if (m != NULL) {
784                 uint64_t delta;
785
786                 /*
787                  * Per-class bandwidth calculation
788                  */
789                 delta = (cur_time - cl->cl_last_time);
790                 if (delta > machclk_freq * 8)
791                         delta = machclk_freq * 8;
792                 cl->cl_bw_delta += delta;
793                 cl->cl_bw_bytes += m->m_pkthdr.len;
794                 cl->cl_last_time = cur_time;
795                 if (cl->cl_bw_delta > machclk_freq) {
796                         cl->cl_bw_delta -= cl->cl_bw_delta >> 2;
797                         cl->cl_bw_bytes -= cl->cl_bw_bytes >> 2;
798                 }
799
800                 /*
801                  * Per-bucket bandwidth calculation
802                  */
803                 delta = (cur_time - b->last_time);
804                 if (delta > machclk_freq * 8)
805                         delta = machclk_freq * 8;
806                 b->bw_delta += delta;
807                 b->bw_bytes += m->m_pkthdr.len;
808                 b->last_time = cur_time;
809                 if (b->bw_delta > machclk_freq) {
810                         b->bw_delta -= b->bw_delta >> 2;
811                         b->bw_bytes -= b->bw_bytes >> 2;
812                 }
813         }
814         return(m);
815 }
816
817 /*
818  * Figure out what the next packet would be if there were no limits.  If
819  * this class hits its bandwidth limit *hit_limit is set to no-zero, otherwise
820  * it is set to 0.  A non-NULL mbuf is returned either way.
821  */
822 static struct mbuf *
823 fairq_pollq(struct fairq_class *cl, uint64_t cur_time, int *hit_limit)
824 {
825         fairq_bucket_t *b;
826         struct mbuf *m;
827         uint64_t delta;
828         uint64_t bw;
829
830         *hit_limit = 0;
831         b = fairq_selectq(cl, 1);
832         if (b == NULL)
833                 return(NULL);
834         m = qhead(&b->queue);
835
836         /*
837          * Did this packet exceed the class bandwidth?  Calculate the
838          * bandwidth component of the packet.
839          *
840          * - Calculate bytes per second
841          */
842         delta = cur_time - cl->cl_last_time;
843         if (delta > machclk_freq * 8)
844                 delta = machclk_freq * 8;
845         cl->cl_bw_delta += delta;
846         cl->cl_last_time = cur_time;
847         if (cl->cl_bw_delta) {
848                 bw = cl->cl_bw_bytes * machclk_freq / cl->cl_bw_delta;
849
850                 if (bw > cl->cl_bandwidth)
851                         *hit_limit = 1;
852                 cl->cl_bw_current = bw;
853 #if 0
854                 kprintf("BW %6lld relative to %6u %d queue %p\n",
855                         bw, cl->cl_bandwidth, *hit_limit, b);
856 #endif
857         }
858         return(m);
859 }
860
861 /*
862  * Locate the next queue we want to pull a packet out of.  This code
863  * is also responsible for removing empty buckets from the circular list.
864  */
865 static
866 fairq_bucket_t *
867 fairq_selectq(struct fairq_class *cl, int ispoll)
868 {
869         fairq_bucket_t *b;
870         uint64_t bw;
871
872         if (ispoll == 0 && cl->cl_polled) {
873                 b = cl->cl_polled;
874                 cl->cl_polled = NULL;
875                 return(b);
876         }
877
878         while ((b = cl->cl_head) != NULL) {
879                 /*
880                  * Remove empty queues from consideration
881                  */
882                 if (qempty(&b->queue)) {
883                         b->in_use = 0;
884                         cl->cl_head = b->next;
885                         if (cl->cl_head == b) {
886                                 cl->cl_head = NULL;
887                         } else {
888                                 b->next->prev = b->prev;
889                                 b->prev->next = b->next;
890                         }
891                         continue;
892                 }
893
894                 /*
895                  * Advance the round robin.  Queues with bandwidths less
896                  * then the hog bandwidth are allowed to burst.
897                  */
898                 if (cl->cl_hogs_m1 == 0) {
899                         cl->cl_head = b->next;
900                 } else if (b->bw_delta) {
901                         bw = b->bw_bytes * machclk_freq / b->bw_delta;
902                         if (bw >= cl->cl_hogs_m1) {
903                                 cl->cl_head = b->next;
904                         }
905                         /*
906                          * XXX TODO - 
907                          */
908                 }
909
910                 /*
911                  * Return bucket b.
912                  */
913                 break;
914         }
915         if (ispoll)
916                 cl->cl_polled = b;
917         return(b);
918 }
919
920 static void
921 fairq_purgeq(struct fairq_class *cl)
922 {
923         fairq_bucket_t *b;
924         struct mbuf *m;
925
926         while ((b = fairq_selectq(cl, 0)) != NULL) {
927                 while ((m = _getq(&b->queue)) != NULL) {
928                         PKTCNTR_ADD(&cl->cl_dropcnt, m_pktlen(m));
929                         m_freem(m);
930                 }
931                 KKASSERT(qlen(&b->queue) == 0);
932         }
933 }
934
935 static void
936 get_class_stats(struct fairq_classstats *sp, struct fairq_class *cl)
937 {
938         fairq_bucket_t *b;
939
940         sp->class_handle = cl->cl_handle;
941         sp->qlimit = cl->cl_qlimit;
942         sp->xmit_cnt = cl->cl_xmitcnt;
943         sp->drop_cnt = cl->cl_dropcnt;
944         sp->qtype = cl->cl_qtype;
945         sp->qlength = 0;
946
947         if (cl->cl_head) {
948                 b = cl->cl_head;
949                 do {
950                         sp->qlength += qlen(&b->queue);
951                         b = b->next;
952                 } while (b != cl->cl_head);
953         }
954
955 #ifdef ALTQ_RED
956         if (cl->cl_qtype == Q_RED)
957                 red_getstats(cl->cl_red, &sp->red[0]);
958 #endif
959 #ifdef ALTQ_RIO
960         if (cl->cl_qtype == Q_RIO)
961                 rio_getstats((rio_t *)cl->cl_red, &sp->red[0]);
962 #endif
963 }
964
965 /* convert a class handle to the corresponding class pointer */
966 static struct fairq_class *
967 clh_to_clp(struct fairq_if *pif, uint32_t chandle)
968 {
969         struct fairq_class *cl;
970         int idx;
971
972         if (chandle == 0)
973                 return (NULL);
974
975         for (idx = pif->pif_maxpri; idx >= 0; idx--)
976                 if ((cl = pif->pif_classes[idx]) != NULL &&
977                     cl->cl_handle == chandle)
978                         return (cl);
979
980         return (NULL);
981 }
982
983 #endif /* ALTQ_FAIRQ */