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