root/altq/altq_cdnr.c

DEFINITIONS

1. LIST_HEAD
2. altq_cdnr_input
3. tcb_lookup
4. cdnr_handle2cb
5. cdnr_cb2handle
6. cdnr_cballoc
7. cdnr_cbdestroy
8. generic_element_destroy
9. tca_verify_action
10. tca_import_action
11. tca_invalidate_action
12. top_create
13. top_destroy
14. element_create
15. element_destroy
16. tb_import_profile
17. tbm_create
18. tbm_destroy
19. tbm_input
20. trtcm_create
21. trtcm_destroy
22. trtcm_input
23. tswtcm_create
24. tswtcm_destroy
25. tswtcm_input
26. cdnrcmd_if_attach
27. cdnrcmd_if_detach
28. cdnrcmd_add_element
29. cdnrcmd_delete_element
30. cdnrcmd_add_tbm
31. cdnrcmd_modify_tbm
32. cdnrcmd_tbm_stats
33. cdnrcmd_add_trtcm
34. cdnrcmd_modify_trtcm
35. cdnrcmd_tcm_stats
36. cdnrcmd_add_tswtcm
37. cdnrcmd_modify_tswtcm
38. cdnrcmd_get_stats

    1 /*      $OpenBSD: altq_cdnr.c,v 1.7 2002/12/16 17:27:20 henning Exp $   */
    2 /*      $KAME: altq_cdnr.c,v 1.8 2000/12/14 08:12:45 thorpej Exp $      */
    4 /*
    5  * Copyright (C) 1999-2000
    6  *      Sony Computer Science Laboratories Inc.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   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 the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY SONY CSL 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 SONY CSL 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  */
   30 #include <sys/param.h>
   31 #include <sys/malloc.h>
   32 #include <sys/mbuf.h>
   33 #include <sys/socket.h>
   34 #include <sys/systm.h>
   35 #include <sys/proc.h>
   36 #include <sys/errno.h>
   37 #include <sys/kernel.h>
   38 #include <sys/queue.h>
   40 #include <net/if.h>
   41 #include <net/if_types.h>
   42 #include <netinet/in.h>
   43 #include <netinet/in_systm.h>
   44 #include <netinet/ip.h>
   45 #ifdef INET6
   46 #include <netinet/ip6.h>
   47 #endif
   49 #include <altq/altq.h>
   50 #include <altq/altq_cdnr.h>
   52 /*
   53  * diffserv traffic conditioning module
   54  */
   56 int altq_cdnr_enabled = 0;
   58 /* cdnr_list keeps all cdnr's allocated. */
   59 static LIST_HEAD(, top_cdnr) tcb_list;
   61 static int altq_cdnr_input(struct mbuf *, int);
   62 static struct top_cdnr *tcb_lookup(char *ifname);
   63 static struct cdnr_block *cdnr_handle2cb(u_long);
   64 static u_long cdnr_cb2handle(struct cdnr_block *);
   65 static void *cdnr_cballoc(struct top_cdnr *, int,
   66        struct tc_action *(*)(struct cdnr_block *, struct cdnr_pktinfo *));
   67 static void cdnr_cbdestroy(void *);
   68 static int tca_verify_action(struct tc_action *);
   69 static void tca_import_action(struct tc_action *, struct tc_action *);
   70 static void tca_invalidate_action(struct tc_action *);
   72 static int generic_element_destroy(struct cdnr_block *);
   73 static struct top_cdnr *top_create(struct ifaltq *);
   74 static int top_destroy(struct top_cdnr *);
   75 static struct cdnr_block *element_create(struct top_cdnr *,
   76                                               struct tc_action *);
   77 static int element_destroy(struct cdnr_block *);
   78 static void tb_import_profile(struct tbe *, struct tb_profile *);
   79 static struct tbmeter *tbm_create(struct top_cdnr *, struct tb_profile *,
   80                            struct tc_action *, struct tc_action *);
   81 static int tbm_destroy(struct tbmeter *);
   82 static struct tc_action *tbm_input(struct cdnr_block *,
   83                                         struct cdnr_pktinfo *);
   84 static struct trtcm *trtcm_create(struct top_cdnr *,
   85                   struct tb_profile *, struct tb_profile *,
   86                   struct tc_action *, struct tc_action *, struct tc_action *,
   87                   int);
   88 static int trtcm_destroy(struct trtcm *);
   89 static struct tc_action *trtcm_input(struct cdnr_block *,
   90                                           struct cdnr_pktinfo *);
   91 static struct tswtcm *tswtcm_create(struct top_cdnr *,
u_int32_t, u_int32_t, u_int32_t,
   93                   struct tc_action *, struct tc_action *, struct tc_action *);
   94 static int tswtcm_destroy(struct tswtcm *);
   95 static struct tc_action *tswtcm_input(struct cdnr_block *,
   96                                            struct cdnr_pktinfo *);
   98 static int cdnrcmd_if_attach(char *);
   99 static int cdnrcmd_if_detach(char *);
  100 static int cdnrcmd_add_element(struct cdnr_add_element *);
  101 static int cdnrcmd_delete_element(struct cdnr_delete_element *);
  102 static int cdnrcmd_add_tbm(struct cdnr_add_tbmeter *);
  103 static int cdnrcmd_modify_tbm(struct cdnr_modify_tbmeter *);
  104 static int cdnrcmd_tbm_stats(struct cdnr_tbmeter_stats *);
  105 static int cdnrcmd_add_trtcm(struct cdnr_add_trtcm *);
  106 static int cdnrcmd_modify_trtcm(struct cdnr_modify_trtcm *);
  107 static int cdnrcmd_tcm_stats(struct cdnr_tcm_stats *);
  108 static int cdnrcmd_add_tswtcm(struct cdnr_add_tswtcm *);
  109 static int cdnrcmd_modify_tswtcm(struct cdnr_modify_tswtcm *);
  110 static int cdnrcmd_get_stats(struct cdnr_get_stats *);
  112 #if 1
  113 /* dummy */
  114 int cdnr_dummy(void);
  116 int cdnr_dummy(void)
  117 {
altq_cdnr_input(NULL, 0);
cdnrcmd_if_attach(NULL);
cdnrcmd_if_detach(NULL);
cdnrcmd_add_element(NULL);
cdnrcmd_delete_element(NULL);
cdnrcmd_add_tbm(NULL);
cdnrcmd_modify_tbm(NULL);
cdnrcmd_tbm_stats(NULL);
cdnrcmd_add_trtcm(NULL);
cdnrcmd_modify_trtcm(NULL);
cdnrcmd_tcm_stats(NULL);
cdnrcmd_add_tswtcm(NULL);
cdnrcmd_modify_tswtcm(NULL);
cdnrcmd_get_stats(NULL);
  133         return (0);
  134 }
  136 #endif
  138 /*
  139  * top level input function called from ip_input.
  140  * should be called before converting header fields to host-byte-order.
  141  */
  142 int
altq_cdnr_input(m, af)
  144         struct mbuf     *m;
  145         int             af;     /* address family */
  146 {
  147         struct ifnet            *ifp;
  148         struct ip               *ip;
  149         struct top_cdnr         *top;
  150         struct tc_action        *tca;
  151         struct cdnr_block       *cb;
  152         struct cdnr_pktinfo     pktinfo;
ifp = m->m_pkthdr.rcvif;
  155         if (!ALTQ_IS_CNDTNING(&ifp->if_snd))
  156                 /* traffic conditioner is not enabled on this interface */
  157                 return (1);
top = ifp->if_snd.altq_cdnr;
ip = mtod(m, struct ip *);
  162 #ifdef INET6
  163         if (af == AF_INET6) {
u_int32_t flowlabel;
flowlabel = ((struct ip6_hdr *)ip)->ip6_flow;
pktinfo.pkt_dscp = (ntohl(flowlabel) >> 20) & DSCP_MASK;
  168         } else
  169 #endif
pktinfo.pkt_dscp = ip->ip_tos & DSCP_MASK;
pktinfo.pkt_len = m_pktlen(m);
tca = NULL;
  175 #if 0
cb = acc_classify(&top->tc_classifier, m, af);
  177 #endif
  178         if (cb != NULL)
tca = &cb->cb_action;
  181         if (tca == NULL)
tca = &top->tc_block.cb_action;
  184         while (1) {
PKTCNTR_ADD(&top->tc_cnts[tca->tca_code], pktinfo.pkt_len);
  187                 switch (tca->tca_code) {
  188                 case TCACODE_PASS:
  189                         return (1);
  190                 case TCACODE_DROP:
m_freem(m);
  192                         return (0);
  193                 case TCACODE_RETURN:
  194                         return (0);
  195                 case TCACODE_MARK:
  196 #ifdef INET6
  197                         if (af == AF_INET6) {
  198                                 struct ip6_hdr *ip6 = (struct ip6_hdr *)ip;
u_int32_t flowlabel;
flowlabel = ntohl(ip6->ip6_flow);
flowlabel = (tca->tca_dscp << 20) |
  203                                         (flowlabel & ~(DSCP_MASK << 20));
ip6->ip6_flow = htonl(flowlabel);
  205                         } else
  206 #endif
ip->ip_tos = tca->tca_dscp |
  208                                         (ip->ip_tos & DSCP_CUMASK);
  209                         return (1);
  210                 case TCACODE_NEXT:
cb = tca->tca_next;
tca = (*cb->cb_input)(cb, &pktinfo);
  213                         break;
  214                 case TCACODE_NONE:
  215                 default:
  216                         return (1);
  217                 }
  218         }
  219 }
  221 static struct top_cdnr *
tcb_lookup(ifname)
  223         char *ifname;
  224 {
  225         struct top_cdnr *top;
  226         struct ifnet *ifp;
  228         if ((ifp = ifunit(ifname)) != NULL)
LIST_FOREACH(top, &tcb_list, tc_next)
  230                         if (top->tc_ifq->altq_ifp == ifp)
  231                                 return (top);
  232         return (NULL);
  233 }
  235 static struct cdnr_block *
cdnr_handle2cb(handle)
u_long handle;
  238 {
  239         struct cdnr_block *cb;
cb = (struct cdnr_block *)handle;
  242         if (handle != ALIGN(cb))
  243                 return (NULL);
  245         if (cb == NULL || cb->cb_handle != handle)
  246                 return (NULL);
  247         return (cb);
  248 }
  250 static u_long
cdnr_cb2handle(cb)
  252         struct cdnr_block *cb;
  253 {
  254         return (cb->cb_handle);
  255 }
  257 static void *
cdnr_cballoc(top, type, input_func)
  259         struct top_cdnr *top;
  260         int type;
  261         struct tc_action *(*input_func)(struct cdnr_block *,
  262                                         struct cdnr_pktinfo *);
  263 {
  264         struct cdnr_block *cb;
  265         int size;
  267         switch (type) {
  268         case TCETYPE_TOP:
size = sizeof(struct top_cdnr);
  270                 break;
  271         case TCETYPE_ELEMENT:
size = sizeof(struct cdnr_block);
  273                 break;
  274         case TCETYPE_TBMETER:
size = sizeof(struct tbmeter);
  276                 break;
  277         case TCETYPE_TRTCM:
size = sizeof(struct trtcm);
  279                 break;
  280         case TCETYPE_TSWTCM:
size = sizeof(struct tswtcm);
  282                 break;
  283         default:
  284                 return (NULL);
  285         }
MALLOC(cb, struct cdnr_block *, size, M_DEVBUF, M_WAITOK);
  288         if (cb == NULL)
  289                 return (NULL);
bzero(cb, size);
cb->cb_len = size;
cb->cb_type = type;
cb->cb_ref = 0;
cb->cb_handle = (u_long)cb;
  296         if (top == NULL)
cb->cb_top = (struct top_cdnr *)cb;
  298         else
cb->cb_top = top;
  301         if (input_func != NULL) {
  302                 /*
  303                  * if this cdnr has an action function,
  304                  * make tc_action to call itself.
  305                  */
cb->cb_action.tca_code = TCACODE_NEXT;
cb->cb_action.tca_next = cb;
cb->cb_input = input_func;
  309         } else
cb->cb_action.tca_code = TCACODE_NONE;
  312         /* if this isn't top, register the element to the top level cdnr */
  313         if (top != NULL)
LIST_INSERT_HEAD(&top->tc_elements, cb, cb_next);
  316         return ((void *)cb);
  317 }
  319 static void
cdnr_cbdestroy(cblock)
  321         void *cblock;
  322 {
  323         struct cdnr_block *cb = cblock;
  325         /* remove from the top level cdnr */
  326         if (cb->cb_top != cblock)
LIST_REMOVE(cb, cb_next);
FREE(cb, M_DEVBUF);
  330 }
  332 /*
  333  * conditioner common destroy routine
  334  */
  335 static int
generic_element_destroy(cb)
  337         struct cdnr_block *cb;
  338 {
  339         int error = 0;
  341         switch (cb->cb_type) {
  342         case TCETYPE_TOP:
error = top_destroy((struct top_cdnr *)cb);
  344                 break;
  345         case TCETYPE_ELEMENT:
error = element_destroy(cb);
  347                 break;
  348         case TCETYPE_TBMETER:
error = tbm_destroy((struct tbmeter *)cb);
  350                 break;
  351         case TCETYPE_TRTCM:
error = trtcm_destroy((struct trtcm *)cb);
  353                 break;
  354         case TCETYPE_TSWTCM:
error = tswtcm_destroy((struct tswtcm *)cb);
  356                 break;
  357         default:
error = EINVAL;
  359         }
  360         return (error);
  361 }
  363 static int
tca_verify_action(utca)
  365         struct tc_action *utca;
  366 {
  367         switch (utca->tca_code) {
  368         case TCACODE_PASS:
  369         case TCACODE_DROP:
  370         case TCACODE_MARK:
  371                 /* these are ok */
  372                 break;
  374         case TCACODE_HANDLE:
  375                 /* verify handle value */
  376                 if (cdnr_handle2cb(utca->tca_handle) == NULL)
  377                         return (-1);
  378                 break;
  380         case TCACODE_NONE:
  381         case TCACODE_RETURN:
  382         case TCACODE_NEXT:
  383         default:
  384                 /* should not be passed from a user */
  385                 return (-1);
  386         }
  387         return (0);
  388 }
  390 static void
tca_import_action(ktca, utca)
  392         struct tc_action *ktca, *utca;
  393 {
  394         struct cdnr_block *cb;
  396         *ktca = *utca;
  397         if (ktca->tca_code == TCACODE_HANDLE) {
cb = cdnr_handle2cb(ktca->tca_handle);
  399                 if (cb == NULL) {
ktca->tca_code = TCACODE_NONE;
  401                         return;
  402                 }
ktca->tca_code = TCACODE_NEXT;
ktca->tca_next = cb;
cb->cb_ref++;
  406         } else if (ktca->tca_code == TCACODE_MARK) {
ktca->tca_dscp &= DSCP_MASK;
  408         }
  409         return;
  410 }
  412 static void
tca_invalidate_action(tca)
  414         struct tc_action *tca;
  415 {
  416         struct cdnr_block *cb;
  418         if (tca->tca_code == TCACODE_NEXT) {
cb = tca->tca_next;
  420                 if (cb == NULL)
  421                         return;
cb->cb_ref--;
  423         }
tca->tca_code = TCACODE_NONE;
  425 }
  427 /*
  428  * top level traffic conditioner
  429  */
  430 static struct top_cdnr *
top_create(ifq)
  432         struct ifaltq *ifq;
  433 {
  434         struct top_cdnr *top;
  436         if ((top = cdnr_cballoc(NULL, TCETYPE_TOP, NULL)) == NULL)
  437                 return (NULL);
top->tc_ifq = ifq;
  440         /* set default action for the top level conditioner */
top->tc_block.cb_action.tca_code = TCACODE_PASS;
LIST_INSERT_HEAD(&tcb_list, top, tc_next);
ifq->altq_cdnr = top;
  447         return (top);
  448 }
  450 static int
top_destroy(top)
  452         struct top_cdnr *top;
  453 {
  454         struct cdnr_block *cb;
  456         if (ALTQ_IS_CNDTNING(top->tc_ifq))
ALTQ_CLEAR_CNDTNING(top->tc_ifq);
top->tc_ifq->altq_cdnr = NULL;
  460         /*
  461          * destroy all the conditioner elements belonging to this interface
  462          */
  463         while ((cb = LIST_FIRST(&top->tc_elements)) != NULL) {
  464                 while (cb != NULL && cb->cb_ref > 0)
cb = LIST_NEXT(cb, cb_next);
  466                 if (cb != NULL)
generic_element_destroy(cb);
  468         }
LIST_REMOVE(top, tc_next);
cdnr_cbdestroy(top);
  474         /* if there is no active conditioner, remove the input hook */
  475         if (altq_input != NULL) {
LIST_FOREACH(top, &tcb_list, tc_next)
  477                         if (ALTQ_IS_CNDTNING(top->tc_ifq))
  478                                 break;
  479                 if (top == NULL)
altq_input = NULL;
  481         }
  483         return (0);
  484 }
  486 /*
  487  * simple tc elements without input function (e.g., dropper and makers).
  488  */
  489 static struct cdnr_block *
element_create(top, action)
  491         struct top_cdnr *top;
  492         struct tc_action *action;
  493 {
  494         struct cdnr_block *cb;
  496         if (tca_verify_action(action) < 0)
  497                 return (NULL);
  499         if ((cb = cdnr_cballoc(top, TCETYPE_ELEMENT, NULL)) == NULL)
  500                 return (NULL);
tca_import_action(&cb->cb_action, action);
  504         return (cb);
  505 }
  507 static int
element_destroy(cb)
  509         struct cdnr_block *cb;
  510 {
  511         if (cb->cb_ref > 0)
  512                 return (EBUSY);
tca_invalidate_action(&cb->cb_action);
cdnr_cbdestroy(cb);
  517         return (0);
  518 }
  520 /*
  521  * internal representation of token bucket parameters
  522  *      rate:   byte_per_unittime << 32
  523  *              (((bits_per_sec) / 8) << 32) / machclk_freq
  524  *      depth:  byte << 32
  525  *
  526  */
  527 #define TB_SHIFT        32
  528 #define TB_SCALE(x)     ((u_int64_t)(x) << TB_SHIFT)
  529 #define TB_UNSCALE(x)   ((x) >> TB_SHIFT)
  531 static void
tb_import_profile(tb, profile)
  533         struct tbe *tb;
  534         struct tb_profile *profile;
  535 {
tb->rate = TB_SCALE(profile->rate / 8) / machclk_freq;
tb->depth = TB_SCALE(profile->depth);
  538         if (tb->rate > 0)
tb->filluptime = tb->depth / tb->rate;
  540         else
tb->filluptime = 0xffffffffffffffffLL;
tb->token = tb->depth;
tb->last = read_machclk();
  544 }
  546 /*
  547  * simple token bucket meter
  548  */
  549 static struct tbmeter *
tbm_create(top, profile, in_action, out_action)
  551         struct top_cdnr *top;
  552         struct tb_profile *profile;
  553         struct tc_action *in_action, *out_action;
  554 {
  555         struct tbmeter *tbm = NULL;
  557         if (tca_verify_action(in_action) < 0
  558             || tca_verify_action(out_action) < 0)
  559                 return (NULL);
  561         if ((tbm = cdnr_cballoc(top, TCETYPE_TBMETER,
tbm_input)) == NULL)
  563                 return (NULL);
tb_import_profile(&tbm->tb, profile);
tca_import_action(&tbm->in_action, in_action);
tca_import_action(&tbm->out_action, out_action);
  570         return (tbm);
  571 }
  573 static int
tbm_destroy(tbm)
  575         struct tbmeter *tbm;
  576 {
  577         if (tbm->cdnrblk.cb_ref > 0)
  578                 return (EBUSY);
tca_invalidate_action(&tbm->in_action);
tca_invalidate_action(&tbm->out_action);
cdnr_cbdestroy(tbm);
  584         return (0);
  585 }
  587 static struct tc_action *
tbm_input(cb, pktinfo)
  589         struct cdnr_block *cb;
  590         struct cdnr_pktinfo *pktinfo;
  591 {
  592         struct tbmeter *tbm = (struct tbmeter *)cb;
u_int64_t       len;
u_int64_t       interval, now;
len = TB_SCALE(pktinfo->pkt_len);
  598         if (tbm->tb.token < len) {
now = read_machclk();
interval = now - tbm->tb.last;
  601                 if (interval >= tbm->tb.filluptime)
tbm->tb.token = tbm->tb.depth;
  603                 else {
tbm->tb.token += interval * tbm->tb.rate;
  605                         if (tbm->tb.token > tbm->tb.depth)
tbm->tb.token = tbm->tb.depth;
  607                 }
tbm->tb.last = now;
  609         }
  611         if (tbm->tb.token < len) {
PKTCNTR_ADD(&tbm->out_cnt, pktinfo->pkt_len);
  613                 return (&tbm->out_action);
  614         }
tbm->tb.token -= len;
PKTCNTR_ADD(&tbm->in_cnt, pktinfo->pkt_len);
  618         return (&tbm->in_action);
  619 }
  621 /*
  622  * two rate three color marker
  623  * as described in draft-heinanen-diffserv-trtcm-01.txt
  624  */
  625 static struct trtcm *
trtcm_create(top, cmtd_profile, peak_profile,
green_action, yellow_action, red_action, coloraware)
  628         struct top_cdnr *top;
  629         struct tb_profile *cmtd_profile, *peak_profile;
  630         struct tc_action *green_action, *yellow_action, *red_action;
  631         int     coloraware;
  632 {
  633         struct trtcm *tcm = NULL;
  635         if (tca_verify_action(green_action) < 0
  636             || tca_verify_action(yellow_action) < 0
  637             || tca_verify_action(red_action) < 0)
  638                 return (NULL);
  640         if ((tcm = cdnr_cballoc(top, TCETYPE_TRTCM,
trtcm_input)) == NULL)
  642                 return (NULL);
tb_import_profile(&tcm->cmtd_tb, cmtd_profile);
tb_import_profile(&tcm->peak_tb, peak_profile);
tca_import_action(&tcm->green_action, green_action);
tca_import_action(&tcm->yellow_action, yellow_action);
tca_import_action(&tcm->red_action, red_action);
  651         /* set dscps to use */
  652         if (tcm->green_action.tca_code == TCACODE_MARK)
tcm->green_dscp = tcm->green_action.tca_dscp & DSCP_MASK;
  654         else
tcm->green_dscp = DSCP_AF11;
  656         if (tcm->yellow_action.tca_code == TCACODE_MARK)
tcm->yellow_dscp = tcm->yellow_action.tca_dscp & DSCP_MASK;
  658         else
tcm->yellow_dscp = DSCP_AF12;
  660         if (tcm->red_action.tca_code == TCACODE_MARK)
tcm->red_dscp = tcm->red_action.tca_dscp & DSCP_MASK;
  662         else
tcm->red_dscp = DSCP_AF13;
tcm->coloraware = coloraware;
  667         return (tcm);
  668 }
  670 static int
trtcm_destroy(tcm)
  672         struct trtcm *tcm;
  673 {
  674         if (tcm->cdnrblk.cb_ref > 0)
  675                 return (EBUSY);
tca_invalidate_action(&tcm->green_action);
tca_invalidate_action(&tcm->yellow_action);
tca_invalidate_action(&tcm->red_action);
cdnr_cbdestroy(tcm);
  682         return (0);
  683 }
  685 static struct tc_action *
trtcm_input(cb, pktinfo)
  687         struct cdnr_block *cb;
  688         struct cdnr_pktinfo *pktinfo;
  689 {
  690         struct trtcm *tcm = (struct trtcm *)cb;
u_int64_t       len;
u_int64_t       interval, now;
u_int8_t        color;
len = TB_SCALE(pktinfo->pkt_len);
  696         if (tcm->coloraware) {
color = pktinfo->pkt_dscp;
  698                 if (color != tcm->yellow_dscp && color != tcm->red_dscp)
color = tcm->green_dscp;
  700         } else {
  701                 /* if color-blind, precolor it as green */
color = tcm->green_dscp;
  703         }
now = read_machclk();
  706         if (tcm->cmtd_tb.token < len) {
interval = now - tcm->cmtd_tb.last;
  708                 if (interval >= tcm->cmtd_tb.filluptime)
tcm->cmtd_tb.token = tcm->cmtd_tb.depth;
  710                 else {
tcm->cmtd_tb.token += interval * tcm->cmtd_tb.rate;
  712                         if (tcm->cmtd_tb.token > tcm->cmtd_tb.depth)
tcm->cmtd_tb.token = tcm->cmtd_tb.depth;
  714                 }
tcm->cmtd_tb.last = now;
  716         }
  717         if (tcm->peak_tb.token < len) {
interval = now - tcm->peak_tb.last;
  719                 if (interval >= tcm->peak_tb.filluptime)
tcm->peak_tb.token = tcm->peak_tb.depth;
  721                 else {
tcm->peak_tb.token += interval * tcm->peak_tb.rate;
  723                         if (tcm->peak_tb.token > tcm->peak_tb.depth)
tcm->peak_tb.token = tcm->peak_tb.depth;
  725                 }
tcm->peak_tb.last = now;
  727         }
  729         if (color == tcm->red_dscp || tcm->peak_tb.token < len) {
pktinfo->pkt_dscp = tcm->red_dscp;
PKTCNTR_ADD(&tcm->red_cnt, pktinfo->pkt_len);
  732                 return (&tcm->red_action);
  733         }
  735         if (color == tcm->yellow_dscp || tcm->cmtd_tb.token < len) {
pktinfo->pkt_dscp = tcm->yellow_dscp;
tcm->peak_tb.token -= len;
PKTCNTR_ADD(&tcm->yellow_cnt, pktinfo->pkt_len);
  739                 return (&tcm->yellow_action);
  740         }
pktinfo->pkt_dscp = tcm->green_dscp;
tcm->cmtd_tb.token -= len;
tcm->peak_tb.token -= len;
PKTCNTR_ADD(&tcm->green_cnt, pktinfo->pkt_len);
  746         return (&tcm->green_action);
  747 }
  749 /*
  750  * time sliding window three color marker
  751  * as described in draft-fang-diffserv-tc-tswtcm-00.txt
  752  */
  753 static struct tswtcm *
tswtcm_create(top, cmtd_rate, peak_rate, avg_interval,
green_action, yellow_action, red_action)
  756         struct top_cdnr *top;
u_int32_t       cmtd_rate, peak_rate, avg_interval;
  758         struct tc_action *green_action, *yellow_action, *red_action;
  759 {
  760         struct tswtcm *tsw;
  762         if (tca_verify_action(green_action) < 0
  763             || tca_verify_action(yellow_action) < 0
  764             || tca_verify_action(red_action) < 0)
  765                 return (NULL);
  767         if ((tsw = cdnr_cballoc(top, TCETYPE_TSWTCM,
tswtcm_input)) == NULL)
  769                 return (NULL);
tca_import_action(&tsw->green_action, green_action);
tca_import_action(&tsw->yellow_action, yellow_action);
tca_import_action(&tsw->red_action, red_action);
  775         /* set dscps to use */
  776         if (tsw->green_action.tca_code == TCACODE_MARK)
tsw->green_dscp = tsw->green_action.tca_dscp & DSCP_MASK;
  778         else
tsw->green_dscp = DSCP_AF11;
  780         if (tsw->yellow_action.tca_code == TCACODE_MARK)
tsw->yellow_dscp = tsw->yellow_action.tca_dscp & DSCP_MASK;
  782         else
tsw->yellow_dscp = DSCP_AF12;
  784         if (tsw->red_action.tca_code == TCACODE_MARK)
tsw->red_dscp = tsw->red_action.tca_dscp & DSCP_MASK;
  786         else
tsw->red_dscp = DSCP_AF13;
  789         /* convert rates from bits/sec to bytes/sec */
tsw->cmtd_rate = cmtd_rate / 8;
tsw->peak_rate = peak_rate / 8;
tsw->avg_rate = 0;
  794         /* timewin is converted from msec to machine clock unit */
tsw->timewin = (u_int64_t)machclk_freq * avg_interval / 1000;
  797         return (tsw);
  798 }
  800 static int
tswtcm_destroy(tsw)
  802         struct tswtcm *tsw;
  803 {
  804         if (tsw->cdnrblk.cb_ref > 0)
  805                 return (EBUSY);
tca_invalidate_action(&tsw->green_action);
tca_invalidate_action(&tsw->yellow_action);
tca_invalidate_action(&tsw->red_action);
cdnr_cbdestroy(tsw);
  812         return (0);
  813 }
  815 static struct tc_action *
tswtcm_input(cb, pktinfo)
  817         struct cdnr_block *cb;
  818         struct cdnr_pktinfo *pktinfo;
  819 {
  820         struct tswtcm   *tsw = (struct tswtcm *)cb;
  821         int             len;
u_int32_t       avg_rate;
u_int64_t       interval, now, tmp;
  825         /*
  826          * rate estimator
  827          */
len = pktinfo->pkt_len;
now = read_machclk();
interval = now - tsw->t_front;
  832         /*
  833          * calculate average rate:
  834          *      avg = (avg * timewin + pkt_len)/(timewin + interval)
  835          * pkt_len needs to be multiplied by machclk_freq in order to
  836          * get (bytes/sec).
  837          * note: when avg_rate (bytes/sec) and timewin (machclk unit) are
  838          * less than 32 bits, the following 64-bit operation has enough
  839          * precision.
  840          */
tmp = ((u_int64_t)tsw->avg_rate * tsw->timewin
  842                + (u_int64_t)len * machclk_freq) / (tsw->timewin + interval);
tsw->avg_rate = avg_rate = (u_int32_t)tmp;
tsw->t_front = now;
  846         /*
  847          * marker
  848          */
  849         if (avg_rate > tsw->cmtd_rate) {
u_int32_t randval = random() % avg_rate;
  852                 if (avg_rate > tsw->peak_rate) {
  853                         if (randval < avg_rate - tsw->peak_rate) {
  854                                 /* mark red */
pktinfo->pkt_dscp = tsw->red_dscp;
PKTCNTR_ADD(&tsw->red_cnt, len);
  857                                 return (&tsw->red_action);
  858                         } else if (randval < avg_rate - tsw->cmtd_rate)
  859                                 goto mark_yellow;
  860                 } else {
  861                         /* peak_rate >= avg_rate > cmtd_rate */
  862                         if (randval < avg_rate - tsw->cmtd_rate) {
mark_yellow:
pktinfo->pkt_dscp = tsw->yellow_dscp;
PKTCNTR_ADD(&tsw->yellow_cnt, len);
  866                                 return (&tsw->yellow_action);
  867                         }
  868                 }
  869         }
  871         /* mark green */
pktinfo->pkt_dscp = tsw->green_dscp;
PKTCNTR_ADD(&tsw->green_cnt, len);
  874         return (&tsw->green_action);
  875 }
  877 /*
  878  * ioctl requests
  879  */
  880 static int
cdnrcmd_if_attach(ifname)
  882         char *ifname;
  883 {
  884         struct ifnet *ifp;
  885         struct top_cdnr *top;
  887         if ((ifp = ifunit(ifname)) == NULL)
  888                 return (EBADF);
  890         if (ifp->if_snd.altq_cdnr != NULL)
  891                 return (EBUSY);
  893         if ((top = top_create(&ifp->if_snd)) == NULL)
  894                 return (ENOMEM);
  895         return (0);
  896 }
  898 static int
cdnrcmd_if_detach(ifname)
  900         char *ifname;
  901 {
  902         struct top_cdnr *top;
  904         if ((top = tcb_lookup(ifname)) == NULL)
  905                 return (EBADF);
  907         return top_destroy(top);
  908 }
  910 static int
cdnrcmd_add_element(ap)
  912         struct cdnr_add_element *ap;
  913 {
  914         struct top_cdnr *top;
  915         struct cdnr_block *cb;
  917         if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
  918                 return (EBADF);
cb = element_create(top, &ap->action);
  921         if (cb == NULL)
  922                 return (EINVAL);
  923         /* return a class handle to the user */
ap->cdnr_handle = cdnr_cb2handle(cb);
  925         return (0);
  926 }
  928 static int
cdnrcmd_delete_element(ap)
  930         struct cdnr_delete_element *ap;
  931 {
  932         struct top_cdnr *top;
  933         struct cdnr_block *cb;
  935         if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
  936                 return (EBADF);
  938         if ((cb = cdnr_handle2cb(ap->cdnr_handle)) == NULL)
  939                 return (EINVAL);
  941         if (cb->cb_type != TCETYPE_ELEMENT)
  942                 return generic_element_destroy(cb);
  944         return element_destroy(cb);
  945 }
  947 static int
cdnrcmd_add_tbm(ap)
  949         struct cdnr_add_tbmeter *ap;
  950 {
  951         struct top_cdnr *top;
  952         struct tbmeter *tbm;
  954         if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
  955                 return (EBADF);
tbm = tbm_create(top, &ap->profile, &ap->in_action, &ap->out_action);
  958         if (tbm == NULL)
  959                 return (EINVAL);
  960         /* return a class handle to the user */
ap->cdnr_handle = cdnr_cb2handle(&tbm->cdnrblk);
  962         return (0);
  963 }
  965 static int
cdnrcmd_modify_tbm(ap)
  967         struct cdnr_modify_tbmeter *ap;
  968 {
  969         struct tbmeter *tbm;
  971         if ((tbm = (struct tbmeter *)cdnr_handle2cb(ap->cdnr_handle)) == NULL)
  972                 return (EINVAL);
tb_import_profile(&tbm->tb, &ap->profile);
  976         return (0);
  977 }
  979 static int
cdnrcmd_tbm_stats(ap)
  981         struct cdnr_tbmeter_stats *ap;
  982 {
  983         struct tbmeter *tbm;
  985         if ((tbm = (struct tbmeter *)cdnr_handle2cb(ap->cdnr_handle)) == NULL)
  986                 return (EINVAL);
ap->in_cnt = tbm->in_cnt;
ap->out_cnt = tbm->out_cnt;
  991         return (0);
  992 }
  994 static int
cdnrcmd_add_trtcm(ap)
  996         struct cdnr_add_trtcm *ap;
  997 {
  998         struct top_cdnr *top;
  999         struct trtcm *tcm;
 1001         if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
 1002                 return (EBADF);
tcm = trtcm_create(top, &ap->cmtd_profile, &ap->peak_profile,
 1005                            &ap->green_action, &ap->yellow_action,
 1006                            &ap->red_action, ap->coloraware);
 1007         if (tcm == NULL)
 1008                 return (EINVAL);
 1010         /* return a class handle to the user */
ap->cdnr_handle = cdnr_cb2handle(&tcm->cdnrblk);
 1012         return (0);
 1013 }
 1015 static int
cdnrcmd_modify_trtcm(ap)
 1017         struct cdnr_modify_trtcm *ap;
 1018 {
 1019         struct trtcm *tcm;
 1021         if ((tcm = (struct trtcm *)cdnr_handle2cb(ap->cdnr_handle)) == NULL)
 1022                 return (EINVAL);
tb_import_profile(&tcm->cmtd_tb, &ap->cmtd_profile);
tb_import_profile(&tcm->peak_tb, &ap->peak_profile);
 1027         return (0);
 1028 }
 1030 static int
cdnrcmd_tcm_stats(ap)
 1032         struct cdnr_tcm_stats *ap;
 1033 {
 1034         struct cdnr_block *cb;
 1036         if ((cb = cdnr_handle2cb(ap->cdnr_handle)) == NULL)
 1037                 return (EINVAL);
 1039         if (cb->cb_type == TCETYPE_TRTCM) {
 1040             struct trtcm *tcm = (struct trtcm *)cb;
ap->green_cnt = tcm->green_cnt;
ap->yellow_cnt = tcm->yellow_cnt;
ap->red_cnt = tcm->red_cnt;
 1045         } else if (cb->cb_type == TCETYPE_TSWTCM) {
 1046             struct tswtcm *tsw = (struct tswtcm *)cb;
ap->green_cnt = tsw->green_cnt;
ap->yellow_cnt = tsw->yellow_cnt;
ap->red_cnt = tsw->red_cnt;
 1051         } else
 1052             return (EINVAL);
 1054         return (0);
 1055 }
 1057 static int
cdnrcmd_add_tswtcm(ap)
 1059         struct cdnr_add_tswtcm *ap;
 1060 {
 1061         struct top_cdnr *top;
 1062         struct tswtcm *tsw;
 1064         if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
 1065                 return (EBADF);
 1067         if (ap->cmtd_rate > ap->peak_rate)
 1068                 return (EINVAL);
tsw = tswtcm_create(top, ap->cmtd_rate, ap->peak_rate,
ap->avg_interval, &ap->green_action,
 1072                             &ap->yellow_action, &ap->red_action);
 1073         if (tsw == NULL)
 1074             return (EINVAL);
 1076         /* return a class handle to the user */
ap->cdnr_handle = cdnr_cb2handle(&tsw->cdnrblk);
 1078         return (0);
 1079 }
 1081 static int
cdnrcmd_modify_tswtcm(ap)
 1083         struct cdnr_modify_tswtcm *ap;
 1084 {
 1085         struct tswtcm *tsw;
 1087         if ((tsw = (struct tswtcm *)cdnr_handle2cb(ap->cdnr_handle)) == NULL)
 1088                 return (EINVAL);
 1090         if (ap->cmtd_rate > ap->peak_rate)
 1091                 return (EINVAL);
 1093         /* convert rates from bits/sec to bytes/sec */
tsw->cmtd_rate = ap->cmtd_rate / 8;
tsw->peak_rate = ap->peak_rate / 8;
tsw->avg_rate = 0;
 1098         /* timewin is converted from msec to machine clock unit */
tsw->timewin = (u_int64_t)machclk_freq * ap->avg_interval / 1000;
 1101         return (0);
 1102 }
 1104 static int
cdnrcmd_get_stats(ap)
 1106         struct cdnr_get_stats *ap;
 1107 {
 1108         struct top_cdnr *top;
 1109         struct cdnr_block *cb;
 1110         struct tbmeter *tbm;
 1111         struct trtcm *tcm;
 1112         struct tswtcm *tsw;
 1113         struct tce_stats tce, *usp;
 1114         int error, n, nskip, nelements;
 1116         if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
 1117                 return (EBADF);
 1119         /* copy action stats */
bcopy(top->tc_cnts, ap->cnts, sizeof(ap->cnts));
 1122         /* stats for each element */
nelements = ap->nelements;
usp = ap->tce_stats;
 1125         if (nelements <= 0 || usp == NULL)
 1126                 return (0);
nskip = ap->nskip;
n = 0;
LIST_FOREACH(cb, &top->tc_elements, cb_next) {
 1131                 if (nskip > 0) {
nskip--;
 1133                         continue;
 1134                 }
bzero(&tce, sizeof(tce));
tce.tce_handle = cb->cb_handle;
tce.tce_type = cb->cb_type;
 1139                 switch (cb->cb_type) {
 1140                 case TCETYPE_TBMETER:
tbm = (struct tbmeter *)cb;
tce.tce_cnts[0] = tbm->in_cnt;
tce.tce_cnts[1] = tbm->out_cnt;
 1144                         break;
 1145                 case TCETYPE_TRTCM:
tcm = (struct trtcm *)cb;
tce.tce_cnts[0] = tcm->green_cnt;
tce.tce_cnts[1] = tcm->yellow_cnt;
tce.tce_cnts[2] = tcm->red_cnt;
 1150                         break;
 1151                 case TCETYPE_TSWTCM:
tsw = (struct tswtcm *)cb;
tce.tce_cnts[0] = tsw->green_cnt;
tce.tce_cnts[1] = tsw->yellow_cnt;
tce.tce_cnts[2] = tsw->red_cnt;
 1156                         break;
 1157                 default:
 1158                         continue;
 1159                 }
 1161                 if ((error = copyout((caddr_t)&tce, (caddr_t)usp++,
 1162                                      sizeof(tce))) != 0)
 1163                         return (error);
 1165                 if (++n == nelements)
 1166                         break;
 1167         }
ap->nelements = n;
 1170         return (0);
 1171 }