1 /* $OpenBSD: pfctl_altq.c,v 1.93 2007/10/15 02:16:35 deraadt Exp $ */ 2 3 /* 4 * Copyright (c) 2002 5 * Sony Computer Science Laboratories Inc. 6 * Copyright (c) 2002, 2003 Henning Brauer <henning@openbsd.org> 7 * 8 * Permission to use, copy, modify, and distribute this software for any 9 * purpose with or without fee is hereby granted, provided that the above 10 * copyright notice and this permission notice appear in all copies. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 19 */ 20 21 #include <sys/cdefs.h> 22 __FBSDID("$FreeBSD$"); 23 24 #define PFIOC_USE_LATEST 25 26 #include <sys/types.h> 27 #include <sys/bitset.h> 28 #include <sys/ioctl.h> 29 #include <sys/socket.h> 30 31 #include <net/if.h> 32 #include <netinet/in.h> 33 #include <net/pfvar.h> 34 35 #include <err.h> 36 #include <errno.h> 37 #include <inttypes.h> 38 #include <limits.h> 39 #include <math.h> 40 #include <search.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <unistd.h> 45 46 #include <net/altq/altq.h> 47 #include <net/altq/altq_cbq.h> 48 #include <net/altq/altq_codel.h> 49 #include <net/altq/altq_priq.h> 50 #include <net/altq/altq_hfsc.h> 51 #include <net/altq/altq_fairq.h> 52 53 #include "pfctl_parser.h" 54 #include "pfctl.h" 55 56 #define is_sc_null(sc) (((sc) == NULL) || ((sc)->m1 == 0 && (sc)->m2 == 0)) 57 58 static STAILQ_HEAD(interfaces, pfctl_altq) interfaces = STAILQ_HEAD_INITIALIZER(interfaces); 59 static struct hsearch_data queue_map; 60 static struct hsearch_data if_map; 61 static struct hsearch_data qid_map; 62 63 static struct pfctl_altq *pfaltq_lookup(char *ifname); 64 static struct pfctl_altq *qname_to_pfaltq(const char *, const char *); 65 static u_int32_t qname_to_qid(char *); 66 67 static int eval_pfqueue_cbq(struct pfctl *, struct pf_altq *, 68 struct pfctl_altq *); 69 static int cbq_compute_idletime(struct pfctl *, struct pf_altq *); 70 static int check_commit_cbq(int, int, struct pfctl_altq *); 71 static int print_cbq_opts(const struct pf_altq *); 72 73 static int print_codel_opts(const struct pf_altq *, 74 const struct node_queue_opt *); 75 76 static int eval_pfqueue_priq(struct pfctl *, struct pf_altq *, 77 struct pfctl_altq *); 78 static int check_commit_priq(int, int, struct pfctl_altq *); 79 static int print_priq_opts(const struct pf_altq *); 80 81 static int eval_pfqueue_hfsc(struct pfctl *, struct pf_altq *, 82 struct pfctl_altq *, struct pfctl_altq *); 83 static int check_commit_hfsc(int, int, struct pfctl_altq *); 84 static int print_hfsc_opts(const struct pf_altq *, 85 const struct node_queue_opt *); 86 87 static int eval_pfqueue_fairq(struct pfctl *, struct pf_altq *, 88 struct pfctl_altq *, struct pfctl_altq *); 89 static int print_fairq_opts(const struct pf_altq *, 90 const struct node_queue_opt *); 91 static int check_commit_fairq(int, int, struct pfctl_altq *); 92 93 static void gsc_add_sc(struct gen_sc *, struct service_curve *); 94 static int is_gsc_under_sc(struct gen_sc *, 95 struct service_curve *); 96 static struct segment *gsc_getentry(struct gen_sc *, double); 97 static int gsc_add_seg(struct gen_sc *, double, double, double, 98 double); 99 static double sc_x2y(struct service_curve *, double); 100 101 u_int32_t getifspeed(char *); 102 u_long getifmtu(char *); 103 int eval_queue_opts(struct pf_altq *, struct node_queue_opt *, 104 u_int64_t); 105 u_int64_t eval_bwspec(struct node_queue_bw *, u_int64_t); 106 void print_hfsc_sc(const char *, u_int, u_int, u_int, 107 const struct node_hfsc_sc *); 108 void print_fairq_sc(const char *, u_int, u_int, u_int, 109 const struct node_fairq_sc *); 110 111 static __attribute__((constructor)) void 112 pfctl_altq_init(void) 113 { 114 /* 115 * As hdestroy() will never be called on these tables, it will be 116 * safe to use references into the stored data as keys. 117 */ 118 if (hcreate_r(0, &queue_map) == 0) 119 err(1, "Failed to create altq queue map"); 120 if (hcreate_r(0, &if_map) == 0) 121 err(1, "Failed to create altq interface map"); 122 if (hcreate_r(0, &qid_map) == 0) 123 err(1, "Failed to create altq queue id map"); 124 } 125 126 void 127 pfaltq_store(struct pf_altq *a) 128 { 129 struct pfctl_altq *altq; 130 ENTRY item; 131 ENTRY *ret_item; 132 size_t key_size; 133 134 if ((altq = malloc(sizeof(*altq))) == NULL) 135 err(1, "queue malloc"); 136 memcpy(&altq->pa, a, sizeof(struct pf_altq)); 137 memset(&altq->meta, 0, sizeof(altq->meta)); 138 139 if (a->qname[0] == 0) { 140 item.key = altq->pa.ifname; 141 item.data = altq; 142 if (hsearch_r(item, ENTER, &ret_item, &if_map) == 0) 143 err(1, "interface map insert"); 144 STAILQ_INSERT_TAIL(&interfaces, altq, meta.link); 145 } else { 146 key_size = sizeof(a->ifname) + sizeof(a->qname); 147 if ((item.key = malloc(key_size)) == NULL) 148 err(1, "queue map key malloc"); 149 snprintf(item.key, key_size, "%s:%s", a->ifname, a->qname); 150 item.data = altq; 151 if (hsearch_r(item, ENTER, &ret_item, &queue_map) == 0) 152 err(1, "queue map insert"); 153 154 item.key = altq->pa.qname; 155 item.data = &altq->pa.qid; 156 if (hsearch_r(item, ENTER, &ret_item, &qid_map) == 0) 157 err(1, "qid map insert"); 158 } 159 } 160 161 static struct pfctl_altq * 162 pfaltq_lookup(char *ifname) 163 { 164 ENTRY item; 165 ENTRY *ret_item; 166 167 item.key = ifname; 168 if (hsearch_r(item, FIND, &ret_item, &if_map) == 0) 169 return (NULL); 170 171 return (ret_item->data); 172 } 173 174 static struct pfctl_altq * 175 qname_to_pfaltq(const char *qname, const char *ifname) 176 { 177 ENTRY item; 178 ENTRY *ret_item; 179 char key[IFNAMSIZ + PF_QNAME_SIZE]; 180 181 item.key = key; 182 snprintf(item.key, sizeof(key), "%s:%s", ifname, qname); 183 if (hsearch_r(item, FIND, &ret_item, &queue_map) == 0) 184 return (NULL); 185 186 return (ret_item->data); 187 } 188 189 static u_int32_t 190 qname_to_qid(char *qname) 191 { 192 ENTRY item; 193 ENTRY *ret_item; 194 uint32_t qid; 195 196 /* 197 * We guarantee that same named queues on different interfaces 198 * have the same qid. 199 */ 200 item.key = qname; 201 if (hsearch_r(item, FIND, &ret_item, &qid_map) == 0) 202 return (0); 203 204 qid = *(uint32_t *)ret_item->data; 205 return (qid); 206 } 207 208 void 209 print_altq(const struct pf_altq *a, unsigned int level, 210 struct node_queue_bw *bw, struct node_queue_opt *qopts) 211 { 212 if (a->qname[0] != 0) { 213 print_queue(a, level, bw, 1, qopts); 214 return; 215 } 216 217 #ifdef __FreeBSD__ 218 if (a->local_flags & PFALTQ_FLAG_IF_REMOVED) 219 printf("INACTIVE "); 220 #endif 221 222 printf("altq on %s ", a->ifname); 223 224 switch (a->scheduler) { 225 case ALTQT_CBQ: 226 if (!print_cbq_opts(a)) 227 printf("cbq "); 228 break; 229 case ALTQT_PRIQ: 230 if (!print_priq_opts(a)) 231 printf("priq "); 232 break; 233 case ALTQT_HFSC: 234 if (!print_hfsc_opts(a, qopts)) 235 printf("hfsc "); 236 break; 237 case ALTQT_FAIRQ: 238 if (!print_fairq_opts(a, qopts)) 239 printf("fairq "); 240 break; 241 case ALTQT_CODEL: 242 if (!print_codel_opts(a, qopts)) 243 printf("codel "); 244 break; 245 } 246 247 if (bw != NULL && bw->bw_percent > 0) { 248 if (bw->bw_percent < 100) 249 printf("bandwidth %u%% ", bw->bw_percent); 250 } else 251 printf("bandwidth %s ", rate2str((double)a->ifbandwidth)); 252 253 if (a->qlimit != DEFAULT_QLIMIT) 254 printf("qlimit %u ", a->qlimit); 255 printf("tbrsize %u ", a->tbrsize); 256 } 257 258 void 259 print_queue(const struct pf_altq *a, unsigned int level, 260 struct node_queue_bw *bw, int print_interface, 261 struct node_queue_opt *qopts) 262 { 263 unsigned int i; 264 265 #ifdef __FreeBSD__ 266 if (a->local_flags & PFALTQ_FLAG_IF_REMOVED) 267 printf("INACTIVE "); 268 #endif 269 printf("queue "); 270 for (i = 0; i < level; ++i) 271 printf(" "); 272 printf("%s ", a->qname); 273 if (print_interface) 274 printf("on %s ", a->ifname); 275 if (a->scheduler == ALTQT_CBQ || a->scheduler == ALTQT_HFSC || 276 a->scheduler == ALTQT_FAIRQ) { 277 if (bw != NULL && bw->bw_percent > 0) { 278 if (bw->bw_percent < 100) 279 printf("bandwidth %u%% ", bw->bw_percent); 280 } else 281 printf("bandwidth %s ", rate2str((double)a->bandwidth)); 282 } 283 if (a->priority != DEFAULT_PRIORITY) 284 printf("priority %u ", a->priority); 285 if (a->qlimit != DEFAULT_QLIMIT) 286 printf("qlimit %u ", a->qlimit); 287 switch (a->scheduler) { 288 case ALTQT_CBQ: 289 print_cbq_opts(a); 290 break; 291 case ALTQT_PRIQ: 292 print_priq_opts(a); 293 break; 294 case ALTQT_HFSC: 295 print_hfsc_opts(a, qopts); 296 break; 297 case ALTQT_FAIRQ: 298 print_fairq_opts(a, qopts); 299 break; 300 } 301 } 302 303 /* 304 * eval_pfaltq computes the discipline parameters. 305 */ 306 int 307 eval_pfaltq(struct pfctl *pf, struct pf_altq *pa, struct node_queue_bw *bw, 308 struct node_queue_opt *opts) 309 { 310 u_int64_t rate; 311 u_int size, errors = 0; 312 313 if (bw->bw_absolute > 0) 314 pa->ifbandwidth = bw->bw_absolute; 315 else 316 if ((rate = getifspeed(pa->ifname)) == 0) { 317 fprintf(stderr, "interface %s does not know its bandwidth, " 318 "please specify an absolute bandwidth\n", 319 pa->ifname); 320 errors++; 321 } else if ((pa->ifbandwidth = eval_bwspec(bw, rate)) == 0) 322 pa->ifbandwidth = rate; 323 324 /* 325 * Limit bandwidth to UINT_MAX for schedulers that aren't 64-bit ready. 326 */ 327 if ((pa->scheduler != ALTQT_HFSC) && (pa->ifbandwidth > UINT_MAX)) { 328 pa->ifbandwidth = UINT_MAX; 329 warnx("interface %s bandwidth limited to %" PRIu64 " bps " 330 "because selected scheduler is 32-bit limited\n", pa->ifname, 331 pa->ifbandwidth); 332 } 333 errors += eval_queue_opts(pa, opts, pa->ifbandwidth); 334 335 /* if tbrsize is not specified, use heuristics */ 336 if (pa->tbrsize == 0) { 337 rate = pa->ifbandwidth; 338 if (rate <= 1 * 1000 * 1000) 339 size = 1; 340 else if (rate <= 10 * 1000 * 1000) 341 size = 4; 342 else if (rate <= 200 * 1000 * 1000) 343 size = 8; 344 else if (rate <= 2500 * 1000 * 1000ULL) 345 size = 24; 346 else 347 size = 128; 348 size = size * getifmtu(pa->ifname); 349 pa->tbrsize = size; 350 } 351 return (errors); 352 } 353 354 /* 355 * check_commit_altq does consistency check for each interface 356 */ 357 int 358 check_commit_altq(int dev, int opts) 359 { 360 struct pfctl_altq *if_ppa; 361 int error = 0; 362 363 /* call the discipline check for each interface. */ 364 STAILQ_FOREACH(if_ppa, &interfaces, meta.link) { 365 switch (if_ppa->pa.scheduler) { 366 case ALTQT_CBQ: 367 error = check_commit_cbq(dev, opts, if_ppa); 368 break; 369 case ALTQT_PRIQ: 370 error = check_commit_priq(dev, opts, if_ppa); 371 break; 372 case ALTQT_HFSC: 373 error = check_commit_hfsc(dev, opts, if_ppa); 374 break; 375 case ALTQT_FAIRQ: 376 error = check_commit_fairq(dev, opts, if_ppa); 377 break; 378 default: 379 break; 380 } 381 } 382 return (error); 383 } 384 385 /* 386 * eval_pfqueue computes the queue parameters. 387 */ 388 int 389 eval_pfqueue(struct pfctl *pf, struct pf_altq *pa, struct node_queue_bw *bw, 390 struct node_queue_opt *opts) 391 { 392 /* should be merged with expand_queue */ 393 struct pfctl_altq *if_ppa, *parent; 394 int error = 0; 395 396 /* find the corresponding interface and copy fields used by queues */ 397 if ((if_ppa = pfaltq_lookup(pa->ifname)) == NULL) { 398 fprintf(stderr, "altq not defined on %s\n", pa->ifname); 399 return (1); 400 } 401 pa->scheduler = if_ppa->pa.scheduler; 402 pa->ifbandwidth = if_ppa->pa.ifbandwidth; 403 404 if (qname_to_pfaltq(pa->qname, pa->ifname) != NULL) { 405 fprintf(stderr, "queue %s already exists on interface %s\n", 406 pa->qname, pa->ifname); 407 return (1); 408 } 409 pa->qid = qname_to_qid(pa->qname); 410 411 parent = NULL; 412 if (pa->parent[0] != 0) { 413 parent = qname_to_pfaltq(pa->parent, pa->ifname); 414 if (parent == NULL) { 415 fprintf(stderr, "parent %s not found for %s\n", 416 pa->parent, pa->qname); 417 return (1); 418 } 419 pa->parent_qid = parent->pa.qid; 420 } 421 if (pa->qlimit == 0) 422 pa->qlimit = DEFAULT_QLIMIT; 423 424 if (pa->scheduler == ALTQT_CBQ || pa->scheduler == ALTQT_HFSC || 425 pa->scheduler == ALTQT_FAIRQ) { 426 pa->bandwidth = eval_bwspec(bw, 427 parent == NULL ? pa->ifbandwidth : parent->pa.bandwidth); 428 429 if (pa->bandwidth > pa->ifbandwidth) { 430 fprintf(stderr, "bandwidth for %s higher than " 431 "interface\n", pa->qname); 432 return (1); 433 } 434 /* 435 * If not HFSC, then check that the sum of the child 436 * bandwidths is less than the parent's bandwidth. For 437 * HFSC, the equivalent concept is to check that the sum of 438 * the child linkshare service curves are under the parent's 439 * linkshare service curve, and that check is performed by 440 * eval_pfqueue_hfsc(). 441 */ 442 if ((parent != NULL) && (pa->scheduler != ALTQT_HFSC)) { 443 if (pa->bandwidth > parent->pa.bandwidth) { 444 warnx("bandwidth for %s higher than parent", 445 pa->qname); 446 return (1); 447 } 448 parent->meta.bwsum += pa->bandwidth; 449 if (parent->meta.bwsum > parent->pa.bandwidth) { 450 warnx("the sum of the child bandwidth (%" PRIu64 451 ") higher than parent \"%s\" (%" PRIu64 ")", 452 parent->meta.bwsum, parent->pa.qname, 453 parent->pa.bandwidth); 454 } 455 } 456 } 457 458 if (eval_queue_opts(pa, opts, 459 parent == NULL ? pa->ifbandwidth : parent->pa.bandwidth)) 460 return (1); 461 462 if (parent != NULL) 463 parent->meta.children++; 464 465 switch (pa->scheduler) { 466 case ALTQT_CBQ: 467 error = eval_pfqueue_cbq(pf, pa, if_ppa); 468 break; 469 case ALTQT_PRIQ: 470 error = eval_pfqueue_priq(pf, pa, if_ppa); 471 break; 472 case ALTQT_HFSC: 473 error = eval_pfqueue_hfsc(pf, pa, if_ppa, parent); 474 break; 475 case ALTQT_FAIRQ: 476 error = eval_pfqueue_fairq(pf, pa, if_ppa, parent); 477 break; 478 default: 479 break; 480 } 481 return (error); 482 } 483 484 /* 485 * CBQ support functions 486 */ 487 #define RM_FILTER_GAIN 5 /* log2 of gain, e.g., 5 => 31/32 */ 488 #define RM_NS_PER_SEC (1000000000) 489 490 static int 491 eval_pfqueue_cbq(struct pfctl *pf, struct pf_altq *pa, struct pfctl_altq *if_ppa) 492 { 493 struct cbq_opts *opts; 494 u_int ifmtu; 495 496 if (pa->priority >= CBQ_MAXPRI) { 497 warnx("priority out of range: max %d", CBQ_MAXPRI - 1); 498 return (-1); 499 } 500 501 ifmtu = getifmtu(pa->ifname); 502 opts = &pa->pq_u.cbq_opts; 503 504 if (opts->pktsize == 0) { /* use default */ 505 opts->pktsize = ifmtu; 506 if (opts->pktsize > MCLBYTES) /* do what TCP does */ 507 opts->pktsize &= ~MCLBYTES; 508 } else if (opts->pktsize > ifmtu) 509 opts->pktsize = ifmtu; 510 if (opts->maxpktsize == 0) /* use default */ 511 opts->maxpktsize = ifmtu; 512 else if (opts->maxpktsize > ifmtu) 513 opts->pktsize = ifmtu; 514 515 if (opts->pktsize > opts->maxpktsize) 516 opts->pktsize = opts->maxpktsize; 517 518 if (pa->parent[0] == 0) 519 opts->flags |= (CBQCLF_ROOTCLASS | CBQCLF_WRR); 520 521 if (pa->pq_u.cbq_opts.flags & CBQCLF_ROOTCLASS) 522 if_ppa->meta.root_classes++; 523 if (pa->pq_u.cbq_opts.flags & CBQCLF_DEFCLASS) 524 if_ppa->meta.default_classes++; 525 526 cbq_compute_idletime(pf, pa); 527 return (0); 528 } 529 530 /* 531 * compute ns_per_byte, maxidle, minidle, and offtime 532 */ 533 static int 534 cbq_compute_idletime(struct pfctl *pf, struct pf_altq *pa) 535 { 536 struct cbq_opts *opts; 537 double maxidle_s, maxidle, minidle; 538 double offtime, nsPerByte, ifnsPerByte, ptime, cptime; 539 double z, g, f, gton, gtom; 540 u_int minburst, maxburst; 541 542 opts = &pa->pq_u.cbq_opts; 543 ifnsPerByte = (1.0 / (double)pa->ifbandwidth) * RM_NS_PER_SEC * 8; 544 minburst = opts->minburst; 545 maxburst = opts->maxburst; 546 547 if (pa->bandwidth == 0) 548 f = 0.0001; /* small enough? */ 549 else 550 f = ((double) pa->bandwidth / (double) pa->ifbandwidth); 551 552 nsPerByte = ifnsPerByte / f; 553 ptime = (double)opts->pktsize * ifnsPerByte; 554 cptime = ptime * (1.0 - f) / f; 555 556 if (nsPerByte * (double)opts->maxpktsize > (double)INT_MAX) { 557 /* 558 * this causes integer overflow in kernel! 559 * (bandwidth < 6Kbps when max_pkt_size=1500) 560 */ 561 if (pa->bandwidth != 0 && (pf->opts & PF_OPT_QUIET) == 0) { 562 warnx("queue bandwidth must be larger than %s", 563 rate2str(ifnsPerByte * (double)opts->maxpktsize / 564 (double)INT_MAX * (double)pa->ifbandwidth)); 565 fprintf(stderr, "cbq: queue %s is too slow!\n", 566 pa->qname); 567 } 568 nsPerByte = (double)(INT_MAX / opts->maxpktsize); 569 } 570 571 if (maxburst == 0) { /* use default */ 572 if (cptime > 10.0 * 1000000) 573 maxburst = 4; 574 else 575 maxburst = 16; 576 } 577 if (minburst == 0) /* use default */ 578 minburst = 2; 579 if (minburst > maxburst) 580 minburst = maxburst; 581 582 z = (double)(1 << RM_FILTER_GAIN); 583 g = (1.0 - 1.0 / z); 584 gton = pow(g, (double)maxburst); 585 gtom = pow(g, (double)(minburst-1)); 586 maxidle = ((1.0 / f - 1.0) * ((1.0 - gton) / gton)); 587 maxidle_s = (1.0 - g); 588 if (maxidle > maxidle_s) 589 maxidle = ptime * maxidle; 590 else 591 maxidle = ptime * maxidle_s; 592 offtime = cptime * (1.0 + 1.0/(1.0 - g) * (1.0 - gtom) / gtom); 593 minidle = -((double)opts->maxpktsize * (double)nsPerByte); 594 595 /* scale parameters */ 596 maxidle = ((maxidle * 8.0) / nsPerByte) * 597 pow(2.0, (double)RM_FILTER_GAIN); 598 offtime = (offtime * 8.0) / nsPerByte * 599 pow(2.0, (double)RM_FILTER_GAIN); 600 minidle = ((minidle * 8.0) / nsPerByte) * 601 pow(2.0, (double)RM_FILTER_GAIN); 602 603 maxidle = maxidle / 1000.0; 604 offtime = offtime / 1000.0; 605 minidle = minidle / 1000.0; 606 607 opts->minburst = minburst; 608 opts->maxburst = maxburst; 609 opts->ns_per_byte = (u_int)nsPerByte; 610 opts->maxidle = (u_int)fabs(maxidle); 611 opts->minidle = (int)minidle; 612 opts->offtime = (u_int)fabs(offtime); 613 614 return (0); 615 } 616 617 static int 618 check_commit_cbq(int dev, int opts, struct pfctl_altq *if_ppa) 619 { 620 int error = 0; 621 622 /* 623 * check if cbq has one root queue and one default queue 624 * for this interface 625 */ 626 if (if_ppa->meta.root_classes != 1) { 627 warnx("should have one root queue on %s", if_ppa->pa.ifname); 628 error++; 629 } 630 if (if_ppa->meta.default_classes != 1) { 631 warnx("should have one default queue on %s", if_ppa->pa.ifname); 632 error++; 633 } 634 return (error); 635 } 636 637 static int 638 print_cbq_opts(const struct pf_altq *a) 639 { 640 const struct cbq_opts *opts; 641 642 opts = &a->pq_u.cbq_opts; 643 if (opts->flags) { 644 printf("cbq("); 645 if (opts->flags & CBQCLF_RED) 646 printf(" red"); 647 if (opts->flags & CBQCLF_ECN) 648 printf(" ecn"); 649 if (opts->flags & CBQCLF_RIO) 650 printf(" rio"); 651 if (opts->flags & CBQCLF_CODEL) 652 printf(" codel"); 653 if (opts->flags & CBQCLF_CLEARDSCP) 654 printf(" cleardscp"); 655 if (opts->flags & CBQCLF_FLOWVALVE) 656 printf(" flowvalve"); 657 if (opts->flags & CBQCLF_BORROW) 658 printf(" borrow"); 659 if (opts->flags & CBQCLF_WRR) 660 printf(" wrr"); 661 if (opts->flags & CBQCLF_EFFICIENT) 662 printf(" efficient"); 663 if (opts->flags & CBQCLF_ROOTCLASS) 664 printf(" root"); 665 if (opts->flags & CBQCLF_DEFCLASS) 666 printf(" default"); 667 printf(" ) "); 668 669 return (1); 670 } else 671 return (0); 672 } 673 674 /* 675 * PRIQ support functions 676 */ 677 static int 678 eval_pfqueue_priq(struct pfctl *pf, struct pf_altq *pa, struct pfctl_altq *if_ppa) 679 { 680 681 if (pa->priority >= PRIQ_MAXPRI) { 682 warnx("priority out of range: max %d", PRIQ_MAXPRI - 1); 683 return (-1); 684 } 685 if (BIT_ISSET(QPRI_BITSET_SIZE, pa->priority, &if_ppa->meta.qpris)) { 686 warnx("%s does not have a unique priority on interface %s", 687 pa->qname, pa->ifname); 688 return (-1); 689 } else 690 BIT_SET(QPRI_BITSET_SIZE, pa->priority, &if_ppa->meta.qpris); 691 692 if (pa->pq_u.priq_opts.flags & PRCF_DEFAULTCLASS) 693 if_ppa->meta.default_classes++; 694 return (0); 695 } 696 697 static int 698 check_commit_priq(int dev, int opts, struct pfctl_altq *if_ppa) 699 { 700 701 /* 702 * check if priq has one default class for this interface 703 */ 704 if (if_ppa->meta.default_classes != 1) { 705 warnx("should have one default queue on %s", if_ppa->pa.ifname); 706 return (1); 707 } 708 return (0); 709 } 710 711 static int 712 print_priq_opts(const struct pf_altq *a) 713 { 714 const struct priq_opts *opts; 715 716 opts = &a->pq_u.priq_opts; 717 718 if (opts->flags) { 719 printf("priq("); 720 if (opts->flags & PRCF_RED) 721 printf(" red"); 722 if (opts->flags & PRCF_ECN) 723 printf(" ecn"); 724 if (opts->flags & PRCF_RIO) 725 printf(" rio"); 726 if (opts->flags & PRCF_CODEL) 727 printf(" codel"); 728 if (opts->flags & PRCF_CLEARDSCP) 729 printf(" cleardscp"); 730 if (opts->flags & PRCF_DEFAULTCLASS) 731 printf(" default"); 732 printf(" ) "); 733 734 return (1); 735 } else 736 return (0); 737 } 738 739 /* 740 * HFSC support functions 741 */ 742 static int 743 eval_pfqueue_hfsc(struct pfctl *pf, struct pf_altq *pa, struct pfctl_altq *if_ppa, 744 struct pfctl_altq *parent) 745 { 746 struct hfsc_opts_v1 *opts; 747 struct service_curve sc; 748 749 opts = &pa->pq_u.hfsc_opts; 750 751 if (parent == NULL) { 752 /* root queue */ 753 opts->lssc_m1 = pa->ifbandwidth; 754 opts->lssc_m2 = pa->ifbandwidth; 755 opts->lssc_d = 0; 756 return (0); 757 } 758 759 /* First child initializes the parent's service curve accumulators. */ 760 if (parent->meta.children == 1) { 761 LIST_INIT(&parent->meta.rtsc); 762 LIST_INIT(&parent->meta.lssc); 763 } 764 765 if (parent->pa.pq_u.hfsc_opts.flags & HFCF_DEFAULTCLASS) { 766 warnx("adding %s would make default queue %s not a leaf", 767 pa->qname, pa->parent); 768 return (-1); 769 } 770 771 if (pa->pq_u.hfsc_opts.flags & HFCF_DEFAULTCLASS) 772 if_ppa->meta.default_classes++; 773 774 /* if link_share is not specified, use bandwidth */ 775 if (opts->lssc_m2 == 0) 776 opts->lssc_m2 = pa->bandwidth; 777 778 if ((opts->rtsc_m1 > 0 && opts->rtsc_m2 == 0) || 779 (opts->lssc_m1 > 0 && opts->lssc_m2 == 0) || 780 (opts->ulsc_m1 > 0 && opts->ulsc_m2 == 0)) { 781 warnx("m2 is zero for %s", pa->qname); 782 return (-1); 783 } 784 785 if ((opts->rtsc_m1 < opts->rtsc_m2 && opts->rtsc_m1 != 0) || 786 (opts->lssc_m1 < opts->lssc_m2 && opts->lssc_m1 != 0) || 787 (opts->ulsc_m1 < opts->ulsc_m2 && opts->ulsc_m1 != 0)) { 788 warnx("m1 must be zero for convex curve: %s", pa->qname); 789 return (-1); 790 } 791 792 /* 793 * admission control: 794 * for the real-time service curve, the sum of the service curves 795 * should not exceed 80% of the interface bandwidth. 20% is reserved 796 * not to over-commit the actual interface bandwidth. 797 * for the linkshare service curve, the sum of the child service 798 * curve should not exceed the parent service curve. 799 * for the upper-limit service curve, the assigned bandwidth should 800 * be smaller than the interface bandwidth, and the upper-limit should 801 * be larger than the real-time service curve when both are defined. 802 */ 803 804 /* check the real-time service curve. reserve 20% of interface bw */ 805 if (opts->rtsc_m2 != 0) { 806 /* add this queue to the sum */ 807 sc.m1 = opts->rtsc_m1; 808 sc.d = opts->rtsc_d; 809 sc.m2 = opts->rtsc_m2; 810 gsc_add_sc(&parent->meta.rtsc, &sc); 811 /* compare the sum with 80% of the interface */ 812 sc.m1 = 0; 813 sc.d = 0; 814 sc.m2 = pa->ifbandwidth / 100 * 80; 815 if (!is_gsc_under_sc(&parent->meta.rtsc, &sc)) { 816 warnx("real-time sc exceeds 80%% of the interface " 817 "bandwidth (%s)", rate2str((double)sc.m2)); 818 return (-1); 819 } 820 } 821 822 /* check the linkshare service curve. */ 823 if (opts->lssc_m2 != 0) { 824 /* add this queue to the child sum */ 825 sc.m1 = opts->lssc_m1; 826 sc.d = opts->lssc_d; 827 sc.m2 = opts->lssc_m2; 828 gsc_add_sc(&parent->meta.lssc, &sc); 829 /* compare the sum of the children with parent's sc */ 830 sc.m1 = parent->pa.pq_u.hfsc_opts.lssc_m1; 831 sc.d = parent->pa.pq_u.hfsc_opts.lssc_d; 832 sc.m2 = parent->pa.pq_u.hfsc_opts.lssc_m2; 833 if (!is_gsc_under_sc(&parent->meta.lssc, &sc)) { 834 warnx("linkshare sc exceeds parent's sc"); 835 return (-1); 836 } 837 } 838 839 /* check the upper-limit service curve. */ 840 if (opts->ulsc_m2 != 0) { 841 if (opts->ulsc_m1 > pa->ifbandwidth || 842 opts->ulsc_m2 > pa->ifbandwidth) { 843 warnx("upper-limit larger than interface bandwidth"); 844 return (-1); 845 } 846 if (opts->rtsc_m2 != 0 && opts->rtsc_m2 > opts->ulsc_m2) { 847 warnx("upper-limit sc smaller than real-time sc"); 848 return (-1); 849 } 850 } 851 852 return (0); 853 } 854 855 /* 856 * FAIRQ support functions 857 */ 858 static int 859 eval_pfqueue_fairq(struct pfctl *pf __unused, struct pf_altq *pa, 860 struct pfctl_altq *if_ppa, struct pfctl_altq *parent) 861 { 862 struct fairq_opts *opts; 863 struct service_curve sc; 864 865 opts = &pa->pq_u.fairq_opts; 866 867 if (parent == NULL) { 868 /* root queue */ 869 opts->lssc_m1 = pa->ifbandwidth; 870 opts->lssc_m2 = pa->ifbandwidth; 871 opts->lssc_d = 0; 872 return (0); 873 } 874 875 /* First child initializes the parent's service curve accumulator. */ 876 if (parent->meta.children == 1) 877 LIST_INIT(&parent->meta.lssc); 878 879 if (parent->pa.pq_u.fairq_opts.flags & FARF_DEFAULTCLASS) { 880 warnx("adding %s would make default queue %s not a leaf", 881 pa->qname, pa->parent); 882 return (-1); 883 } 884 885 if (pa->pq_u.fairq_opts.flags & FARF_DEFAULTCLASS) 886 if_ppa->meta.default_classes++; 887 888 /* if link_share is not specified, use bandwidth */ 889 if (opts->lssc_m2 == 0) 890 opts->lssc_m2 = pa->bandwidth; 891 892 /* 893 * admission control: 894 * for the real-time service curve, the sum of the service curves 895 * should not exceed 80% of the interface bandwidth. 20% is reserved 896 * not to over-commit the actual interface bandwidth. 897 * for the link-sharing service curve, the sum of the child service 898 * curve should not exceed the parent service curve. 899 * for the upper-limit service curve, the assigned bandwidth should 900 * be smaller than the interface bandwidth, and the upper-limit should 901 * be larger than the real-time service curve when both are defined. 902 */ 903 904 /* check the linkshare service curve. */ 905 if (opts->lssc_m2 != 0) { 906 /* add this queue to the child sum */ 907 sc.m1 = opts->lssc_m1; 908 sc.d = opts->lssc_d; 909 sc.m2 = opts->lssc_m2; 910 gsc_add_sc(&parent->meta.lssc, &sc); 911 /* compare the sum of the children with parent's sc */ 912 sc.m1 = parent->pa.pq_u.fairq_opts.lssc_m1; 913 sc.d = parent->pa.pq_u.fairq_opts.lssc_d; 914 sc.m2 = parent->pa.pq_u.fairq_opts.lssc_m2; 915 if (!is_gsc_under_sc(&parent->meta.lssc, &sc)) { 916 warnx("link-sharing sc exceeds parent's sc"); 917 return (-1); 918 } 919 } 920 921 return (0); 922 } 923 924 static int 925 check_commit_hfsc(int dev, int opts, struct pfctl_altq *if_ppa) 926 { 927 928 /* check if hfsc has one default queue for this interface */ 929 if (if_ppa->meta.default_classes != 1) { 930 warnx("should have one default queue on %s", if_ppa->pa.ifname); 931 return (1); 932 } 933 return (0); 934 } 935 936 static int 937 check_commit_fairq(int dev __unused, int opts __unused, struct pfctl_altq *if_ppa) 938 { 939 940 /* check if fairq has one default queue for this interface */ 941 if (if_ppa->meta.default_classes != 1) { 942 warnx("should have one default queue on %s", if_ppa->pa.ifname); 943 return (1); 944 } 945 return (0); 946 } 947 948 static int 949 print_hfsc_opts(const struct pf_altq *a, const struct node_queue_opt *qopts) 950 { 951 const struct hfsc_opts_v1 *opts; 952 const struct node_hfsc_sc *rtsc, *lssc, *ulsc; 953 954 opts = &a->pq_u.hfsc_opts; 955 if (qopts == NULL) 956 rtsc = lssc = ulsc = NULL; 957 else { 958 rtsc = &qopts->data.hfsc_opts.realtime; 959 lssc = &qopts->data.hfsc_opts.linkshare; 960 ulsc = &qopts->data.hfsc_opts.upperlimit; 961 } 962 963 if (opts->flags || opts->rtsc_m2 != 0 || opts->ulsc_m2 != 0 || 964 (opts->lssc_m2 != 0 && (opts->lssc_m2 != a->bandwidth || 965 opts->lssc_d != 0))) { 966 printf("hfsc("); 967 if (opts->flags & HFCF_RED) 968 printf(" red"); 969 if (opts->flags & HFCF_ECN) 970 printf(" ecn"); 971 if (opts->flags & HFCF_RIO) 972 printf(" rio"); 973 if (opts->flags & HFCF_CODEL) 974 printf(" codel"); 975 if (opts->flags & HFCF_CLEARDSCP) 976 printf(" cleardscp"); 977 if (opts->flags & HFCF_DEFAULTCLASS) 978 printf(" default"); 979 if (opts->rtsc_m2 != 0) 980 print_hfsc_sc("realtime", opts->rtsc_m1, opts->rtsc_d, 981 opts->rtsc_m2, rtsc); 982 if (opts->lssc_m2 != 0 && (opts->lssc_m2 != a->bandwidth || 983 opts->lssc_d != 0)) 984 print_hfsc_sc("linkshare", opts->lssc_m1, opts->lssc_d, 985 opts->lssc_m2, lssc); 986 if (opts->ulsc_m2 != 0) 987 print_hfsc_sc("upperlimit", opts->ulsc_m1, opts->ulsc_d, 988 opts->ulsc_m2, ulsc); 989 printf(" ) "); 990 991 return (1); 992 } else 993 return (0); 994 } 995 996 static int 997 print_codel_opts(const struct pf_altq *a, const struct node_queue_opt *qopts) 998 { 999 const struct codel_opts *opts; 1000 1001 opts = &a->pq_u.codel_opts; 1002 if (opts->target || opts->interval || opts->ecn) { 1003 printf("codel("); 1004 if (opts->target) 1005 printf(" target %d", opts->target); 1006 if (opts->interval) 1007 printf(" interval %d", opts->interval); 1008 if (opts->ecn) 1009 printf("ecn"); 1010 printf(" ) "); 1011 1012 return (1); 1013 } 1014 1015 return (0); 1016 } 1017 1018 static int 1019 print_fairq_opts(const struct pf_altq *a, const struct node_queue_opt *qopts) 1020 { 1021 const struct fairq_opts *opts; 1022 const struct node_fairq_sc *loc_lssc; 1023 1024 opts = &a->pq_u.fairq_opts; 1025 if (qopts == NULL) 1026 loc_lssc = NULL; 1027 else 1028 loc_lssc = &qopts->data.fairq_opts.linkshare; 1029 1030 if (opts->flags || 1031 (opts->lssc_m2 != 0 && (opts->lssc_m2 != a->bandwidth || 1032 opts->lssc_d != 0))) { 1033 printf("fairq("); 1034 if (opts->flags & FARF_RED) 1035 printf(" red"); 1036 if (opts->flags & FARF_ECN) 1037 printf(" ecn"); 1038 if (opts->flags & FARF_RIO) 1039 printf(" rio"); 1040 if (opts->flags & FARF_CODEL) 1041 printf(" codel"); 1042 if (opts->flags & FARF_CLEARDSCP) 1043 printf(" cleardscp"); 1044 if (opts->flags & FARF_DEFAULTCLASS) 1045 printf(" default"); 1046 if (opts->lssc_m2 != 0 && (opts->lssc_m2 != a->bandwidth || 1047 opts->lssc_d != 0)) 1048 print_fairq_sc("linkshare", opts->lssc_m1, opts->lssc_d, 1049 opts->lssc_m2, loc_lssc); 1050 printf(" ) "); 1051 1052 return (1); 1053 } else 1054 return (0); 1055 } 1056 1057 /* 1058 * admission control using generalized service curve 1059 */ 1060 1061 /* add a new service curve to a generalized service curve */ 1062 static void 1063 gsc_add_sc(struct gen_sc *gsc, struct service_curve *sc) 1064 { 1065 if (is_sc_null(sc)) 1066 return; 1067 if (sc->d != 0) 1068 gsc_add_seg(gsc, 0.0, 0.0, (double)sc->d, (double)sc->m1); 1069 gsc_add_seg(gsc, (double)sc->d, 0.0, INFINITY, (double)sc->m2); 1070 } 1071 1072 /* 1073 * check whether all points of a generalized service curve have 1074 * their y-coordinates no larger than a given two-piece linear 1075 * service curve. 1076 */ 1077 static int 1078 is_gsc_under_sc(struct gen_sc *gsc, struct service_curve *sc) 1079 { 1080 struct segment *s, *last, *end; 1081 double y; 1082 1083 if (is_sc_null(sc)) { 1084 if (LIST_EMPTY(gsc)) 1085 return (1); 1086 LIST_FOREACH(s, gsc, _next) { 1087 if (s->m != 0) 1088 return (0); 1089 } 1090 return (1); 1091 } 1092 /* 1093 * gsc has a dummy entry at the end with x = INFINITY. 1094 * loop through up to this dummy entry. 1095 */ 1096 end = gsc_getentry(gsc, INFINITY); 1097 if (end == NULL) 1098 return (1); 1099 last = NULL; 1100 for (s = LIST_FIRST(gsc); s != end; s = LIST_NEXT(s, _next)) { 1101 if (s->y > sc_x2y(sc, s->x)) 1102 return (0); 1103 last = s; 1104 } 1105 /* last now holds the real last segment */ 1106 if (last == NULL) 1107 return (1); 1108 if (last->m > sc->m2) 1109 return (0); 1110 if (last->x < sc->d && last->m > sc->m1) { 1111 y = last->y + (sc->d - last->x) * last->m; 1112 if (y > sc_x2y(sc, sc->d)) 1113 return (0); 1114 } 1115 return (1); 1116 } 1117 1118 /* 1119 * return a segment entry starting at x. 1120 * if gsc has no entry starting at x, a new entry is created at x. 1121 */ 1122 static struct segment * 1123 gsc_getentry(struct gen_sc *gsc, double x) 1124 { 1125 struct segment *new, *prev, *s; 1126 1127 prev = NULL; 1128 LIST_FOREACH(s, gsc, _next) { 1129 if (s->x == x) 1130 return (s); /* matching entry found */ 1131 else if (s->x < x) 1132 prev = s; 1133 else 1134 break; 1135 } 1136 1137 /* we have to create a new entry */ 1138 if ((new = calloc(1, sizeof(struct segment))) == NULL) 1139 return (NULL); 1140 1141 new->x = x; 1142 if (x == INFINITY || s == NULL) 1143 new->d = 0; 1144 else if (s->x == INFINITY) 1145 new->d = INFINITY; 1146 else 1147 new->d = s->x - x; 1148 if (prev == NULL) { 1149 /* insert the new entry at the head of the list */ 1150 new->y = 0; 1151 new->m = 0; 1152 LIST_INSERT_HEAD(gsc, new, _next); 1153 } else { 1154 /* 1155 * the start point intersects with the segment pointed by 1156 * prev. divide prev into 2 segments 1157 */ 1158 if (x == INFINITY) { 1159 prev->d = INFINITY; 1160 if (prev->m == 0) 1161 new->y = prev->y; 1162 else 1163 new->y = INFINITY; 1164 } else { 1165 prev->d = x - prev->x; 1166 new->y = prev->d * prev->m + prev->y; 1167 } 1168 new->m = prev->m; 1169 LIST_INSERT_AFTER(prev, new, _next); 1170 } 1171 return (new); 1172 } 1173 1174 /* add a segment to a generalized service curve */ 1175 static int 1176 gsc_add_seg(struct gen_sc *gsc, double x, double y, double d, double m) 1177 { 1178 struct segment *start, *end, *s; 1179 double x2; 1180 1181 if (d == INFINITY) 1182 x2 = INFINITY; 1183 else 1184 x2 = x + d; 1185 start = gsc_getentry(gsc, x); 1186 end = gsc_getentry(gsc, x2); 1187 if (start == NULL || end == NULL) 1188 return (-1); 1189 1190 for (s = start; s != end; s = LIST_NEXT(s, _next)) { 1191 s->m += m; 1192 s->y += y + (s->x - x) * m; 1193 } 1194 1195 end = gsc_getentry(gsc, INFINITY); 1196 for (; s != end; s = LIST_NEXT(s, _next)) { 1197 s->y += m * d; 1198 } 1199 1200 return (0); 1201 } 1202 1203 /* get y-projection of a service curve */ 1204 static double 1205 sc_x2y(struct service_curve *sc, double x) 1206 { 1207 double y; 1208 1209 if (x <= (double)sc->d) 1210 /* y belongs to the 1st segment */ 1211 y = x * (double)sc->m1; 1212 else 1213 /* y belongs to the 2nd segment */ 1214 y = (double)sc->d * (double)sc->m1 1215 + (x - (double)sc->d) * (double)sc->m2; 1216 return (y); 1217 } 1218 1219 /* 1220 * misc utilities 1221 */ 1222 #define R2S_BUFS 8 1223 #define RATESTR_MAX 16 1224 1225 char * 1226 rate2str(double rate) 1227 { 1228 char *buf; 1229 static char r2sbuf[R2S_BUFS][RATESTR_MAX]; /* ring bufer */ 1230 static int idx = 0; 1231 int i; 1232 static const char unit[] = " KMG"; 1233 1234 buf = r2sbuf[idx++]; 1235 if (idx == R2S_BUFS) 1236 idx = 0; 1237 1238 for (i = 0; rate >= 1000 && i <= 3; i++) 1239 rate /= 1000; 1240 1241 if ((int)(rate * 100) % 100) 1242 snprintf(buf, RATESTR_MAX, "%.2f%cb", rate, unit[i]); 1243 else 1244 snprintf(buf, RATESTR_MAX, "%d%cb", (int)rate, unit[i]); 1245 1246 return (buf); 1247 } 1248 1249 u_int32_t 1250 getifspeed(char *ifname) 1251 { 1252 int s; 1253 struct ifreq ifr; 1254 struct if_data ifrdat; 1255 1256 s = get_query_socket(); 1257 bzero(&ifr, sizeof(ifr)); 1258 if (strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)) >= 1259 sizeof(ifr.ifr_name)) 1260 errx(1, "getifspeed: strlcpy"); 1261 ifr.ifr_data = (caddr_t)&ifrdat; 1262 if (ioctl(s, SIOCGIFDATA, (caddr_t)&ifr) == -1) 1263 err(1, "SIOCGIFDATA"); 1264 return ((u_int32_t)ifrdat.ifi_baudrate); 1265 } 1266 1267 u_long 1268 getifmtu(char *ifname) 1269 { 1270 int s; 1271 struct ifreq ifr; 1272 1273 s = get_query_socket(); 1274 bzero(&ifr, sizeof(ifr)); 1275 if (strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)) >= 1276 sizeof(ifr.ifr_name)) 1277 errx(1, "getifmtu: strlcpy"); 1278 if (ioctl(s, SIOCGIFMTU, (caddr_t)&ifr) == -1) 1279 #ifdef __FreeBSD__ 1280 ifr.ifr_mtu = 1500; 1281 #else 1282 err(1, "SIOCGIFMTU"); 1283 #endif 1284 if (ifr.ifr_mtu > 0) 1285 return (ifr.ifr_mtu); 1286 else { 1287 warnx("could not get mtu for %s, assuming 1500", ifname); 1288 return (1500); 1289 } 1290 } 1291 1292 int 1293 eval_queue_opts(struct pf_altq *pa, struct node_queue_opt *opts, 1294 u_int64_t ref_bw) 1295 { 1296 int errors = 0; 1297 1298 switch (pa->scheduler) { 1299 case ALTQT_CBQ: 1300 pa->pq_u.cbq_opts = opts->data.cbq_opts; 1301 break; 1302 case ALTQT_PRIQ: 1303 pa->pq_u.priq_opts = opts->data.priq_opts; 1304 break; 1305 case ALTQT_HFSC: 1306 pa->pq_u.hfsc_opts.flags = opts->data.hfsc_opts.flags; 1307 if (opts->data.hfsc_opts.linkshare.used) { 1308 pa->pq_u.hfsc_opts.lssc_m1 = 1309 eval_bwspec(&opts->data.hfsc_opts.linkshare.m1, 1310 ref_bw); 1311 pa->pq_u.hfsc_opts.lssc_m2 = 1312 eval_bwspec(&opts->data.hfsc_opts.linkshare.m2, 1313 ref_bw); 1314 pa->pq_u.hfsc_opts.lssc_d = 1315 opts->data.hfsc_opts.linkshare.d; 1316 } 1317 if (opts->data.hfsc_opts.realtime.used) { 1318 pa->pq_u.hfsc_opts.rtsc_m1 = 1319 eval_bwspec(&opts->data.hfsc_opts.realtime.m1, 1320 ref_bw); 1321 pa->pq_u.hfsc_opts.rtsc_m2 = 1322 eval_bwspec(&opts->data.hfsc_opts.realtime.m2, 1323 ref_bw); 1324 pa->pq_u.hfsc_opts.rtsc_d = 1325 opts->data.hfsc_opts.realtime.d; 1326 } 1327 if (opts->data.hfsc_opts.upperlimit.used) { 1328 pa->pq_u.hfsc_opts.ulsc_m1 = 1329 eval_bwspec(&opts->data.hfsc_opts.upperlimit.m1, 1330 ref_bw); 1331 pa->pq_u.hfsc_opts.ulsc_m2 = 1332 eval_bwspec(&opts->data.hfsc_opts.upperlimit.m2, 1333 ref_bw); 1334 pa->pq_u.hfsc_opts.ulsc_d = 1335 opts->data.hfsc_opts.upperlimit.d; 1336 } 1337 break; 1338 case ALTQT_FAIRQ: 1339 pa->pq_u.fairq_opts.flags = opts->data.fairq_opts.flags; 1340 pa->pq_u.fairq_opts.nbuckets = opts->data.fairq_opts.nbuckets; 1341 pa->pq_u.fairq_opts.hogs_m1 = 1342 eval_bwspec(&opts->data.fairq_opts.hogs_bw, ref_bw); 1343 1344 if (opts->data.fairq_opts.linkshare.used) { 1345 pa->pq_u.fairq_opts.lssc_m1 = 1346 eval_bwspec(&opts->data.fairq_opts.linkshare.m1, 1347 ref_bw); 1348 pa->pq_u.fairq_opts.lssc_m2 = 1349 eval_bwspec(&opts->data.fairq_opts.linkshare.m2, 1350 ref_bw); 1351 pa->pq_u.fairq_opts.lssc_d = 1352 opts->data.fairq_opts.linkshare.d; 1353 } 1354 break; 1355 case ALTQT_CODEL: 1356 pa->pq_u.codel_opts.target = opts->data.codel_opts.target; 1357 pa->pq_u.codel_opts.interval = opts->data.codel_opts.interval; 1358 pa->pq_u.codel_opts.ecn = opts->data.codel_opts.ecn; 1359 break; 1360 default: 1361 warnx("eval_queue_opts: unknown scheduler type %u", 1362 opts->qtype); 1363 errors++; 1364 break; 1365 } 1366 1367 return (errors); 1368 } 1369 1370 /* 1371 * If absolute bandwidth if set, return the lesser of that value and the 1372 * reference bandwidth. Limiting to the reference bandwidth allows simple 1373 * limiting of configured bandwidth parameters for schedulers that are 1374 * 32-bit limited, as the root/interface bandwidth (top-level reference 1375 * bandwidth) will be properly limited in that case. 1376 * 1377 * Otherwise, if the absolute bandwidth is not set, return given percentage 1378 * of reference bandwidth. 1379 */ 1380 u_int64_t 1381 eval_bwspec(struct node_queue_bw *bw, u_int64_t ref_bw) 1382 { 1383 if (bw->bw_absolute > 0) 1384 return (MIN(bw->bw_absolute, ref_bw)); 1385 1386 if (bw->bw_percent > 0) 1387 return (ref_bw / 100 * bw->bw_percent); 1388 1389 return (0); 1390 } 1391 1392 void 1393 print_hfsc_sc(const char *scname, u_int m1, u_int d, u_int m2, 1394 const struct node_hfsc_sc *sc) 1395 { 1396 printf(" %s", scname); 1397 1398 if (d != 0) { 1399 printf("("); 1400 if (sc != NULL && sc->m1.bw_percent > 0) 1401 printf("%u%%", sc->m1.bw_percent); 1402 else 1403 printf("%s", rate2str((double)m1)); 1404 printf(" %u", d); 1405 } 1406 1407 if (sc != NULL && sc->m2.bw_percent > 0) 1408 printf(" %u%%", sc->m2.bw_percent); 1409 else 1410 printf(" %s", rate2str((double)m2)); 1411 1412 if (d != 0) 1413 printf(")"); 1414 } 1415 1416 void 1417 print_fairq_sc(const char *scname, u_int m1, u_int d, u_int m2, 1418 const struct node_fairq_sc *sc) 1419 { 1420 printf(" %s", scname); 1421 1422 if (d != 0) { 1423 printf("("); 1424 if (sc != NULL && sc->m1.bw_percent > 0) 1425 printf("%u%%", sc->m1.bw_percent); 1426 else 1427 printf("%s", rate2str((double)m1)); 1428 printf(" %u", d); 1429 } 1430 1431 if (sc != NULL && sc->m2.bw_percent > 0) 1432 printf(" %u%%", sc->m2.bw_percent); 1433 else 1434 printf(" %s", rate2str((double)m2)); 1435 1436 if (d != 0) 1437 printf(")"); 1438 } 1439