1 /* $NetBSD: altq_cdnr.c,v 1.23 2025/01/08 13:00:04 joe Exp $ */ 2 /* $KAME: altq_cdnr.c,v 1.15 2005/04/13 03:44:24 suz Exp $ */ 3 4 /* 5 * Copyright (C) 1999-2002 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/cdefs.h> 31 __KERNEL_RCSID(0, "$NetBSD: altq_cdnr.c,v 1.23 2025/01/08 13:00:04 joe Exp $"); 32 33 #ifdef _KERNEL_OPT 34 #include "opt_altq.h" 35 #include "opt_inet.h" 36 #endif 37 38 #include <sys/param.h> 39 #include <sys/malloc.h> 40 #include <sys/mbuf.h> 41 #include <sys/socket.h> 42 #include <sys/sockio.h> 43 #include <sys/systm.h> 44 #include <sys/proc.h> 45 #include <sys/errno.h> 46 #include <sys/kernel.h> 47 #include <sys/queue.h> 48 #include <sys/kauth.h> 49 #include <sys/cprng.h> 50 51 #include <net/if.h> 52 #include <net/if_types.h> 53 #include <netinet/in.h> 54 #include <netinet/in_systm.h> 55 #include <netinet/ip.h> 56 #ifdef INET6 57 #include <netinet/ip6.h> 58 #endif 59 60 #include <altq/altq.h> 61 #include <altq/altq_conf.h> 62 #include <altq/altq_cdnr.h> 63 64 #ifdef ALTQ3_COMPAT 65 /* 66 * diffserv traffic conditioning module 67 */ 68 69 int altq_cdnr_enabled = 0; 70 71 /* traffic conditioner is enabled by ALTQ_CDNR option in opt_altq.h */ 72 #ifdef ALTQ_CDNR 73 74 /* cdnr_list keeps all cdnr's allocated. */ 75 static LIST_HEAD(, top_cdnr) tcb_list; 76 77 static int altq_cdnr_input(struct mbuf *, int); 78 static struct top_cdnr *tcb_lookup(char *ifname); 79 static struct cdnr_block *cdnr_handle2cb(u_long); 80 static u_long cdnr_cb2handle(struct cdnr_block *); 81 static void *cdnr_cballoc(struct top_cdnr *, int, 82 struct tc_action *(*)(struct cdnr_block *, struct cdnr_pktinfo *)); 83 static void cdnr_cbdestroy(void *); 84 static int tca_verify_action(struct tc_action *); 85 static void tca_import_action(struct tc_action *, struct tc_action *); 86 static void tca_invalidate_action(struct tc_action *); 87 88 static int generic_element_destroy(struct cdnr_block *); 89 static struct top_cdnr *top_create(struct ifaltq *); 90 static int top_destroy(struct top_cdnr *); 91 static struct cdnr_block *element_create(struct top_cdnr *, struct tc_action *); 92 static int element_destroy(struct cdnr_block *); 93 static void tb_import_profile(struct tbe *, struct tb_profile *); 94 static struct tbmeter *tbm_create(struct top_cdnr *, struct tb_profile *, 95 struct tc_action *, struct tc_action *); 96 static int tbm_destroy(struct tbmeter *); 97 static struct tc_action *tbm_input(struct cdnr_block *, struct cdnr_pktinfo *); 98 static struct trtcm *trtcm_create(struct top_cdnr *, 99 struct tb_profile *, struct tb_profile *, 100 struct tc_action *, struct tc_action *, struct tc_action *, 101 int); 102 static int trtcm_destroy(struct trtcm *); 103 static struct tc_action *trtcm_input(struct cdnr_block *, struct cdnr_pktinfo *); 104 static struct tswtcm *tswtcm_create(struct top_cdnr *, 105 u_int32_t, u_int32_t, u_int32_t, 106 struct tc_action *, struct tc_action *, struct tc_action *); 107 static int tswtcm_destroy(struct tswtcm *); 108 static struct tc_action *tswtcm_input(struct cdnr_block *, struct cdnr_pktinfo *); 109 110 static int cdnrcmd_if_attach(char *); 111 static int cdnrcmd_if_detach(char *); 112 static int cdnrcmd_add_element(struct cdnr_add_element *); 113 static int cdnrcmd_delete_element(struct cdnr_delete_element *); 114 static int cdnrcmd_add_filter(struct cdnr_add_filter *); 115 static int cdnrcmd_delete_filter(struct cdnr_delete_filter *); 116 static int cdnrcmd_add_tbm(struct cdnr_add_tbmeter *); 117 static int cdnrcmd_modify_tbm(struct cdnr_modify_tbmeter *); 118 static int cdnrcmd_tbm_stats(struct cdnr_tbmeter_stats *); 119 static int cdnrcmd_add_trtcm(struct cdnr_add_trtcm *); 120 static int cdnrcmd_modify_trtcm(struct cdnr_modify_trtcm *); 121 static int cdnrcmd_tcm_stats(struct cdnr_tcm_stats *); 122 static int cdnrcmd_add_tswtcm(struct cdnr_add_tswtcm *); 123 static int cdnrcmd_modify_tswtcm(struct cdnr_modify_tswtcm *); 124 static int cdnrcmd_get_stats(struct cdnr_get_stats *); 125 126 altqdev_decl(cdnr); 127 128 /* 129 * top level input function called from ip_input. 130 * should be called before converting header fields to host-byte-order. 131 */ 132 int 133 altq_cdnr_input(struct mbuf *m, int af) 134 { 135 struct ifnet *ifp; 136 struct ip *ip; 137 struct top_cdnr *top; 138 struct tc_action *tca; 139 struct cdnr_block *cb; 140 struct cdnr_pktinfo pktinfo; 141 142 ifp = m_get_rcvif_NOMPSAFE(m); 143 if (!ALTQ_IS_CNDTNING(&ifp->if_snd)) 144 /* traffic conditioner is not enabled on this interface */ 145 return 1; 146 147 top = ifp->if_snd.altq_cdnr; 148 149 ip = mtod(m, struct ip *); 150 #ifdef INET6 151 if (af == AF_INET6) { 152 u_int32_t flowlabel; 153 154 flowlabel = ((struct ip6_hdr *)ip)->ip6_flow; 155 pktinfo.pkt_dscp = (ntohl(flowlabel) >> 20) & DSCP_MASK; 156 } else 157 #endif 158 pktinfo.pkt_dscp = ip->ip_tos & DSCP_MASK; 159 pktinfo.pkt_len = m_pktlen(m); 160 161 tca = NULL; 162 163 cb = acc_classify(&top->tc_classifier, m, af); 164 if (cb != NULL) 165 tca = &cb->cb_action; 166 167 if (tca == NULL) 168 tca = &top->tc_block.cb_action; 169 170 while (1) { 171 PKTCNTR_ADD(&top->tc_cnts[tca->tca_code], pktinfo.pkt_len); 172 173 switch (tca->tca_code) { 174 case TCACODE_PASS: 175 return 1; 176 case TCACODE_DROP: 177 m_freem(m); 178 return 0; 179 case TCACODE_RETURN: 180 return 0; 181 case TCACODE_MARK: 182 #ifdef INET6 183 if (af == AF_INET6) { 184 struct ip6_hdr *ip6 = (struct ip6_hdr *)ip; 185 u_int32_t flowlabel; 186 187 flowlabel = ntohl(ip6->ip6_flow); 188 flowlabel = (tca->tca_dscp << 20) | 189 (flowlabel & ~(DSCP_MASK << 20)); 190 ip6->ip6_flow = htonl(flowlabel); 191 } else 192 #endif 193 ip->ip_tos = tca->tca_dscp | 194 (ip->ip_tos & DSCP_CUMASK); 195 return 1; 196 case TCACODE_NEXT: 197 cb = tca->tca_next; 198 tca = (*cb->cb_input)(cb, &pktinfo); 199 break; 200 case TCACODE_NONE: 201 default: 202 return 1; 203 } 204 } 205 } 206 207 static struct top_cdnr * 208 tcb_lookup(char *ifname) 209 { 210 struct top_cdnr *top; 211 struct ifnet *ifp; 212 213 if ((ifp = ifunit(ifname)) != NULL) 214 LIST_FOREACH(top, &tcb_list, tc_next) 215 if (top->tc_ifq->altq_ifp == ifp) 216 return top; 217 return NULL; 218 } 219 220 static struct cdnr_block * 221 cdnr_handle2cb(u_long handle) 222 { 223 struct cdnr_block *cb; 224 225 cb = (struct cdnr_block *)handle; 226 if (handle != ALIGN(cb)) 227 return NULL; 228 229 if (cb == NULL || cb->cb_handle != handle) 230 return NULL; 231 return cb; 232 } 233 234 static u_long 235 cdnr_cb2handle(struct cdnr_block *cb) 236 { 237 return (cb->cb_handle); 238 } 239 240 static void * 241 cdnr_cballoc(struct top_cdnr *top, int type, struct tc_action *(*input_func)( 242 struct cdnr_block *, struct cdnr_pktinfo *)) 243 { 244 struct cdnr_block *cb; 245 int size; 246 247 switch (type) { 248 case TCETYPE_TOP: 249 size = sizeof(struct top_cdnr); 250 break; 251 case TCETYPE_ELEMENT: 252 size = sizeof(struct cdnr_block); 253 break; 254 case TCETYPE_TBMETER: 255 size = sizeof(struct tbmeter); 256 break; 257 case TCETYPE_TRTCM: 258 size = sizeof(struct trtcm); 259 break; 260 case TCETYPE_TSWTCM: 261 size = sizeof(struct tswtcm); 262 break; 263 default: 264 return NULL; 265 } 266 267 cb = malloc(size, M_DEVBUF, M_WAITOK|M_ZERO); 268 if (cb == NULL) 269 return NULL; 270 271 cb->cb_len = size; 272 cb->cb_type = type; 273 cb->cb_ref = 0; 274 cb->cb_handle = (u_long)cb; 275 if (top == NULL) 276 cb->cb_top = (struct top_cdnr *)cb; 277 else 278 cb->cb_top = top; 279 280 if (input_func != NULL) { 281 /* 282 * if this cdnr has an action function, 283 * make tc_action to call itself. 284 */ 285 cb->cb_action.tca_code = TCACODE_NEXT; 286 cb->cb_action.tca_next = cb; 287 cb->cb_input = input_func; 288 } else 289 cb->cb_action.tca_code = TCACODE_NONE; 290 291 /* if this isn't top, register the element to the top level cdnr */ 292 if (top != NULL) 293 LIST_INSERT_HEAD(&top->tc_elements, cb, cb_next); 294 295 return ((void *)cb); 296 } 297 298 static void 299 cdnr_cbdestroy(void *cblock) 300 { 301 struct cdnr_block *cb = cblock; 302 303 /* delete filters belonging to this cdnr */ 304 acc_discard_filters(&cb->cb_top->tc_classifier, cb, 0); 305 306 /* remove from the top level cdnr */ 307 if (cb->cb_top != cblock) 308 LIST_REMOVE(cb, cb_next); 309 310 free(cb, M_DEVBUF); 311 } 312 313 /* 314 * conditioner common destroy routine 315 */ 316 static int 317 generic_element_destroy(struct cdnr_block *cb) 318 { 319 int error = 0; 320 321 switch (cb->cb_type) { 322 case TCETYPE_TOP: 323 error = top_destroy((struct top_cdnr *)cb); 324 break; 325 case TCETYPE_ELEMENT: 326 error = element_destroy(cb); 327 break; 328 case TCETYPE_TBMETER: 329 error = tbm_destroy((struct tbmeter *)cb); 330 break; 331 case TCETYPE_TRTCM: 332 error = trtcm_destroy((struct trtcm *)cb); 333 break; 334 case TCETYPE_TSWTCM: 335 error = tswtcm_destroy((struct tswtcm *)cb); 336 break; 337 default: 338 error = EINVAL; 339 } 340 return error; 341 } 342 343 static int 344 tca_verify_action(struct tc_action *utca) 345 { 346 switch (utca->tca_code) { 347 case TCACODE_PASS: 348 case TCACODE_DROP: 349 case TCACODE_MARK: 350 /* these are ok */ 351 break; 352 353 case TCACODE_HANDLE: 354 /* verify handle value */ 355 if (cdnr_handle2cb(utca->tca_handle) == NULL) 356 return -1; 357 break; 358 359 case TCACODE_NONE: 360 case TCACODE_RETURN: 361 case TCACODE_NEXT: 362 default: 363 /* should not be passed from a user */ 364 return -1; 365 } 366 return 0; 367 } 368 369 static void 370 tca_import_action(struct tc_action *ktca, struct tc_action *utca) 371 { 372 struct cdnr_block *cb; 373 374 *ktca = *utca; 375 if (ktca->tca_code == TCACODE_HANDLE) { 376 cb = cdnr_handle2cb(ktca->tca_handle); 377 if (cb == NULL) { 378 ktca->tca_code = TCACODE_NONE; 379 return; 380 } 381 ktca->tca_code = TCACODE_NEXT; 382 ktca->tca_next = cb; 383 cb->cb_ref++; 384 } else if (ktca->tca_code == TCACODE_MARK) { 385 ktca->tca_dscp &= DSCP_MASK; 386 } 387 return; 388 } 389 390 static void 391 tca_invalidate_action(struct tc_action *tca) 392 { 393 struct cdnr_block *cb; 394 395 if (tca->tca_code == TCACODE_NEXT) { 396 cb = tca->tca_next; 397 if (cb == NULL) 398 return; 399 cb->cb_ref--; 400 } 401 tca->tca_code = TCACODE_NONE; 402 } 403 404 /* 405 * top level traffic conditioner 406 */ 407 static struct top_cdnr * 408 top_create(struct ifaltq *ifq) 409 { 410 struct top_cdnr *top; 411 412 if ((top = cdnr_cballoc(NULL, TCETYPE_TOP, NULL)) == NULL) 413 return NULL; 414 415 top->tc_ifq = ifq; 416 /* set default action for the top level conditioner */ 417 top->tc_block.cb_action.tca_code = TCACODE_PASS; 418 419 LIST_INSERT_HEAD(&tcb_list, top, tc_next); 420 421 ifq->altq_cdnr = top; 422 423 return top; 424 } 425 426 static int 427 top_destroy(struct top_cdnr *top) 428 { 429 struct cdnr_block *cb; 430 431 if (ALTQ_IS_CNDTNING(top->tc_ifq)) 432 ALTQ_CLEAR_CNDTNING(top->tc_ifq); 433 top->tc_ifq->altq_cdnr = NULL; 434 435 /* 436 * destroy all the conditioner elements belonging to this interface 437 */ 438 while ((cb = LIST_FIRST(&top->tc_elements)) != NULL) { 439 while (cb != NULL && cb->cb_ref > 0) 440 cb = LIST_NEXT(cb, cb_next); 441 if (cb != NULL) 442 generic_element_destroy(cb); 443 } 444 445 LIST_REMOVE(top, tc_next); 446 447 cdnr_cbdestroy(top); 448 449 /* if there is no active conditioner, remove the input hook */ 450 if (altq_input != NULL) { 451 LIST_FOREACH(top, &tcb_list, tc_next) 452 if (ALTQ_IS_CNDTNING(top->tc_ifq)) 453 break; 454 if (top == NULL) 455 altq_input = NULL; 456 } 457 458 return 0; 459 } 460 461 /* 462 * simple tc elements without input function (e.g., dropper and makers). 463 */ 464 static struct cdnr_block * 465 element_create(struct top_cdnr *top, struct tc_action *action) 466 { 467 struct cdnr_block *cb; 468 469 if (tca_verify_action(action) < 0) 470 return NULL; 471 472 if ((cb = cdnr_cballoc(top, TCETYPE_ELEMENT, NULL)) == NULL) 473 return NULL; 474 475 tca_import_action(&cb->cb_action, action); 476 477 return cb; 478 } 479 480 static int 481 element_destroy(struct cdnr_block *cb) 482 { 483 if (cb->cb_ref > 0) 484 return EBUSY; 485 486 tca_invalidate_action(&cb->cb_action); 487 488 cdnr_cbdestroy(cb); 489 return 0; 490 } 491 492 /* 493 * internal representation of token bucket parameters 494 * rate: byte_per_unittime << 32 495 * (((bits_per_sec) / 8) << 32) / machclk_freq 496 * depth: byte << 32 497 * 498 */ 499 #define TB_SHIFT 32 500 #define TB_SCALE(x) ((u_int64_t)(x) << TB_SHIFT) 501 #define TB_UNSCALE(x) ((x) >> TB_SHIFT) 502 503 static void 504 tb_import_profile(struct tbe *tb, struct tb_profile *profile) 505 { 506 tb->rate = TB_SCALE(profile->rate / 8) / machclk_freq; 507 tb->depth = TB_SCALE(profile->depth); 508 if (tb->rate > 0) 509 tb->filluptime = tb->depth / tb->rate; 510 else 511 tb->filluptime = 0xffffffffffffffffLL; 512 tb->token = tb->depth; 513 tb->last = read_machclk(); 514 } 515 516 /* 517 * simple token bucket meter 518 */ 519 static struct tbmeter * 520 tbm_create(struct top_cdnr *top, struct tb_profile *profile, 521 struct tc_action *in_action, struct tc_action *out_action) 522 { 523 struct tbmeter *tbm = NULL; 524 525 if (tca_verify_action(in_action) < 0 526 || tca_verify_action(out_action) < 0) 527 return NULL; 528 529 if ((tbm = cdnr_cballoc(top, TCETYPE_TBMETER, 530 tbm_input)) == NULL) 531 return NULL; 532 533 tb_import_profile(&tbm->tb, profile); 534 535 tca_import_action(&tbm->in_action, in_action); 536 tca_import_action(&tbm->out_action, out_action); 537 538 return tbm; 539 } 540 541 static int 542 tbm_destroy(struct tbmeter *tbm) 543 { 544 if (tbm->cdnrblk.cb_ref > 0) 545 return EBUSY; 546 547 tca_invalidate_action(&tbm->in_action); 548 tca_invalidate_action(&tbm->out_action); 549 550 cdnr_cbdestroy(tbm); 551 return 0; 552 } 553 554 static struct tc_action * 555 tbm_input(struct cdnr_block *cb, struct cdnr_pktinfo *pktinfo) 556 { 557 struct tbmeter *tbm = (struct tbmeter *)cb; 558 u_int64_t len; 559 u_int64_t interval, now; 560 561 len = TB_SCALE(pktinfo->pkt_len); 562 563 if (tbm->tb.token < len) { 564 now = read_machclk(); 565 interval = now - tbm->tb.last; 566 if (interval >= tbm->tb.filluptime) 567 tbm->tb.token = tbm->tb.depth; 568 else { 569 tbm->tb.token += interval * tbm->tb.rate; 570 if (tbm->tb.token > tbm->tb.depth) 571 tbm->tb.token = tbm->tb.depth; 572 } 573 tbm->tb.last = now; 574 } 575 576 if (tbm->tb.token < len) { 577 PKTCNTR_ADD(&tbm->out_cnt, pktinfo->pkt_len); 578 return (&tbm->out_action); 579 } 580 581 tbm->tb.token -= len; 582 PKTCNTR_ADD(&tbm->in_cnt, pktinfo->pkt_len); 583 return (&tbm->in_action); 584 } 585 586 /* 587 * two rate three color marker 588 * as described in draft-heinanen-diffserv-trtcm-01.txt 589 */ 590 static struct trtcm * 591 trtcm_create(struct top_cdnr *top, struct tb_profile *cmtd_profile, 592 struct tb_profile *peak_profile, struct tc_action *green_action, 593 struct tc_action *yellow_action, struct tc_action *red_action, 594 int coloraware) 595 { 596 struct trtcm *tcm = NULL; 597 598 if (tca_verify_action(green_action) < 0 599 || tca_verify_action(yellow_action) < 0 600 || tca_verify_action(red_action) < 0) 601 return NULL; 602 603 if ((tcm = cdnr_cballoc(top, TCETYPE_TRTCM, 604 trtcm_input)) == NULL) 605 return NULL; 606 607 tb_import_profile(&tcm->cmtd_tb, cmtd_profile); 608 tb_import_profile(&tcm->peak_tb, peak_profile); 609 610 tca_import_action(&tcm->green_action, green_action); 611 tca_import_action(&tcm->yellow_action, yellow_action); 612 tca_import_action(&tcm->red_action, red_action); 613 614 /* set dscps to use */ 615 if (tcm->green_action.tca_code == TCACODE_MARK) 616 tcm->green_dscp = tcm->green_action.tca_dscp & DSCP_MASK; 617 else 618 tcm->green_dscp = DSCP_AF11; 619 if (tcm->yellow_action.tca_code == TCACODE_MARK) 620 tcm->yellow_dscp = tcm->yellow_action.tca_dscp & DSCP_MASK; 621 else 622 tcm->yellow_dscp = DSCP_AF12; 623 if (tcm->red_action.tca_code == TCACODE_MARK) 624 tcm->red_dscp = tcm->red_action.tca_dscp & DSCP_MASK; 625 else 626 tcm->red_dscp = DSCP_AF13; 627 628 tcm->coloraware = coloraware; 629 630 return tcm; 631 } 632 633 static int 634 trtcm_destroy(struct trtcm *tcm) 635 { 636 if (tcm->cdnrblk.cb_ref > 0) 637 return EBUSY; 638 639 tca_invalidate_action(&tcm->green_action); 640 tca_invalidate_action(&tcm->yellow_action); 641 tca_invalidate_action(&tcm->red_action); 642 643 cdnr_cbdestroy(tcm); 644 return 0; 645 } 646 647 static struct tc_action * 648 trtcm_input(struct cdnr_block *cb, struct cdnr_pktinfo *pktinfo) 649 { 650 struct trtcm *tcm = (struct trtcm *)cb; 651 u_int64_t len; 652 u_int64_t interval, now; 653 u_int8_t color; 654 655 len = TB_SCALE(pktinfo->pkt_len); 656 if (tcm->coloraware) { 657 color = pktinfo->pkt_dscp; 658 if (color != tcm->yellow_dscp && color != tcm->red_dscp) 659 color = tcm->green_dscp; 660 } else { 661 /* if color-blind, precolor it as green */ 662 color = tcm->green_dscp; 663 } 664 665 now = read_machclk(); 666 if (tcm->cmtd_tb.token < len) { 667 interval = now - tcm->cmtd_tb.last; 668 if (interval >= tcm->cmtd_tb.filluptime) 669 tcm->cmtd_tb.token = tcm->cmtd_tb.depth; 670 else { 671 tcm->cmtd_tb.token += interval * tcm->cmtd_tb.rate; 672 if (tcm->cmtd_tb.token > tcm->cmtd_tb.depth) 673 tcm->cmtd_tb.token = tcm->cmtd_tb.depth; 674 } 675 tcm->cmtd_tb.last = now; 676 } 677 if (tcm->peak_tb.token < len) { 678 interval = now - tcm->peak_tb.last; 679 if (interval >= tcm->peak_tb.filluptime) 680 tcm->peak_tb.token = tcm->peak_tb.depth; 681 else { 682 tcm->peak_tb.token += interval * tcm->peak_tb.rate; 683 if (tcm->peak_tb.token > tcm->peak_tb.depth) 684 tcm->peak_tb.token = tcm->peak_tb.depth; 685 } 686 tcm->peak_tb.last = now; 687 } 688 689 if (color == tcm->red_dscp || tcm->peak_tb.token < len) { 690 pktinfo->pkt_dscp = tcm->red_dscp; 691 PKTCNTR_ADD(&tcm->red_cnt, pktinfo->pkt_len); 692 return (&tcm->red_action); 693 } 694 695 if (color == tcm->yellow_dscp || tcm->cmtd_tb.token < len) { 696 pktinfo->pkt_dscp = tcm->yellow_dscp; 697 tcm->peak_tb.token -= len; 698 PKTCNTR_ADD(&tcm->yellow_cnt, pktinfo->pkt_len); 699 return (&tcm->yellow_action); 700 } 701 702 pktinfo->pkt_dscp = tcm->green_dscp; 703 tcm->cmtd_tb.token -= len; 704 tcm->peak_tb.token -= len; 705 PKTCNTR_ADD(&tcm->green_cnt, pktinfo->pkt_len); 706 return (&tcm->green_action); 707 } 708 709 /* 710 * time sliding window three color marker 711 * as described in draft-fang-diffserv-tc-tswtcm-00.txt 712 */ 713 static struct tswtcm * 714 tswtcm_create(struct top_cdnr *top, u_int32_t cmtd_rate, u_int32_t peak_rate, 715 u_int32_t avg_interval, struct tc_action *green_action, 716 struct tc_action *yellow_action, struct tc_action *red_action) 717 { 718 struct tswtcm *tsw; 719 720 if (tca_verify_action(green_action) < 0 721 || tca_verify_action(yellow_action) < 0 722 || tca_verify_action(red_action) < 0) 723 return NULL; 724 725 if ((tsw = cdnr_cballoc(top, TCETYPE_TSWTCM, 726 tswtcm_input)) == NULL) 727 return NULL; 728 729 tca_import_action(&tsw->green_action, green_action); 730 tca_import_action(&tsw->yellow_action, yellow_action); 731 tca_import_action(&tsw->red_action, red_action); 732 733 /* set dscps to use */ 734 if (tsw->green_action.tca_code == TCACODE_MARK) 735 tsw->green_dscp = tsw->green_action.tca_dscp & DSCP_MASK; 736 else 737 tsw->green_dscp = DSCP_AF11; 738 if (tsw->yellow_action.tca_code == TCACODE_MARK) 739 tsw->yellow_dscp = tsw->yellow_action.tca_dscp & DSCP_MASK; 740 else 741 tsw->yellow_dscp = DSCP_AF12; 742 if (tsw->red_action.tca_code == TCACODE_MARK) 743 tsw->red_dscp = tsw->red_action.tca_dscp & DSCP_MASK; 744 else 745 tsw->red_dscp = DSCP_AF13; 746 747 /* convert rates from bits/sec to bytes/sec */ 748 tsw->cmtd_rate = cmtd_rate / 8; 749 tsw->peak_rate = peak_rate / 8; 750 tsw->avg_rate = 0; 751 752 /* timewin is converted from msec to machine clock unit */ 753 tsw->timewin = (u_int64_t)machclk_freq * avg_interval / 1000; 754 755 return tsw; 756 } 757 758 static int 759 tswtcm_destroy(struct tswtcm *tsw) 760 { 761 if (tsw->cdnrblk.cb_ref > 0) 762 return EBUSY; 763 764 tca_invalidate_action(&tsw->green_action); 765 tca_invalidate_action(&tsw->yellow_action); 766 tca_invalidate_action(&tsw->red_action); 767 768 cdnr_cbdestroy(tsw); 769 return 0; 770 } 771 772 static struct tc_action * 773 tswtcm_input(struct cdnr_block *cb, struct cdnr_pktinfo *pktinfo) 774 { 775 struct tswtcm *tsw = (struct tswtcm *)cb; 776 int len; 777 u_int32_t avg_rate; 778 u_int64_t interval, now, tmp; 779 780 /* 781 * rate estimator 782 */ 783 len = pktinfo->pkt_len; 784 now = read_machclk(); 785 786 interval = now - tsw->t_front; 787 /* 788 * calculate average rate: 789 * avg = (avg * timewin + pkt_len)/(timewin + interval) 790 * pkt_len needs to be multiplied by machclk_freq in order to 791 * get (bytes/sec). 792 * note: when avg_rate (bytes/sec) and timewin (machclk unit) are 793 * less than 32 bits, the following 64-bit operation has enough 794 * precision. 795 */ 796 tmp = ((u_int64_t)tsw->avg_rate * tsw->timewin 797 + (u_int64_t)len * machclk_freq) / (tsw->timewin + interval); 798 tsw->avg_rate = avg_rate = (u_int32_t)tmp; 799 tsw->t_front = now; 800 801 /* 802 * marker 803 */ 804 if (avg_rate > tsw->cmtd_rate) { 805 u_int32_t randval = cprng_fast32() % avg_rate; 806 807 if (avg_rate > tsw->peak_rate) { 808 if (randval < avg_rate - tsw->peak_rate) { 809 /* mark red */ 810 pktinfo->pkt_dscp = tsw->red_dscp; 811 PKTCNTR_ADD(&tsw->red_cnt, len); 812 return (&tsw->red_action); 813 } else if (randval < avg_rate - tsw->cmtd_rate) 814 goto mark_yellow; 815 } else { 816 /* peak_rate >= avg_rate > cmtd_rate */ 817 if (randval < avg_rate - tsw->cmtd_rate) { 818 mark_yellow: 819 pktinfo->pkt_dscp = tsw->yellow_dscp; 820 PKTCNTR_ADD(&tsw->yellow_cnt, len); 821 return (&tsw->yellow_action); 822 } 823 } 824 } 825 826 /* mark green */ 827 pktinfo->pkt_dscp = tsw->green_dscp; 828 PKTCNTR_ADD(&tsw->green_cnt, len); 829 return (&tsw->green_action); 830 } 831 832 /* 833 * ioctl requests 834 */ 835 static int 836 cdnrcmd_if_attach(char *ifname) 837 { 838 struct ifnet *ifp; 839 struct top_cdnr *top; 840 841 if ((ifp = ifunit(ifname)) == NULL) 842 return EBADF; 843 844 if (ifp->if_snd.altq_cdnr != NULL) 845 return EBUSY; 846 847 if ((top = top_create(&ifp->if_snd)) == NULL) 848 return ENOMEM; 849 return 0; 850 } 851 852 static int 853 cdnrcmd_if_detach(char *ifname) 854 { 855 struct top_cdnr *top; 856 857 if ((top = tcb_lookup(ifname)) == NULL) 858 return EBADF; 859 860 return top_destroy(top); 861 } 862 863 static int 864 cdnrcmd_add_element(struct cdnr_add_element *ap) 865 { 866 struct top_cdnr *top; 867 struct cdnr_block *cb; 868 869 if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL) 870 return EBADF; 871 872 cb = element_create(top, &ap->action); 873 if (cb == NULL) 874 return EINVAL; 875 /* return a class handle to the user */ 876 ap->cdnr_handle = cdnr_cb2handle(cb); 877 return 0; 878 } 879 880 static int 881 cdnrcmd_delete_element(struct cdnr_delete_element *ap) 882 { 883 struct top_cdnr *top; 884 struct cdnr_block *cb; 885 886 if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL) 887 return EBADF; 888 889 if ((cb = cdnr_handle2cb(ap->cdnr_handle)) == NULL) 890 return EINVAL; 891 892 if (cb->cb_type != TCETYPE_ELEMENT) 893 return generic_element_destroy(cb); 894 895 return element_destroy(cb); 896 } 897 898 static int 899 cdnrcmd_add_filter(struct cdnr_add_filter *ap) 900 { 901 struct top_cdnr *top; 902 struct cdnr_block *cb; 903 904 if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL) 905 return EBADF; 906 907 if ((cb = cdnr_handle2cb(ap->cdnr_handle)) == NULL) 908 return EINVAL; 909 910 return acc_add_filter(&top->tc_classifier, &ap->filter, 911 cb, &ap->filter_handle); 912 } 913 914 static int 915 cdnrcmd_delete_filter(struct cdnr_delete_filter *ap) 916 { 917 struct top_cdnr *top; 918 919 if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL) 920 return EBADF; 921 922 return acc_delete_filter(&top->tc_classifier, ap->filter_handle); 923 } 924 925 static int 926 cdnrcmd_add_tbm(struct cdnr_add_tbmeter *ap) 927 { 928 struct top_cdnr *top; 929 struct tbmeter *tbm; 930 931 if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL) 932 return EBADF; 933 934 tbm = tbm_create(top, &ap->profile, &ap->in_action, &ap->out_action); 935 if (tbm == NULL) 936 return EINVAL; 937 /* return a class handle to the user */ 938 ap->cdnr_handle = cdnr_cb2handle(&tbm->cdnrblk); 939 return 0; 940 } 941 942 static int 943 cdnrcmd_modify_tbm(struct cdnr_modify_tbmeter *ap) 944 { 945 struct tbmeter *tbm; 946 947 if ((tbm = (struct tbmeter *)cdnr_handle2cb(ap->cdnr_handle)) == NULL) 948 return EINVAL; 949 950 tb_import_profile(&tbm->tb, &ap->profile); 951 952 return 0; 953 } 954 955 static int 956 cdnrcmd_tbm_stats(struct cdnr_tbmeter_stats *ap) 957 { 958 struct tbmeter *tbm; 959 960 if ((tbm = (struct tbmeter *)cdnr_handle2cb(ap->cdnr_handle)) == NULL) 961 return EINVAL; 962 963 ap->in_cnt = tbm->in_cnt; 964 ap->out_cnt = tbm->out_cnt; 965 966 return 0; 967 } 968 969 static int 970 cdnrcmd_add_trtcm(struct cdnr_add_trtcm *ap) 971 { 972 struct top_cdnr *top; 973 struct trtcm *tcm; 974 975 if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL) 976 return EBADF; 977 978 tcm = trtcm_create(top, &ap->cmtd_profile, &ap->peak_profile, 979 &ap->green_action, &ap->yellow_action, 980 &ap->red_action, ap->coloraware); 981 if (tcm == NULL) 982 return EINVAL; 983 984 /* return a class handle to the user */ 985 ap->cdnr_handle = cdnr_cb2handle(&tcm->cdnrblk); 986 return 0; 987 } 988 989 static int 990 cdnrcmd_modify_trtcm(struct cdnr_modify_trtcm *ap) 991 { 992 struct trtcm *tcm; 993 994 if ((tcm = (struct trtcm *)cdnr_handle2cb(ap->cdnr_handle)) == NULL) 995 return EINVAL; 996 997 tb_import_profile(&tcm->cmtd_tb, &ap->cmtd_profile); 998 tb_import_profile(&tcm->peak_tb, &ap->peak_profile); 999 1000 return 0; 1001 } 1002 1003 static int 1004 cdnrcmd_tcm_stats(struct cdnr_tcm_stats *ap) 1005 { 1006 struct cdnr_block *cb; 1007 1008 if ((cb = cdnr_handle2cb(ap->cdnr_handle)) == NULL) 1009 return EINVAL; 1010 1011 if (cb->cb_type == TCETYPE_TRTCM) { 1012 struct trtcm *tcm = (struct trtcm *)cb; 1013 1014 ap->green_cnt = tcm->green_cnt; 1015 ap->yellow_cnt = tcm->yellow_cnt; 1016 ap->red_cnt = tcm->red_cnt; 1017 } else if (cb->cb_type == TCETYPE_TSWTCM) { 1018 struct tswtcm *tsw = (struct tswtcm *)cb; 1019 1020 ap->green_cnt = tsw->green_cnt; 1021 ap->yellow_cnt = tsw->yellow_cnt; 1022 ap->red_cnt = tsw->red_cnt; 1023 } else 1024 return EINVAL; 1025 1026 return 0; 1027 } 1028 1029 static int 1030 cdnrcmd_add_tswtcm(struct cdnr_add_tswtcm *ap) 1031 { 1032 struct top_cdnr *top; 1033 struct tswtcm *tsw; 1034 1035 if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL) 1036 return EBADF; 1037 1038 if (ap->cmtd_rate > ap->peak_rate) 1039 return EINVAL; 1040 1041 tsw = tswtcm_create(top, ap->cmtd_rate, ap->peak_rate, 1042 ap->avg_interval, &ap->green_action, 1043 &ap->yellow_action, &ap->red_action); 1044 if (tsw == NULL) 1045 return EINVAL; 1046 1047 /* return a class handle to the user */ 1048 ap->cdnr_handle = cdnr_cb2handle(&tsw->cdnrblk); 1049 return 0; 1050 } 1051 1052 static int 1053 cdnrcmd_modify_tswtcm(struct cdnr_modify_tswtcm *ap) 1054 { 1055 struct tswtcm *tsw; 1056 1057 if ((tsw = (struct tswtcm *)cdnr_handle2cb(ap->cdnr_handle)) == NULL) 1058 return EINVAL; 1059 1060 if (ap->cmtd_rate > ap->peak_rate) 1061 return EINVAL; 1062 1063 /* convert rates from bits/sec to bytes/sec */ 1064 tsw->cmtd_rate = ap->cmtd_rate / 8; 1065 tsw->peak_rate = ap->peak_rate / 8; 1066 tsw->avg_rate = 0; 1067 1068 /* timewin is converted from msec to machine clock unit */ 1069 tsw->timewin = (u_int64_t)machclk_freq * ap->avg_interval / 1000; 1070 1071 return 0; 1072 } 1073 1074 static int 1075 cdnrcmd_get_stats(struct cdnr_get_stats *ap) 1076 { 1077 struct top_cdnr *top; 1078 struct cdnr_block *cb; 1079 struct tbmeter *tbm; 1080 struct trtcm *tcm; 1081 struct tswtcm *tsw; 1082 struct tce_stats tce, *usp; 1083 int error, n, nskip, nelements; 1084 1085 if ((top = tcb_lookup(ap->iface.cdnr_ifname)) == NULL) 1086 return EBADF; 1087 1088 /* copy action stats */ 1089 (void)memcpy(ap->cnts, top->tc_cnts, sizeof(ap->cnts)); 1090 1091 /* stats for each element */ 1092 nelements = ap->nelements; 1093 usp = ap->tce_stats; 1094 if (nelements <= 0 || usp == NULL) 1095 return 0; 1096 1097 nskip = ap->nskip; 1098 n = 0; 1099 LIST_FOREACH(cb, &top->tc_elements, cb_next) { 1100 if (nskip > 0) { 1101 nskip--; 1102 continue; 1103 } 1104 1105 (void)memset(&tce, 0, sizeof(tce)); 1106 tce.tce_handle = cb->cb_handle; 1107 tce.tce_type = cb->cb_type; 1108 switch (cb->cb_type) { 1109 case TCETYPE_TBMETER: 1110 tbm = (struct tbmeter *)cb; 1111 tce.tce_cnts[0] = tbm->in_cnt; 1112 tce.tce_cnts[1] = tbm->out_cnt; 1113 break; 1114 case TCETYPE_TRTCM: 1115 tcm = (struct trtcm *)cb; 1116 tce.tce_cnts[0] = tcm->green_cnt; 1117 tce.tce_cnts[1] = tcm->yellow_cnt; 1118 tce.tce_cnts[2] = tcm->red_cnt; 1119 break; 1120 case TCETYPE_TSWTCM: 1121 tsw = (struct tswtcm *)cb; 1122 tce.tce_cnts[0] = tsw->green_cnt; 1123 tce.tce_cnts[1] = tsw->yellow_cnt; 1124 tce.tce_cnts[2] = tsw->red_cnt; 1125 break; 1126 default: 1127 continue; 1128 } 1129 1130 if ((error = copyout((void *)&tce, (void *)usp++, 1131 sizeof(tce))) != 0) 1132 return error; 1133 1134 if (++n == nelements) 1135 break; 1136 } 1137 ap->nelements = n; 1138 1139 return 0; 1140 } 1141 1142 /* 1143 * conditioner device interface 1144 */ 1145 int 1146 cdnropen(dev_t dev, int flag, int fmt, 1147 struct lwp *l) 1148 { 1149 if (machclk_freq == 0) 1150 init_machclk(); 1151 1152 if (machclk_freq == 0) { 1153 printf("cdnr: no CPU clock available!\n"); 1154 return ENXIO; 1155 } 1156 1157 /* everything will be done when the queueing scheme is attached. */ 1158 return 0; 1159 } 1160 1161 int 1162 cdnrclose(dev_t dev, int flag, int fmt, 1163 struct lwp *l) 1164 { 1165 struct top_cdnr *top; 1166 int err, error = 0; 1167 1168 while ((top = LIST_FIRST(&tcb_list)) != NULL) { 1169 /* destroy all */ 1170 err = top_destroy(top); 1171 if (err != 0 && error == 0) 1172 error = err; 1173 } 1174 altq_input = NULL; 1175 1176 return error; 1177 } 1178 1179 int 1180 cdnrioctl(dev_t dev, ioctlcmd_t cmd, void *addr, int flag, 1181 struct lwp *l) 1182 { 1183 struct top_cdnr *top; 1184 struct cdnr_interface *ifacep; 1185 int s, error = 0; 1186 1187 /* check super-user privilege */ 1188 switch (cmd) { 1189 case CDNR_GETSTATS: 1190 break; 1191 default: 1192 if ((error = kauth_authorize_network(l->l_cred, 1193 KAUTH_NETWORK_ALTQ, KAUTH_REQ_NETWORK_ALTQ_CDNR, NULL, 1194 NULL, NULL)) != 0) 1195 return (error); 1196 break; 1197 } 1198 1199 s = splnet(); 1200 switch (cmd) { 1201 1202 case CDNR_IF_ATTACH: 1203 ifacep = (struct cdnr_interface *)addr; 1204 error = cdnrcmd_if_attach(ifacep->cdnr_ifname); 1205 break; 1206 1207 case CDNR_IF_DETACH: 1208 ifacep = (struct cdnr_interface *)addr; 1209 error = cdnrcmd_if_detach(ifacep->cdnr_ifname); 1210 break; 1211 1212 case CDNR_ENABLE: 1213 case CDNR_DISABLE: 1214 ifacep = (struct cdnr_interface *)addr; 1215 if ((top = tcb_lookup(ifacep->cdnr_ifname)) == NULL) { 1216 error = EBADF; 1217 break; 1218 } 1219 1220 switch (cmd) { 1221 1222 case CDNR_ENABLE: 1223 ALTQ_SET_CNDTNING(top->tc_ifq); 1224 if (altq_input == NULL) 1225 altq_input = altq_cdnr_input; 1226 break; 1227 1228 case CDNR_DISABLE: 1229 ALTQ_CLEAR_CNDTNING(top->tc_ifq); 1230 LIST_FOREACH(top, &tcb_list, tc_next) 1231 if (ALTQ_IS_CNDTNING(top->tc_ifq)) 1232 break; 1233 if (top == NULL) 1234 altq_input = NULL; 1235 break; 1236 } 1237 break; 1238 1239 case CDNR_ADD_ELEM: 1240 error = cdnrcmd_add_element((struct cdnr_add_element *)addr); 1241 break; 1242 1243 case CDNR_DEL_ELEM: 1244 error = cdnrcmd_delete_element((struct cdnr_delete_element *)addr); 1245 break; 1246 1247 case CDNR_ADD_TBM: 1248 error = cdnrcmd_add_tbm((struct cdnr_add_tbmeter *)addr); 1249 break; 1250 1251 case CDNR_MOD_TBM: 1252 error = cdnrcmd_modify_tbm((struct cdnr_modify_tbmeter *)addr); 1253 break; 1254 1255 case CDNR_TBM_STATS: 1256 error = cdnrcmd_tbm_stats((struct cdnr_tbmeter_stats *)addr); 1257 break; 1258 1259 case CDNR_ADD_TCM: 1260 error = cdnrcmd_add_trtcm((struct cdnr_add_trtcm *)addr); 1261 break; 1262 1263 case CDNR_MOD_TCM: 1264 error = cdnrcmd_modify_trtcm((struct cdnr_modify_trtcm *)addr); 1265 break; 1266 1267 case CDNR_TCM_STATS: 1268 error = cdnrcmd_tcm_stats((struct cdnr_tcm_stats *)addr); 1269 break; 1270 1271 case CDNR_ADD_FILTER: 1272 error = cdnrcmd_add_filter((struct cdnr_add_filter *)addr); 1273 break; 1274 1275 case CDNR_DEL_FILTER: 1276 error = cdnrcmd_delete_filter((struct cdnr_delete_filter *)addr); 1277 break; 1278 1279 case CDNR_GETSTATS: 1280 error = cdnrcmd_get_stats((struct cdnr_get_stats *)addr); 1281 break; 1282 1283 case CDNR_ADD_TSW: 1284 error = cdnrcmd_add_tswtcm((struct cdnr_add_tswtcm *)addr); 1285 break; 1286 1287 case CDNR_MOD_TSW: 1288 error = cdnrcmd_modify_tswtcm((struct cdnr_modify_tswtcm *)addr); 1289 break; 1290 1291 default: 1292 error = EINVAL; 1293 break; 1294 } 1295 splx(s); 1296 1297 return error; 1298 } 1299 1300 #ifdef KLD_MODULE 1301 1302 static struct altqsw cdnr_sw = 1303 {"cdnr", cdnropen, cdnrclose, cdnrioctl}; 1304 1305 ALTQ_MODULE(altq_cdnr, ALTQT_CDNR, &cdnr_sw); 1306 1307 #endif /* KLD_MODULE */ 1308 1309 #endif /* ALTQ3_COMPAT */ 1310 #endif /* ALTQ_CDNR */ 1311
Indexes created Sat Sep 20 22:09:52 GMT 2025