![[BACK]](/icons/back.gif){kind=icon}
Return to altq_cdnr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / altq|
Return to altq_cdnr.c CVS log | Up to [local] / sys / altq |
1.1 nbrk 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 $ */
3:
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: */
29:
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>
39:
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
48:
49: #include <altq/altq.h>
50: #include <altq/altq_cdnr.h>
51:
52: /*
53: * diffserv traffic conditioning module
54: */
55:
56: int altq_cdnr_enabled = 0;
57:
58: /* cdnr_list keeps all cdnr's allocated. */
59: static LIST_HEAD(, top_cdnr) tcb_list;
60:
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 *);
71:
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 *,
92: 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 *);
97:
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 *);
111:
112: #if 1
113: /* dummy */
114: int cdnr_dummy(void);
115:
116: int cdnr_dummy(void)
117: {
118: altq_cdnr_input(NULL, 0);
119:
120: cdnrcmd_if_attach(NULL);
121: cdnrcmd_if_detach(NULL);
122: cdnrcmd_add_element(NULL);
123: cdnrcmd_delete_element(NULL);
124: cdnrcmd_add_tbm(NULL);
125: cdnrcmd_modify_tbm(NULL);
126: cdnrcmd_tbm_stats(NULL);
127: cdnrcmd_add_trtcm(NULL);
128: cdnrcmd_modify_trtcm(NULL);
129: cdnrcmd_tcm_stats(NULL);
130: cdnrcmd_add_tswtcm(NULL);
131: cdnrcmd_modify_tswtcm(NULL);
132: cdnrcmd_get_stats(NULL);
133: return (0);
134: }
135:
136: #endif
137:
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
143: 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;
153:
154: 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);
158:
159: top = ifp->if_snd.altq_cdnr;
160:
161: ip = mtod(m, struct ip *);
162: #ifdef INET6
163: if (af == AF_INET6) {
164: u_int32_t flowlabel;
165:
166: flowlabel = ((struct ip6_hdr *)ip)->ip6_flow;
167: pktinfo.pkt_dscp = (ntohl(flowlabel) >> 20) & DSCP_MASK;
168: } else
169: #endif
170: pktinfo.pkt_dscp = ip->ip_tos & DSCP_MASK;
171: pktinfo.pkt_len = m_pktlen(m);
172:
173: tca = NULL;
174:
175: #if 0
176: cb = acc_classify(&top->tc_classifier, m, af);
177: #endif
178: if (cb != NULL)
179: tca = &cb->cb_action;
180:
181: if (tca == NULL)
182: tca = &top->tc_block.cb_action;
183:
184: while (1) {
185: PKTCNTR_ADD(&top->tc_cnts[tca->tca_code], pktinfo.pkt_len);
186:
187: switch (tca->tca_code) {
188: case TCACODE_PASS:
189: return (1);
190: case TCACODE_DROP:
191: 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;
199: u_int32_t flowlabel;
200:
201: flowlabel = ntohl(ip6->ip6_flow);
202: flowlabel = (tca->tca_dscp << 20) |
203: (flowlabel & ~(DSCP_MASK << 20));
204: ip6->ip6_flow = htonl(flowlabel);
205: } else
206: #endif
207: ip->ip_tos = tca->tca_dscp |
208: (ip->ip_tos & DSCP_CUMASK);
209: return (1);
210: case TCACODE_NEXT:
211: cb = tca->tca_next;
212: tca = (*cb->cb_input)(cb, &pktinfo);
213: break;
214: case TCACODE_NONE:
215: default:
216: return (1);
217: }
218: }
219: }
220:
221: static struct top_cdnr *
222: tcb_lookup(ifname)
223: char *ifname;
224: {
225: struct top_cdnr *top;
226: struct ifnet *ifp;
227:
228: if ((ifp = ifunit(ifname)) != NULL)
229: LIST_FOREACH(top, &tcb_list, tc_next)
230: if (top->tc_ifq->altq_ifp == ifp)
231: return (top);
232: return (NULL);
233: }
234:
235: static struct cdnr_block *
236: cdnr_handle2cb(handle)
237: u_long handle;
238: {
239: struct cdnr_block *cb;
240:
241: cb = (struct cdnr_block *)handle;
242: if (handle != ALIGN(cb))
243: return (NULL);
244:
245: if (cb == NULL || cb->cb_handle != handle)
246: return (NULL);
247: return (cb);
248: }
249:
250: static u_long
251: cdnr_cb2handle(cb)
252: struct cdnr_block *cb;
253: {
254: return (cb->cb_handle);
255: }
256:
257: static void *
258: 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;
266:
267: switch (type) {
268: case TCETYPE_TOP:
269: size = sizeof(struct top_cdnr);
270: break;
271: case TCETYPE_ELEMENT:
272: size = sizeof(struct cdnr_block);
273: break;
274: case TCETYPE_TBMETER:
275: size = sizeof(struct tbmeter);
276: break;
277: case TCETYPE_TRTCM:
278: size = sizeof(struct trtcm);
279: break;
280: case TCETYPE_TSWTCM:
281: size = sizeof(struct tswtcm);
282: break;
283: default:
284: return (NULL);
285: }
286:
287: MALLOC(cb, struct cdnr_block *, size, M_DEVBUF, M_WAITOK);
288: if (cb == NULL)
289: return (NULL);
290: bzero(cb, size);
291:
292: cb->cb_len = size;
293: cb->cb_type = type;
294: cb->cb_ref = 0;
295: cb->cb_handle = (u_long)cb;
296: if (top == NULL)
297: cb->cb_top = (struct top_cdnr *)cb;
298: else
299: cb->cb_top = top;
300:
301: if (input_func != NULL) {
302: /*
303: * if this cdnr has an action function,
304: * make tc_action to call itself.
305: */
306: cb->cb_action.tca_code = TCACODE_NEXT;
307: cb->cb_action.tca_next = cb;
308: cb->cb_input = input_func;
309: } else
310: cb->cb_action.tca_code = TCACODE_NONE;
311:
312: /* if this isn't top, register the element to the top level cdnr */
313: if (top != NULL)
314: LIST_INSERT_HEAD(&top->tc_elements, cb, cb_next);
315:
316: return ((void *)cb);
317: }
318:
319: static void
320: cdnr_cbdestroy(cblock)
321: void *cblock;
322: {
323: struct cdnr_block *cb = cblock;
324:
325: /* remove from the top level cdnr */
326: if (cb->cb_top != cblock)
327: LIST_REMOVE(cb, cb_next);
328:
329: FREE(cb, M_DEVBUF);
330: }
331:
332: /*
333: * conditioner common destroy routine
334: */
335: static int
336: generic_element_destroy(cb)
337: struct cdnr_block *cb;
338: {
339: int error = 0;
340:
341: switch (cb->cb_type) {
342: case TCETYPE_TOP:
343: error = top_destroy((struct top_cdnr *)cb);
344: break;
345: case TCETYPE_ELEMENT:
346: error = element_destroy(cb);
347: break;
348: case TCETYPE_TBMETER:
349: error = tbm_destroy((struct tbmeter *)cb);
350: break;
351: case TCETYPE_TRTCM:
352: error = trtcm_destroy((struct trtcm *)cb);
353: break;
354: case TCETYPE_TSWTCM:
355: error = tswtcm_destroy((struct tswtcm *)cb);
356: break;
357: default:
358: error = EINVAL;
359: }
360: return (error);
361: }
362:
363: static int
364: 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;
373:
374: case TCACODE_HANDLE:
375: /* verify handle value */
376: if (cdnr_handle2cb(utca->tca_handle) == NULL)
377: return (-1);
378: break;
379:
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: }
389:
390: static void
391: tca_import_action(ktca, utca)
392: struct tc_action *ktca, *utca;
393: {
394: struct cdnr_block *cb;
395:
396: *ktca = *utca;
397: if (ktca->tca_code == TCACODE_HANDLE) {
398: cb = cdnr_handle2cb(ktca->tca_handle);
399: if (cb == NULL) {
400: ktca->tca_code = TCACODE_NONE;
401: return;
402: }
403: ktca->tca_code = TCACODE_NEXT;
404: ktca->tca_next = cb;
405: cb->cb_ref++;
406: } else if (ktca->tca_code == TCACODE_MARK) {
407: ktca->tca_dscp &= DSCP_MASK;
408: }
409: return;
410: }
411:
412: static void
413: tca_invalidate_action(tca)
414: struct tc_action *tca;
415: {
416: struct cdnr_block *cb;
417:
418: if (tca->tca_code == TCACODE_NEXT) {
419: cb = tca->tca_next;
420: if (cb == NULL)
421: return;
422: cb->cb_ref--;
423: }
424: tca->tca_code = TCACODE_NONE;
425: }
426:
427: /*
428: * top level traffic conditioner
429: */
430: static struct top_cdnr *
431: top_create(ifq)
432: struct ifaltq *ifq;
433: {
434: struct top_cdnr *top;
435:
436: if ((top = cdnr_cballoc(NULL, TCETYPE_TOP, NULL)) == NULL)
437: return (NULL);
438:
439: top->tc_ifq = ifq;
440: /* set default action for the top level conditioner */
441: top->tc_block.cb_action.tca_code = TCACODE_PASS;
442:
443: LIST_INSERT_HEAD(&tcb_list, top, tc_next);
444:
445: ifq->altq_cdnr = top;
446:
447: return (top);
448: }
449:
450: static int
451: top_destroy(top)
452: struct top_cdnr *top;
453: {
454: struct cdnr_block *cb;
455:
456: if (ALTQ_IS_CNDTNING(top->tc_ifq))
457: ALTQ_CLEAR_CNDTNING(top->tc_ifq);
458: top->tc_ifq->altq_cdnr = NULL;
459:
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)
465: cb = LIST_NEXT(cb, cb_next);
466: if (cb != NULL)
467: generic_element_destroy(cb);
468: }
469:
470: LIST_REMOVE(top, tc_next);
471:
472: cdnr_cbdestroy(top);
473:
474: /* if there is no active conditioner, remove the input hook */
475: if (altq_input != NULL) {
476: LIST_FOREACH(top, &tcb_list, tc_next)
477: if (ALTQ_IS_CNDTNING(top->tc_ifq))
478: break;
479: if (top == NULL)
480: altq_input = NULL;
481: }
482:
483: return (0);
484: }
485:
486: /*
487: * simple tc elements without input function (e.g., dropper and makers).
488: */
489: static struct cdnr_block *
490: element_create(top, action)
491: struct top_cdnr *top;
492: struct tc_action *action;
493: {
494: struct cdnr_block *cb;
495:
496: if (tca_verify_action(action) < 0)
497: return (NULL);
498:
499: if ((cb = cdnr_cballoc(top, TCETYPE_ELEMENT, NULL)) == NULL)
500: return (NULL);
501:
502: tca_import_action(&cb->cb_action, action);
503:
504: return (cb);
505: }
506:
507: static int
508: element_destroy(cb)
509: struct cdnr_block *cb;
510: {
511: if (cb->cb_ref > 0)
512: return (EBUSY);
513:
514: tca_invalidate_action(&cb->cb_action);
515:
516: cdnr_cbdestroy(cb);
517: return (0);
518: }
519:
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)
530:
531: static void
532: tb_import_profile(tb, profile)
533: struct tbe *tb;
534: struct tb_profile *profile;
535: {
536: tb->rate = TB_SCALE(profile->rate / 8) / machclk_freq;
537: tb->depth = TB_SCALE(profile->depth);
538: if (tb->rate > 0)
539: tb->filluptime = tb->depth / tb->rate;
540: else
541: tb->filluptime = 0xffffffffffffffffLL;
542: tb->token = tb->depth;
543: tb->last = read_machclk();
544: }
545:
546: /*
547: * simple token bucket meter
548: */
549: static struct tbmeter *
550: 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;
556:
557: if (tca_verify_action(in_action) < 0
558: || tca_verify_action(out_action) < 0)
559: return (NULL);
560:
561: if ((tbm = cdnr_cballoc(top, TCETYPE_TBMETER,
562: tbm_input)) == NULL)
563: return (NULL);
564:
565: tb_import_profile(&tbm->tb, profile);
566:
567: tca_import_action(&tbm->in_action, in_action);
568: tca_import_action(&tbm->out_action, out_action);
569:
570: return (tbm);
571: }
572:
573: static int
574: tbm_destroy(tbm)
575: struct tbmeter *tbm;
576: {
577: if (tbm->cdnrblk.cb_ref > 0)
578: return (EBUSY);
579:
580: tca_invalidate_action(&tbm->in_action);
581: tca_invalidate_action(&tbm->out_action);
582:
583: cdnr_cbdestroy(tbm);
584: return (0);
585: }
586:
587: static struct tc_action *
588: tbm_input(cb, pktinfo)
589: struct cdnr_block *cb;
590: struct cdnr_pktinfo *pktinfo;
591: {
592: struct tbmeter *tbm = (struct tbmeter *)cb;
593: u_int64_t len;
594: u_int64_t interval, now;
595:
596: len = TB_SCALE(pktinfo->pkt_len);
597:
598: if (tbm->tb.token < len) {
599: now = read_machclk();
600: interval = now - tbm->tb.last;
601: if (interval >= tbm->tb.filluptime)
602: tbm->tb.token = tbm->tb.depth;
603: else {
604: tbm->tb.token += interval * tbm->tb.rate;
605: if (tbm->tb.token > tbm->tb.depth)
606: tbm->tb.token = tbm->tb.depth;
607: }
608: tbm->tb.last = now;
609: }
610:
611: if (tbm->tb.token < len) {
612: PKTCNTR_ADD(&tbm->out_cnt, pktinfo->pkt_len);
613: return (&tbm->out_action);
614: }
615:
616: tbm->tb.token -= len;
617: PKTCNTR_ADD(&tbm->in_cnt, pktinfo->pkt_len);
618: return (&tbm->in_action);
619: }
620:
621: /*
622: * two rate three color marker
623: * as described in draft-heinanen-diffserv-trtcm-01.txt
624: */
625: static struct trtcm *
626: trtcm_create(top, cmtd_profile, peak_profile,
627: 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;
634:
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);
639:
640: if ((tcm = cdnr_cballoc(top, TCETYPE_TRTCM,
641: trtcm_input)) == NULL)
642: return (NULL);
643:
644: tb_import_profile(&tcm->cmtd_tb, cmtd_profile);
645: tb_import_profile(&tcm->peak_tb, peak_profile);
646:
647: tca_import_action(&tcm->green_action, green_action);
648: tca_import_action(&tcm->yellow_action, yellow_action);
649: tca_import_action(&tcm->red_action, red_action);
650:
651: /* set dscps to use */
652: if (tcm->green_action.tca_code == TCACODE_MARK)
653: tcm->green_dscp = tcm->green_action.tca_dscp & DSCP_MASK;
654: else
655: tcm->green_dscp = DSCP_AF11;
656: if (tcm->yellow_action.tca_code == TCACODE_MARK)
657: tcm->yellow_dscp = tcm->yellow_action.tca_dscp & DSCP_MASK;
658: else
659: tcm->yellow_dscp = DSCP_AF12;
660: if (tcm->red_action.tca_code == TCACODE_MARK)
661: tcm->red_dscp = tcm->red_action.tca_dscp & DSCP_MASK;
662: else
663: tcm->red_dscp = DSCP_AF13;
664:
665: tcm->coloraware = coloraware;
666:
667: return (tcm);
668: }
669:
670: static int
671: trtcm_destroy(tcm)
672: struct trtcm *tcm;
673: {
674: if (tcm->cdnrblk.cb_ref > 0)
675: return (EBUSY);
676:
677: tca_invalidate_action(&tcm->green_action);
678: tca_invalidate_action(&tcm->yellow_action);
679: tca_invalidate_action(&tcm->red_action);
680:
681: cdnr_cbdestroy(tcm);
682: return (0);
683: }
684:
685: static struct tc_action *
686: trtcm_input(cb, pktinfo)
687: struct cdnr_block *cb;
688: struct cdnr_pktinfo *pktinfo;
689: {
690: struct trtcm *tcm = (struct trtcm *)cb;
691: u_int64_t len;
692: u_int64_t interval, now;
693: u_int8_t color;
694:
695: len = TB_SCALE(pktinfo->pkt_len);
696: if (tcm->coloraware) {
697: color = pktinfo->pkt_dscp;
698: if (color != tcm->yellow_dscp && color != tcm->red_dscp)
699: color = tcm->green_dscp;
700: } else {
701: /* if color-blind, precolor it as green */
702: color = tcm->green_dscp;
703: }
704:
705: now = read_machclk();
706: if (tcm->cmtd_tb.token < len) {
707: interval = now - tcm->cmtd_tb.last;
708: if (interval >= tcm->cmtd_tb.filluptime)
709: tcm->cmtd_tb.token = tcm->cmtd_tb.depth;
710: else {
711: tcm->cmtd_tb.token += interval * tcm->cmtd_tb.rate;
712: if (tcm->cmtd_tb.token > tcm->cmtd_tb.depth)
713: tcm->cmtd_tb.token = tcm->cmtd_tb.depth;
714: }
715: tcm->cmtd_tb.last = now;
716: }
717: if (tcm->peak_tb.token < len) {
718: interval = now - tcm->peak_tb.last;
719: if (interval >= tcm->peak_tb.filluptime)
720: tcm->peak_tb.token = tcm->peak_tb.depth;
721: else {
722: tcm->peak_tb.token += interval * tcm->peak_tb.rate;
723: if (tcm->peak_tb.token > tcm->peak_tb.depth)
724: tcm->peak_tb.token = tcm->peak_tb.depth;
725: }
726: tcm->peak_tb.last = now;
727: }
728:
729: if (color == tcm->red_dscp || tcm->peak_tb.token < len) {
730: pktinfo->pkt_dscp = tcm->red_dscp;
731: PKTCNTR_ADD(&tcm->red_cnt, pktinfo->pkt_len);
732: return (&tcm->red_action);
733: }
734:
735: if (color == tcm->yellow_dscp || tcm->cmtd_tb.token < len) {
736: pktinfo->pkt_dscp = tcm->yellow_dscp;
737: tcm->peak_tb.token -= len;
738: PKTCNTR_ADD(&tcm->yellow_cnt, pktinfo->pkt_len);
739: return (&tcm->yellow_action);
740: }
741:
742: pktinfo->pkt_dscp = tcm->green_dscp;
743: tcm->cmtd_tb.token -= len;
744: tcm->peak_tb.token -= len;
745: PKTCNTR_ADD(&tcm->green_cnt, pktinfo->pkt_len);
746: return (&tcm->green_action);
747: }
748:
749: /*
750: * time sliding window three color marker
751: * as described in draft-fang-diffserv-tc-tswtcm-00.txt
752: */
753: static struct tswtcm *
754: tswtcm_create(top, cmtd_rate, peak_rate, avg_interval,
755: green_action, yellow_action, red_action)
756: struct top_cdnr *top;
757: u_int32_t cmtd_rate, peak_rate, avg_interval;
758: struct tc_action *green_action, *yellow_action, *red_action;
759: {
760: struct tswtcm *tsw;
761:
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);
766:
767: if ((tsw = cdnr_cballoc(top, TCETYPE_TSWTCM,
768: tswtcm_input)) == NULL)
769: return (NULL);
770:
771: tca_import_action(&tsw->green_action, green_action);
772: tca_import_action(&tsw->yellow_action, yellow_action);
773: tca_import_action(&tsw->red_action, red_action);
774:
775: /* set dscps to use */
776: if (tsw->green_action.tca_code == TCACODE_MARK)
777: tsw->green_dscp = tsw->green_action.tca_dscp & DSCP_MASK;
778: else
779: tsw->green_dscp = DSCP_AF11;
780: if (tsw->yellow_action.tca_code == TCACODE_MARK)
781: tsw->yellow_dscp = tsw->yellow_action.tca_dscp & DSCP_MASK;
782: else
783: tsw->yellow_dscp = DSCP_AF12;
784: if (tsw->red_action.tca_code == TCACODE_MARK)
785: tsw->red_dscp = tsw->red_action.tca_dscp & DSCP_MASK;
786: else
787: tsw->red_dscp = DSCP_AF13;
788:
789: /* convert rates from bits/sec to bytes/sec */
790: tsw->cmtd_rate = cmtd_rate / 8;
791: tsw->peak_rate = peak_rate / 8;
792: tsw->avg_rate = 0;
793:
794: /* timewin is converted from msec to machine clock unit */
795: tsw->timewin = (u_int64_t)machclk_freq * avg_interval / 1000;
796:
797: return (tsw);
798: }
799:
800: static int
801: tswtcm_destroy(tsw)
802: struct tswtcm *tsw;
803: {
804: if (tsw->cdnrblk.cb_ref > 0)
805: return (EBUSY);
806:
807: tca_invalidate_action(&tsw->green_action);
808: tca_invalidate_action(&tsw->yellow_action);
809: tca_invalidate_action(&tsw->red_action);
810:
811: cdnr_cbdestroy(tsw);
812: return (0);
813: }
814:
815: static struct tc_action *
816: 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;
822: u_int32_t avg_rate;
823: u_int64_t interval, now, tmp;
824:
825: /*
826: * rate estimator
827: */
828: len = pktinfo->pkt_len;
829: now = read_machclk();
830:
831: 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: */
841: tmp = ((u_int64_t)tsw->avg_rate * tsw->timewin
842: + (u_int64_t)len * machclk_freq) / (tsw->timewin + interval);
843: tsw->avg_rate = avg_rate = (u_int32_t)tmp;
844: tsw->t_front = now;
845:
846: /*
847: * marker
848: */
849: if (avg_rate > tsw->cmtd_rate) {
850: u_int32_t randval = random() % avg_rate;
851:
852: if (avg_rate > tsw->peak_rate) {
853: if (randval < avg_rate - tsw->peak_rate) {
854: /* mark red */
855: pktinfo->pkt_dscp = tsw->red_dscp;
856: 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) {
863: mark_yellow:
864: pktinfo->pkt_dscp = tsw->yellow_dscp;
865: PKTCNTR_ADD(&tsw->yellow_cnt, len);
866: return (&tsw->yellow_action);
867: }
868: }
869: }
870:
871: /* mark green */
872: pktinfo->pkt_dscp = tsw->green_dscp;
873: PKTCNTR_ADD(&tsw->green_cnt, len);
874: return (&tsw->green_action);
875: }
876:
877: /*
878: * ioctl requests
879: */
880: static int
881: cdnrcmd_if_attach(ifname)
882: char *ifname;
883: {
884: struct ifnet *ifp;
885: struct top_cdnr *top;
886:
887: if ((ifp = ifunit(ifname)) == NULL)
888: return (EBADF);
889:
890: if (ifp->if_snd.altq_cdnr != NULL)
891: return (EBUSY);
892:
893: if ((top = top_create(&ifp->if_snd)) == NULL)
894: return (ENOMEM);
895: return (0);
896: }
897:
898: static int
899: cdnrcmd_if_detach(ifname)
900: char *ifname;
901: {
902: struct top_cdnr *top;
903:
904: if ((top = tcb_lookup(ifname)) == NULL)
905: return (EBADF);
906:
907: return top_destroy(top);
908: }
909:
910: static int
911: cdnrcmd_add_element(ap)
912: struct cdnr_add_element *ap;
913: {
914: struct top_cdnr *top;
915: struct cdnr_block *cb;
916:
917: if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
918: return (EBADF);
919:
920: cb = element_create(top, &ap->action);
921: if (cb == NULL)
922: return (EINVAL);
923: /* return a class handle to the user */
924: ap->cdnr_handle = cdnr_cb2handle(cb);
925: return (0);
926: }
927:
928: static int
929: cdnrcmd_delete_element(ap)
930: struct cdnr_delete_element *ap;
931: {
932: struct top_cdnr *top;
933: struct cdnr_block *cb;
934:
935: if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
936: return (EBADF);
937:
938: if ((cb = cdnr_handle2cb(ap->cdnr_handle)) == NULL)
939: return (EINVAL);
940:
941: if (cb->cb_type != TCETYPE_ELEMENT)
942: return generic_element_destroy(cb);
943:
944: return element_destroy(cb);
945: }
946:
947: static int
948: cdnrcmd_add_tbm(ap)
949: struct cdnr_add_tbmeter *ap;
950: {
951: struct top_cdnr *top;
952: struct tbmeter *tbm;
953:
954: if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
955: return (EBADF);
956:
957: 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 */
961: ap->cdnr_handle = cdnr_cb2handle(&tbm->cdnrblk);
962: return (0);
963: }
964:
965: static int
966: cdnrcmd_modify_tbm(ap)
967: struct cdnr_modify_tbmeter *ap;
968: {
969: struct tbmeter *tbm;
970:
971: if ((tbm = (struct tbmeter *)cdnr_handle2cb(ap->cdnr_handle)) == NULL)
972: return (EINVAL);
973:
974: tb_import_profile(&tbm->tb, &ap->profile);
975:
976: return (0);
977: }
978:
979: static int
980: cdnrcmd_tbm_stats(ap)
981: struct cdnr_tbmeter_stats *ap;
982: {
983: struct tbmeter *tbm;
984:
985: if ((tbm = (struct tbmeter *)cdnr_handle2cb(ap->cdnr_handle)) == NULL)
986: return (EINVAL);
987:
988: ap->in_cnt = tbm->in_cnt;
989: ap->out_cnt = tbm->out_cnt;
990:
991: return (0);
992: }
993:
994: static int
995: cdnrcmd_add_trtcm(ap)
996: struct cdnr_add_trtcm *ap;
997: {
998: struct top_cdnr *top;
999: struct trtcm *tcm;
1000:
1001: if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
1002: return (EBADF);
1003:
1004: 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);
1009:
1010: /* return a class handle to the user */
1011: ap->cdnr_handle = cdnr_cb2handle(&tcm->cdnrblk);
1012: return (0);
1013: }
1014:
1015: static int
1016: cdnrcmd_modify_trtcm(ap)
1017: struct cdnr_modify_trtcm *ap;
1018: {
1019: struct trtcm *tcm;
1020:
1021: if ((tcm = (struct trtcm *)cdnr_handle2cb(ap->cdnr_handle)) == NULL)
1022: return (EINVAL);
1023:
1024: tb_import_profile(&tcm->cmtd_tb, &ap->cmtd_profile);
1025: tb_import_profile(&tcm->peak_tb, &ap->peak_profile);
1026:
1027: return (0);
1028: }
1029:
1030: static int
1031: cdnrcmd_tcm_stats(ap)
1032: struct cdnr_tcm_stats *ap;
1033: {
1034: struct cdnr_block *cb;
1035:
1036: if ((cb = cdnr_handle2cb(ap->cdnr_handle)) == NULL)
1037: return (EINVAL);
1038:
1039: if (cb->cb_type == TCETYPE_TRTCM) {
1040: struct trtcm *tcm = (struct trtcm *)cb;
1041:
1042: ap->green_cnt = tcm->green_cnt;
1043: ap->yellow_cnt = tcm->yellow_cnt;
1044: ap->red_cnt = tcm->red_cnt;
1045: } else if (cb->cb_type == TCETYPE_TSWTCM) {
1046: struct tswtcm *tsw = (struct tswtcm *)cb;
1047:
1048: ap->green_cnt = tsw->green_cnt;
1049: ap->yellow_cnt = tsw->yellow_cnt;
1050: ap->red_cnt = tsw->red_cnt;
1051: } else
1052: return (EINVAL);
1053:
1054: return (0);
1055: }
1056:
1057: static int
1058: cdnrcmd_add_tswtcm(ap)
1059: struct cdnr_add_tswtcm *ap;
1060: {
1061: struct top_cdnr *top;
1062: struct tswtcm *tsw;
1063:
1064: if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
1065: return (EBADF);
1066:
1067: if (ap->cmtd_rate > ap->peak_rate)
1068: return (EINVAL);
1069:
1070: tsw = tswtcm_create(top, ap->cmtd_rate, ap->peak_rate,
1071: ap->avg_interval, &ap->green_action,
1072: &ap->yellow_action, &ap->red_action);
1073: if (tsw == NULL)
1074: return (EINVAL);
1075:
1076: /* return a class handle to the user */
1077: ap->cdnr_handle = cdnr_cb2handle(&tsw->cdnrblk);
1078: return (0);
1079: }
1080:
1081: static int
1082: cdnrcmd_modify_tswtcm(ap)
1083: struct cdnr_modify_tswtcm *ap;
1084: {
1085: struct tswtcm *tsw;
1086:
1087: if ((tsw = (struct tswtcm *)cdnr_handle2cb(ap->cdnr_handle)) == NULL)
1088: return (EINVAL);
1089:
1090: if (ap->cmtd_rate > ap->peak_rate)
1091: return (EINVAL);
1092:
1093: /* convert rates from bits/sec to bytes/sec */
1094: tsw->cmtd_rate = ap->cmtd_rate / 8;
1095: tsw->peak_rate = ap->peak_rate / 8;
1096: tsw->avg_rate = 0;
1097:
1098: /* timewin is converted from msec to machine clock unit */
1099: tsw->timewin = (u_int64_t)machclk_freq * ap->avg_interval / 1000;
1100:
1101: return (0);
1102: }
1103:
1104: static int
1105: 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;
1115:
1116: if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL)
1117: return (EBADF);
1118:
1119: /* copy action stats */
1120: bcopy(top->tc_cnts, ap->cnts, sizeof(ap->cnts));
1121:
1122: /* stats for each element */
1123: nelements = ap->nelements;
1124: usp = ap->tce_stats;
1125: if (nelements <= 0 || usp == NULL)
1126: return (0);
1127:
1128: nskip = ap->nskip;
1129: n = 0;
1130: LIST_FOREACH(cb, &top->tc_elements, cb_next) {
1131: if (nskip > 0) {
1132: nskip--;
1133: continue;
1134: }
1135:
1136: bzero(&tce, sizeof(tce));
1137: tce.tce_handle = cb->cb_handle;
1138: tce.tce_type = cb->cb_type;
1139: switch (cb->cb_type) {
1140: case TCETYPE_TBMETER:
1141: tbm = (struct tbmeter *)cb;
1142: tce.tce_cnts[0] = tbm->in_cnt;
1143: tce.tce_cnts[1] = tbm->out_cnt;
1144: break;
1145: case TCETYPE_TRTCM:
1146: tcm = (struct trtcm *)cb;
1147: tce.tce_cnts[0] = tcm->green_cnt;
1148: tce.tce_cnts[1] = tcm->yellow_cnt;
1149: tce.tce_cnts[2] = tcm->red_cnt;
1150: break;
1151: case TCETYPE_TSWTCM:
1152: tsw = (struct tswtcm *)cb;
1153: tce.tce_cnts[0] = tsw->green_cnt;
1154: tce.tce_cnts[1] = tsw->yellow_cnt;
1155: tce.tce_cnts[2] = tsw->red_cnt;
1156: break;
1157: default:
1158: continue;
1159: }
1160:
1161: if ((error = copyout((caddr_t)&tce, (caddr_t)usp++,
1162: sizeof(tce))) != 0)
1163: return (error);
1164:
1165: if (++n == nelements)
1166: break;
1167: }
1168: ap->nelements = n;
1169:
1170: return (0);
1171: }