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