root/altq/altq_priq.c

DEFINITIONS

1. priq_pfattach
2. priq_add_altq
3. priq_remove_altq
4. priq_add_queue
5. priq_remove_queue
6. priq_getqstats
7. priq_clear_interface
8. priq_request
9. priq_purge
10. priq_class_create
11. priq_class_destroy
12. priq_enqueue
13. priq_dequeue
14. priq_addq
15. priq_getq
16. priq_pollq
17. priq_purgeq
18. get_class_stats
19. clh_to_clp

    1 /*      $OpenBSD: altq_priq.c,v 1.20 2007/05/28 17:16:38 henning Exp $  */
    2 /*      $KAME: altq_priq.c,v 1.1 2000/10/18 09:15:23 kjc Exp $  */
    3 /*
    4  * Copyright (C) 2000
    5  *      Sony Computer Science Laboratories Inc.  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  *
   16  * THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL SONY CSL OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  */
   28 /*
   29  * priority queue
   30  */
   32 #include <sys/param.h>
   33 #include <sys/malloc.h>
   34 #include <sys/mbuf.h>
   35 #include <sys/socket.h>
   36 #include <sys/systm.h>
   37 #include <sys/proc.h>
   38 #include <sys/errno.h>
   39 #include <sys/kernel.h>
   40 #include <sys/queue.h>
   42 #include <net/if.h>
   43 #include <netinet/in.h>
   45 #include <net/pfvar.h>
   46 #include <altq/altq.h>
   47 #include <altq/altq_priq.h>
   49 /*
   50  * function prototypes
   51  */
   52 static int priq_clear_interface(struct priq_if *);
   53 static int priq_request(struct ifaltq *, int, void *);
   54 static void priq_purge(struct priq_if *);
   55 static struct priq_class *priq_class_create(struct priq_if *, int, int, int,
   56     int);
   57 static int priq_class_destroy(struct priq_class *);
   58 static int priq_enqueue(struct ifaltq *, struct mbuf *,
   59                              struct altq_pktattr *);
   60 static struct mbuf *priq_dequeue(struct ifaltq *, int);
   62 static int priq_addq(struct priq_class *, struct mbuf *);
   63 static struct mbuf *priq_getq(struct priq_class *);
   64 static struct mbuf *priq_pollq(struct priq_class *);
   65 static void priq_purgeq(struct priq_class *);
   67 static void get_class_stats(struct priq_classstats *, struct priq_class *);
   68 static struct priq_class *clh_to_clp(struct priq_if *, u_int32_t);
   70 int
priq_pfattach(struct pf_altq *a)
   72 {
   73         struct ifnet *ifp;
   74         int s, error;
   76         if ((ifp = ifunit(a->ifname)) == NULL || a->altq_disc == NULL)
   77                 return (EINVAL);
s = splnet();
error = altq_attach(&ifp->if_snd, ALTQT_PRIQ, a->altq_disc,
priq_enqueue, priq_dequeue, priq_request, NULL, NULL);
splx(s);
   82         return (error);
   83 }
   85 int
priq_add_altq(struct pf_altq *a)
   87 {
   88         struct priq_if  *pif;
   89         struct ifnet    *ifp;
   91         if ((ifp = ifunit(a->ifname)) == NULL)
   92                 return (EINVAL);
   93         if (!ALTQ_IS_READY(&ifp->if_snd))
   94                 return (ENODEV);
MALLOC(pif, struct priq_if *, sizeof(struct priq_if),
M_DEVBUF, M_WAITOK);
   98         if (pif == NULL)
   99                 return (ENOMEM);
bzero(pif, sizeof(struct priq_if));
pif->pif_bandwidth = a->ifbandwidth;
pif->pif_maxpri = -1;
pif->pif_ifq = &ifp->if_snd;
  105         /* keep the state in pf_altq */
a->altq_disc = pif;
  108         return (0);
  109 }
  111 int
priq_remove_altq(struct pf_altq *a)
  113 {
  114         struct priq_if *pif;
  116         if ((pif = a->altq_disc) == NULL)
  117                 return (EINVAL);
a->altq_disc = NULL;
  120         (void)priq_clear_interface(pif);
FREE(pif, M_DEVBUF);
  123         return (0);
  124 }
  126 int
priq_add_queue(struct pf_altq *a)
  128 {
  129         struct priq_if *pif;
  130         struct priq_class *cl;
  132         if ((pif = a->altq_disc) == NULL)
  133                 return (EINVAL);
  135         /* check parameters */
  136         if (a->priority >= PRIQ_MAXPRI)
  137                 return (EINVAL);
  138         if (a->qid == 0)
  139                 return (EINVAL);
  140         if (pif->pif_classes[a->priority] != NULL)
  141                 return (EBUSY);
  142         if (clh_to_clp(pif, a->qid) != NULL)
  143                 return (EBUSY);
cl = priq_class_create(pif, a->priority, a->qlimit,
a->pq_u.priq_opts.flags, a->qid);
  147         if (cl == NULL)
  148                 return (ENOMEM);
  150         return (0);
  151 }
  153 int
priq_remove_queue(struct pf_altq *a)
  155 {
  156         struct priq_if *pif;
  157         struct priq_class *cl;
  159         if ((pif = a->altq_disc) == NULL)
  160                 return (EINVAL);
  162         if ((cl = clh_to_clp(pif, a->qid)) == NULL)
  163                 return (EINVAL);
  165         return (priq_class_destroy(cl));
  166 }
  168 int
priq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes)
  170 {
  171         struct priq_if *pif;
  172         struct priq_class *cl;
  173         struct priq_classstats stats;
  174         int error = 0;
  176         if ((pif = altq_lookup(a->ifname, ALTQT_PRIQ)) == NULL)
  177                 return (EBADF);
  179         if ((cl = clh_to_clp(pif, a->qid)) == NULL)
  180                 return (EINVAL);
  182         if (*nbytes < sizeof(stats))
  183                 return (EINVAL);
get_class_stats(&stats, cl);
  187         if ((error = copyout((caddr_t)&stats, ubuf, sizeof(stats))) != 0)
  188                 return (error);
  189         *nbytes = sizeof(stats);
  190         return (0);
  191 }
  193 /*
  194  * bring the interface back to the initial state by discarding
  195  * all the filters and classes.
  196  */
  197 static int
priq_clear_interface(struct priq_if *pif)
  199 {
  200         struct priq_class       *cl;
  201         int pri;
  203         /* clear out the classes */
  204         for (pri = 0; pri <= pif->pif_maxpri; pri++)
  205                 if ((cl = pif->pif_classes[pri]) != NULL)
priq_class_destroy(cl);
  208         return (0);
  209 }
  211 static int
priq_request(struct ifaltq *ifq, int req, void *arg)
  213 {
  214         struct priq_if  *pif = (struct priq_if *)ifq->altq_disc;
  216         switch (req) {
  217         case ALTRQ_PURGE:
priq_purge(pif);
  219                 break;
  220         }
  221         return (0);
  222 }
  224 /* discard all the queued packets on the interface */
  225 static void
priq_purge(struct priq_if *pif)
  227 {
  228         struct priq_class *cl;
  229         int pri;
  231         for (pri = 0; pri <= pif->pif_maxpri; pri++) {
  232                 if ((cl = pif->pif_classes[pri]) != NULL && !qempty(cl->cl_q))
priq_purgeq(cl);
  234         }
  235         if (ALTQ_IS_ENABLED(pif->pif_ifq))
pif->pif_ifq->ifq_len = 0;
  237 }
  239 static struct priq_class *
priq_class_create(struct priq_if *pif, int pri, int qlimit, int flags, int qid)
  241 {
  242         struct priq_class *cl;
  243         int s;
  245 #ifndef ALTQ_RED
  246         if (flags & PRCF_RED) {
  247 #ifdef ALTQ_DEBUG
printf("priq_class_create: RED not configured for PRIQ!\n");
  249 #endif
  250                 return (NULL);
  251         }
  252 #endif
  254         if ((cl = pif->pif_classes[pri]) != NULL) {
  255                 /* modify the class instead of creating a new one */
s = splnet();
  257                 if (!qempty(cl->cl_q))
priq_purgeq(cl);
splx(s);
  260 #ifdef ALTQ_RIO
  261                 if (q_is_rio(cl->cl_q))
rio_destroy((rio_t *)cl->cl_red);
  263 #endif
  264 #ifdef ALTQ_RED
  265                 if (q_is_red(cl->cl_q))
red_destroy(cl->cl_red);
  267 #endif
  268         } else {
MALLOC(cl, struct priq_class *, sizeof(struct priq_class),
M_DEVBUF, M_WAITOK);
  271                 if (cl == NULL)
  272                         return (NULL);
bzero(cl, sizeof(struct priq_class));
MALLOC(cl->cl_q, class_queue_t *, sizeof(class_queue_t),
M_DEVBUF, M_WAITOK);
  277                 if (cl->cl_q == NULL)
  278                         goto err_ret;
bzero(cl->cl_q, sizeof(class_queue_t));
  280         }
pif->pif_classes[pri] = cl;
  283         if (flags & PRCF_DEFAULTCLASS)
pif->pif_default = cl;
  285         if (qlimit == 0)
qlimit = 50;  /* use default */
qlimit(cl->cl_q) = qlimit;
qtype(cl->cl_q) = Q_DROPTAIL;
qlen(cl->cl_q) = 0;
cl->cl_flags = flags;
cl->cl_pri = pri;
  292         if (pri > pif->pif_maxpri)
pif->pif_maxpri = pri;
cl->cl_pif = pif;
cl->cl_handle = qid;
  297 #ifdef ALTQ_RED
  298         if (flags & (PRCF_RED|PRCF_RIO)) {
  299                 int red_flags, red_pkttime;
red_flags = 0;
  302                 if (flags & PRCF_ECN)
red_flags |= REDF_ECN;
  304 #ifdef ALTQ_RIO
  305                 if (flags & PRCF_CLEARDSCP)
red_flags |= RIOF_CLEARDSCP;
  307 #endif
  308                 if (pif->pif_bandwidth < 8)
red_pkttime = 1000 * 1000 * 1000; /* 1 sec */
  310                 else
red_pkttime = (int64_t)pif->pif_ifq->altq_ifp->if_mtu
  312                           * 1000 * 1000 * 1000 / (pif->pif_bandwidth / 8);
  313 #ifdef ALTQ_RIO
  314                 if (flags & PRCF_RIO) {
cl->cl_red = (red_t *)rio_alloc(0, NULL,
red_flags, red_pkttime);
  317                         if (cl->cl_red != NULL)
qtype(cl->cl_q) = Q_RIO;
  319                 } else
  320 #endif
  321                 if (flags & PRCF_RED) {
cl->cl_red = red_alloc(0, 0,
qlimit(cl->cl_q) * 10/100,
qlimit(cl->cl_q) * 30/100,
red_flags, red_pkttime);
  326                         if (cl->cl_red != NULL)
qtype(cl->cl_q) = Q_RED;
  328                 }
  329         }
  330 #endif /* ALTQ_RED */
  332         return (cl);
err_ret:
  335         if (cl->cl_red != NULL) {
  336 #ifdef ALTQ_RIO
  337                 if (q_is_rio(cl->cl_q))
rio_destroy((rio_t *)cl->cl_red);
  339 #endif
  340 #ifdef ALTQ_RED
  341                 if (q_is_red(cl->cl_q))
red_destroy(cl->cl_red);
  343 #endif
  344         }
  345         if (cl->cl_q != NULL)
FREE(cl->cl_q, M_DEVBUF);
FREE(cl, M_DEVBUF);
  348         return (NULL);
  349 }
  351 static int
priq_class_destroy(struct priq_class *cl)
  353 {
  354         struct priq_if *pif;
  355         int s, pri;
s = splnet();
  359         if (!qempty(cl->cl_q))
priq_purgeq(cl);
pif = cl->cl_pif;
pif->pif_classes[cl->cl_pri] = NULL;
  364         if (pif->pif_maxpri == cl->cl_pri) {
  365                 for (pri = cl->cl_pri; pri >= 0; pri--)
  366                         if (pif->pif_classes[pri] != NULL) {
pif->pif_maxpri = pri;
  368                                 break;
  369                         }
  370                 if (pri < 0)
pif->pif_maxpri = -1;
  372         }
splx(s);
  375         if (cl->cl_red != NULL) {
  376 #ifdef ALTQ_RIO
  377                 if (q_is_rio(cl->cl_q))
rio_destroy((rio_t *)cl->cl_red);
  379 #endif
  380 #ifdef ALTQ_RED
  381                 if (q_is_red(cl->cl_q))
red_destroy(cl->cl_red);
  383 #endif
  384         }
FREE(cl->cl_q, M_DEVBUF);
FREE(cl, M_DEVBUF);
  387         return (0);
  388 }
  390 /*
  391  * priq_enqueue is an enqueue function to be registered to
  392  * (*altq_enqueue) in struct ifaltq.
  393  */
  394 static int
priq_enqueue(struct ifaltq *ifq, struct mbuf *m, struct altq_pktattr *pktattr)
  396 {
  397         struct priq_if  *pif = (struct priq_if *)ifq->altq_disc;
  398         struct priq_class *cl;
  399         int len;
  401         /* grab class set by classifier */
  402         if ((m->m_flags & M_PKTHDR) == 0) {
  403                 /* should not happen */
printf("altq: packet for %s does not have pkthdr\n",
ifq->altq_ifp->if_xname);
m_freem(m);
  407                 return (ENOBUFS);
  408         }
  409         if ((cl = clh_to_clp(pif, m->m_pkthdr.pf.qid)) == NULL) {
cl = pif->pif_default;
  411                 if (cl == NULL) {
m_freem(m);
  413                         return (ENOBUFS);
  414                 }
cl->cl_pktattr = NULL;
  416         }
len = m_pktlen(m);
  419         if (priq_addq(cl, m) != 0) {
  420                 /* drop occurred.  mbuf was freed in priq_addq. */
PKTCNTR_ADD(&cl->cl_dropcnt, len);
  422                 return (ENOBUFS);
  423         }
IFQ_INC_LEN(ifq);
  426         /* successfully queued. */
  427         return (0);
  428 }
  430 /*
  431  * priq_dequeue is a dequeue function to be registered to
  432  * (*altq_dequeue) in struct ifaltq.
  433  *
  434  * note: ALTDQ_POLL returns the next packet without removing the packet
  435  *      from the queue.  ALTDQ_REMOVE is a normal dequeue operation.
  436  *      ALTDQ_REMOVE must return the same packet if called immediately
  437  *      after ALTDQ_POLL.
  438  */
  439 static struct mbuf *
priq_dequeue(struct ifaltq *ifq, int op)
  441 {
  442         struct priq_if  *pif = (struct priq_if *)ifq->altq_disc;
  443         struct priq_class *cl;
  444         struct mbuf *m;
  445         int pri;
  447         if (IFQ_IS_EMPTY(ifq))
  448                 /* no packet in the queue */
  449                 return (NULL);
  451         for (pri = pif->pif_maxpri;  pri >= 0; pri--) {
  452                 if ((cl = pif->pif_classes[pri]) != NULL &&
  453                     !qempty(cl->cl_q)) {
  454                         if (op == ALTDQ_POLL)
  455                                 return (priq_pollq(cl));
m = priq_getq(cl);
  458                         if (m != NULL) {
IFQ_DEC_LEN(ifq);
  460                                 if (qempty(cl->cl_q))
cl->cl_period++;
PKTCNTR_ADD(&cl->cl_xmitcnt, m_pktlen(m));
  463                         }
  464                         return (m);
  465                 }
  466         }
  467         return (NULL);
  468 }
  470 static int
priq_addq(struct priq_class *cl, struct mbuf *m)
  472 {
  474 #ifdef ALTQ_RIO
  475         if (q_is_rio(cl->cl_q))
  476                 return rio_addq((rio_t *)cl->cl_red, cl->cl_q, m,
cl->cl_pktattr);
  478 #endif
  479 #ifdef ALTQ_RED
  480         if (q_is_red(cl->cl_q))
  481                 return red_addq(cl->cl_red, cl->cl_q, m, cl->cl_pktattr);
  482 #endif
  483         if (qlen(cl->cl_q) >= qlimit(cl->cl_q)) {
m_freem(m);
  485                 return (-1);
  486         }
  488         if (cl->cl_flags & PRCF_CLEARDSCP)
write_dsfield(m, cl->cl_pktattr, 0);
_addq(cl->cl_q, m);
  493         return (0);
  494 }
  496 static struct mbuf *
priq_getq(struct priq_class *cl)
  498 {
  499 #ifdef ALTQ_RIO
  500         if (q_is_rio(cl->cl_q))
  501                 return rio_getq((rio_t *)cl->cl_red, cl->cl_q);
  502 #endif
  503 #ifdef ALTQ_RED
  504         if (q_is_red(cl->cl_q))
  505                 return red_getq(cl->cl_red, cl->cl_q);
  506 #endif
  507         return _getq(cl->cl_q);
  508 }
  510 static struct mbuf *
priq_pollq(cl)
  512         struct priq_class *cl;
  513 {
  514         return qhead(cl->cl_q);
  515 }
  517 static void
priq_purgeq(struct priq_class *cl)
  519 {
  520         struct mbuf *m;
  522         if (qempty(cl->cl_q))
  523                 return;
  525         while ((m = _getq(cl->cl_q)) != NULL) {
PKTCNTR_ADD(&cl->cl_dropcnt, m_pktlen(m));
m_freem(m);
  528         }
ASSERT(qlen(cl->cl_q) == 0);
  530 }
  532 static void
get_class_stats(struct priq_classstats *sp, struct priq_class *cl)
  534 {
sp->class_handle = cl->cl_handle;
sp->qlength = qlen(cl->cl_q);
sp->qlimit = qlimit(cl->cl_q);
sp->period = cl->cl_period;
sp->xmitcnt = cl->cl_xmitcnt;
sp->dropcnt = cl->cl_dropcnt;
sp->qtype = qtype(cl->cl_q);
  543 #ifdef ALTQ_RED
  544         if (q_is_red(cl->cl_q))
red_getstats(cl->cl_red, &sp->red[0]);
  546 #endif
  547 #ifdef ALTQ_RIO
  548         if (q_is_rio(cl->cl_q))
rio_getstats((rio_t *)cl->cl_red, &sp->red[0]);
  550 #endif
  552 }
  554 /* convert a class handle to the corresponding class pointer */
  555 static struct priq_class *
clh_to_clp(struct priq_if *pif, u_int32_t chandle)
  557 {
  558         struct priq_class *cl;
  559         int idx;
  561         if (chandle == 0)
  562                 return (NULL);
  564         for (idx = pif->pif_maxpri; idx >= 0; idx--)
  565                 if ((cl = pif->pif_classes[idx]) != NULL &&
cl->cl_handle == chandle)
  567                         return (cl);
  569         return (NULL);
  570 }