1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * net/sched/sch_ets.c Enhanced Transmission Selection scheduler 4 * 5 * Description 6 * ----------- 7 * 8 * The Enhanced Transmission Selection scheduler is a classful queuing 9 * discipline that merges functionality of PRIO and DRR qdiscs in one scheduler. 10 * ETS makes it easy to configure a set of strict and bandwidth-sharing bands to 11 * implement the transmission selection described in 802.1Qaz. 12 * 13 * Although ETS is technically classful, it's not possible to add and remove 14 * classes at will. Instead one specifies number of classes, how many are 15 * PRIO-like and how many DRR-like, and quanta for the latter. 16 * 17 * Algorithm 18 * --------- 19 * 20 * The strict classes, if any, are tried for traffic first: first band 0, if it 21 * has no traffic then band 1, etc. 22 * 23 * When there is no traffic in any of the strict queues, the bandwidth-sharing 24 * ones are tried next. Each band is assigned a deficit counter, initialized to 25 * "quantum" of that band. ETS maintains a list of active bandwidth-sharing 26 * bands whose qdiscs are non-empty. A packet is dequeued from the band at the 27 * head of the list if the packet size is smaller or equal to the deficit 28 * counter. If the counter is too small, it is increased by "quantum" and the 29 * scheduler moves on to the next band in the active list. 30 */ 31 32 #include <linux/module.h> 33 #include <net/gen_stats.h> 34 #include <net/netlink.h> 35 #include <net/pkt_cls.h> 36 #include <net/pkt_sched.h> 37 #include <net/sch_generic.h> 38 39 struct ets_class { 40 struct list_head alist; /* In struct ets_sched.active. */ 41 struct Qdisc *qdisc; 42 u32 quantum; 43 u32 deficit; 44 struct gnet_stats_basic_sync bstats; 45 struct gnet_stats_queue qstats; 46 }; 47 48 struct ets_sched { 49 struct list_head active; 50 struct tcf_proto __rcu *filter_list; 51 struct tcf_block *block; 52 unsigned int nbands; 53 unsigned int nstrict; 54 u8 prio2band[TC_PRIO_MAX + 1]; 55 struct ets_class classes[TCQ_ETS_MAX_BANDS]; 56 }; 57 58 static const struct nla_policy ets_policy[TCA_ETS_MAX + 1] = { 59 [TCA_ETS_NBANDS] = { .type = NLA_U8 }, 60 [TCA_ETS_NSTRICT] = { .type = NLA_U8 }, 61 [TCA_ETS_QUANTA] = { .type = NLA_NESTED }, 62 [TCA_ETS_PRIOMAP] = { .type = NLA_NESTED }, 63 }; 64 65 static const struct nla_policy ets_priomap_policy[TCA_ETS_MAX + 1] = { 66 [TCA_ETS_PRIOMAP_BAND] = { .type = NLA_U8 }, 67 }; 68 69 static const struct nla_policy ets_quanta_policy[TCA_ETS_MAX + 1] = { 70 [TCA_ETS_QUANTA_BAND] = { .type = NLA_U32 }, 71 }; 72 73 static const struct nla_policy ets_class_policy[TCA_ETS_MAX + 1] = { 74 [TCA_ETS_QUANTA_BAND] = { .type = NLA_U32 }, 75 }; 76 77 static int ets_quantum_parse(struct Qdisc *sch, const struct nlattr *attr, 78 unsigned int *quantum, 79 struct netlink_ext_ack *extack) 80 { 81 *quantum = nla_get_u32(attr); 82 if (!*quantum) { 83 NL_SET_ERR_MSG(extack, "ETS quantum cannot be zero"); 84 return -EINVAL; 85 } 86 return 0; 87 } 88 89 static struct ets_class * 90 ets_class_from_arg(struct Qdisc *sch, unsigned long arg) 91 { 92 struct ets_sched *q = qdisc_priv(sch); 93 94 return &q->classes[arg - 1]; 95 } 96 97 static u32 ets_class_id(struct Qdisc *sch, const struct ets_class *cl) 98 { 99 struct ets_sched *q = qdisc_priv(sch); 100 int band = cl - q->classes; 101 102 return TC_H_MAKE(sch->handle, band + 1); 103 } 104 105 static void ets_offload_change(struct Qdisc *sch) 106 { 107 struct net_device *dev = qdisc_dev(sch); 108 struct ets_sched *q = qdisc_priv(sch); 109 struct tc_ets_qopt_offload qopt; 110 unsigned int w_psum_prev = 0; 111 unsigned int q_psum = 0; 112 unsigned int q_sum = 0; 113 unsigned int quantum; 114 unsigned int w_psum; 115 unsigned int weight; 116 unsigned int i; 117 118 if (!tc_can_offload(dev) || !dev->netdev_ops->ndo_setup_tc) 119 return; 120 121 qopt.command = TC_ETS_REPLACE; 122 qopt.handle = sch->handle; 123 qopt.parent = sch->parent; 124 qopt.replace_params.bands = q->nbands; 125 qopt.replace_params.qstats = &sch->qstats; 126 memcpy(&qopt.replace_params.priomap, 127 q->prio2band, sizeof(q->prio2band)); 128 129 for (i = 0; i < q->nbands; i++) 130 q_sum += q->classes[i].quantum; 131 132 for (i = 0; i < q->nbands; i++) { 133 quantum = q->classes[i].quantum; 134 q_psum += quantum; 135 w_psum = quantum ? q_psum * 100 / q_sum : 0; 136 weight = w_psum - w_psum_prev; 137 w_psum_prev = w_psum; 138 139 qopt.replace_params.quanta[i] = quantum; 140 qopt.replace_params.weights[i] = weight; 141 } 142 143 dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_ETS, &qopt); 144 } 145 146 static void ets_offload_destroy(struct Qdisc *sch) 147 { 148 struct net_device *dev = qdisc_dev(sch); 149 struct tc_ets_qopt_offload qopt; 150 151 if (!tc_can_offload(dev) || !dev->netdev_ops->ndo_setup_tc) 152 return; 153 154 qopt.command = TC_ETS_DESTROY; 155 qopt.handle = sch->handle; 156 qopt.parent = sch->parent; 157 dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_ETS, &qopt); 158 } 159 160 static void ets_offload_graft(struct Qdisc *sch, struct Qdisc *new, 161 struct Qdisc *old, unsigned long arg, 162 struct netlink_ext_ack *extack) 163 { 164 struct net_device *dev = qdisc_dev(sch); 165 struct tc_ets_qopt_offload qopt; 166 167 qopt.command = TC_ETS_GRAFT; 168 qopt.handle = sch->handle; 169 qopt.parent = sch->parent; 170 qopt.graft_params.band = arg - 1; 171 qopt.graft_params.child_handle = new->handle; 172 173 qdisc_offload_graft_helper(dev, sch, new, old, TC_SETUP_QDISC_ETS, 174 &qopt, extack); 175 } 176 177 static int ets_offload_dump(struct Qdisc *sch) 178 { 179 struct tc_ets_qopt_offload qopt; 180 181 qopt.command = TC_ETS_STATS; 182 qopt.handle = sch->handle; 183 qopt.parent = sch->parent; 184 qopt.stats.bstats = &sch->bstats; 185 qopt.stats.qstats = &sch->qstats; 186 187 return qdisc_offload_dump_helper(sch, TC_SETUP_QDISC_ETS, &qopt); 188 } 189 190 static bool ets_class_is_strict(struct ets_sched *q, const struct ets_class *cl) 191 { 192 unsigned int band = cl - q->classes; 193 194 return band < q->nstrict; 195 } 196 197 static int ets_class_change(struct Qdisc *sch, u32 classid, u32 parentid, 198 struct nlattr **tca, unsigned long *arg, 199 struct netlink_ext_ack *extack) 200 { 201 struct ets_class *cl = ets_class_from_arg(sch, *arg); 202 struct ets_sched *q = qdisc_priv(sch); 203 struct nlattr *opt = tca[TCA_OPTIONS]; 204 struct nlattr *tb[TCA_ETS_MAX + 1]; 205 unsigned int quantum; 206 int err; 207 208 /* Classes can be added and removed only through Qdisc_ops.change 209 * interface. 210 */ 211 if (!cl) { 212 NL_SET_ERR_MSG(extack, "Fine-grained class addition and removal is not supported"); 213 return -EOPNOTSUPP; 214 } 215 216 if (!opt) { 217 NL_SET_ERR_MSG(extack, "ETS options are required for this operation"); 218 return -EINVAL; 219 } 220 221 err = nla_parse_nested(tb, TCA_ETS_MAX, opt, ets_class_policy, extack); 222 if (err < 0) 223 return err; 224 225 if (!tb[TCA_ETS_QUANTA_BAND]) 226 /* Nothing to configure. */ 227 return 0; 228 229 if (ets_class_is_strict(q, cl)) { 230 NL_SET_ERR_MSG(extack, "Strict bands do not have a configurable quantum"); 231 return -EINVAL; 232 } 233 234 err = ets_quantum_parse(sch, tb[TCA_ETS_QUANTA_BAND], &quantum, 235 extack); 236 if (err) 237 return err; 238 239 sch_tree_lock(sch); 240 cl->quantum = quantum; 241 sch_tree_unlock(sch); 242 243 ets_offload_change(sch); 244 return 0; 245 } 246 247 static int ets_class_graft(struct Qdisc *sch, unsigned long arg, 248 struct Qdisc *new, struct Qdisc **old, 249 struct netlink_ext_ack *extack) 250 { 251 struct ets_class *cl = ets_class_from_arg(sch, arg); 252 253 if (!new) { 254 new = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops, 255 ets_class_id(sch, cl), NULL); 256 if (!new) 257 new = &noop_qdisc; 258 else 259 qdisc_hash_add(new, true); 260 } 261 262 *old = qdisc_replace(sch, new, &cl->qdisc); 263 ets_offload_graft(sch, new, *old, arg, extack); 264 return 0; 265 } 266 267 static struct Qdisc *ets_class_leaf(struct Qdisc *sch, unsigned long arg) 268 { 269 struct ets_class *cl = ets_class_from_arg(sch, arg); 270 271 return cl->qdisc; 272 } 273 274 static unsigned long ets_class_find(struct Qdisc *sch, u32 classid) 275 { 276 unsigned long band = TC_H_MIN(classid); 277 struct ets_sched *q = qdisc_priv(sch); 278 279 if (band - 1 >= q->nbands) 280 return 0; 281 return band; 282 } 283 284 static void ets_class_qlen_notify(struct Qdisc *sch, unsigned long arg) 285 { 286 struct ets_class *cl = ets_class_from_arg(sch, arg); 287 struct ets_sched *q = qdisc_priv(sch); 288 289 /* We get notified about zero-length child Qdiscs as well if they are 290 * offloaded. Those aren't on the active list though, so don't attempt 291 * to remove them. 292 */ 293 if (!ets_class_is_strict(q, cl) && sch->q.qlen) 294 list_del(&cl->alist); 295 } 296 297 static int ets_class_dump(struct Qdisc *sch, unsigned long arg, 298 struct sk_buff *skb, struct tcmsg *tcm) 299 { 300 struct ets_class *cl = ets_class_from_arg(sch, arg); 301 struct ets_sched *q = qdisc_priv(sch); 302 struct nlattr *nest; 303 304 tcm->tcm_parent = TC_H_ROOT; 305 tcm->tcm_handle = ets_class_id(sch, cl); 306 tcm->tcm_info = cl->qdisc->handle; 307 308 nest = nla_nest_start_noflag(skb, TCA_OPTIONS); 309 if (!nest) 310 goto nla_put_failure; 311 if (!ets_class_is_strict(q, cl)) { 312 if (nla_put_u32(skb, TCA_ETS_QUANTA_BAND, cl->quantum)) 313 goto nla_put_failure; 314 } 315 return nla_nest_end(skb, nest); 316 317 nla_put_failure: 318 nla_nest_cancel(skb, nest); 319 return -EMSGSIZE; 320 } 321 322 static int ets_class_dump_stats(struct Qdisc *sch, unsigned long arg, 323 struct gnet_dump *d) 324 { 325 struct ets_class *cl = ets_class_from_arg(sch, arg); 326 struct Qdisc *cl_q = cl->qdisc; 327 328 if (gnet_stats_copy_basic(d, NULL, &cl_q->bstats, true) < 0 || 329 qdisc_qstats_copy(d, cl_q) < 0) 330 return -1; 331 332 return 0; 333 } 334 335 static void ets_qdisc_walk(struct Qdisc *sch, struct qdisc_walker *arg) 336 { 337 struct ets_sched *q = qdisc_priv(sch); 338 int i; 339 340 if (arg->stop) 341 return; 342 343 for (i = 0; i < q->nbands; i++) { 344 if (arg->count < arg->skip) { 345 arg->count++; 346 continue; 347 } 348 if (arg->fn(sch, i + 1, arg) < 0) { 349 arg->stop = 1; 350 break; 351 } 352 arg->count++; 353 } 354 } 355 356 static struct tcf_block * 357 ets_qdisc_tcf_block(struct Qdisc *sch, unsigned long cl, 358 struct netlink_ext_ack *extack) 359 { 360 struct ets_sched *q = qdisc_priv(sch); 361 362 if (cl) { 363 NL_SET_ERR_MSG(extack, "ETS classid must be zero"); 364 return NULL; 365 } 366 367 return q->block; 368 } 369 370 static unsigned long ets_qdisc_bind_tcf(struct Qdisc *sch, unsigned long parent, 371 u32 classid) 372 { 373 return ets_class_find(sch, classid); 374 } 375 376 static void ets_qdisc_unbind_tcf(struct Qdisc *sch, unsigned long arg) 377 { 378 } 379 380 static struct ets_class *ets_classify(struct sk_buff *skb, struct Qdisc *sch, 381 int *qerr) 382 { 383 struct ets_sched *q = qdisc_priv(sch); 384 u32 band = skb->priority; 385 struct tcf_result res; 386 struct tcf_proto *fl; 387 int err; 388 389 *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS; 390 if (TC_H_MAJ(skb->priority) != sch->handle) { 391 fl = rcu_dereference_bh(q->filter_list); 392 err = tcf_classify(skb, NULL, fl, &res, false); 393 #ifdef CONFIG_NET_CLS_ACT 394 switch (err) { 395 case TC_ACT_STOLEN: 396 case TC_ACT_QUEUED: 397 case TC_ACT_TRAP: 398 *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN; 399 fallthrough; 400 case TC_ACT_SHOT: 401 return NULL; 402 } 403 #endif 404 if (!fl || err < 0) { 405 if (TC_H_MAJ(band)) 406 band = 0; 407 return &q->classes[q->prio2band[band & TC_PRIO_MAX]]; 408 } 409 band = res.classid; 410 } 411 band = TC_H_MIN(band) - 1; 412 if (band >= q->nbands) 413 return &q->classes[q->prio2band[0]]; 414 return &q->classes[band]; 415 } 416 417 static int ets_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch, 418 struct sk_buff **to_free) 419 { 420 unsigned int len = qdisc_pkt_len(skb); 421 struct ets_sched *q = qdisc_priv(sch); 422 struct ets_class *cl; 423 int err = 0; 424 bool first; 425 426 cl = ets_classify(skb, sch, &err); 427 if (!cl) { 428 if (err & __NET_XMIT_BYPASS) 429 qdisc_qstats_drop(sch); 430 __qdisc_drop(skb, to_free); 431 return err; 432 } 433 434 first = !cl->qdisc->q.qlen; 435 err = qdisc_enqueue(skb, cl->qdisc, to_free); 436 if (unlikely(err != NET_XMIT_SUCCESS)) { 437 if (net_xmit_drop_count(err)) { 438 cl->qstats.drops++; 439 qdisc_qstats_drop(sch); 440 } 441 return err; 442 } 443 444 if (first && !ets_class_is_strict(q, cl)) { 445 list_add_tail(&cl->alist, &q->active); 446 cl->deficit = cl->quantum; 447 } 448 449 sch->qstats.backlog += len; 450 sch->q.qlen++; 451 return err; 452 } 453 454 static struct sk_buff * 455 ets_qdisc_dequeue_skb(struct Qdisc *sch, struct sk_buff *skb) 456 { 457 qdisc_bstats_update(sch, skb); 458 qdisc_qstats_backlog_dec(sch, skb); 459 sch->q.qlen--; 460 return skb; 461 } 462 463 static struct sk_buff *ets_qdisc_dequeue(struct Qdisc *sch) 464 { 465 struct ets_sched *q = qdisc_priv(sch); 466 struct ets_class *cl; 467 struct sk_buff *skb; 468 unsigned int band; 469 unsigned int len; 470 471 while (1) { 472 for (band = 0; band < q->nstrict; band++) { 473 cl = &q->classes[band]; 474 skb = qdisc_dequeue_peeked(cl->qdisc); 475 if (skb) 476 return ets_qdisc_dequeue_skb(sch, skb); 477 } 478 479 if (list_empty(&q->active)) 480 goto out; 481 482 cl = list_first_entry(&q->active, struct ets_class, alist); 483 skb = cl->qdisc->ops->peek(cl->qdisc); 484 if (!skb) { 485 qdisc_warn_nonwc(__func__, cl->qdisc); 486 goto out; 487 } 488 489 len = qdisc_pkt_len(skb); 490 if (len <= cl->deficit) { 491 cl->deficit -= len; 492 skb = qdisc_dequeue_peeked(cl->qdisc); 493 if (unlikely(!skb)) 494 goto out; 495 if (cl->qdisc->q.qlen == 0) 496 list_del(&cl->alist); 497 return ets_qdisc_dequeue_skb(sch, skb); 498 } 499 500 cl->deficit += cl->quantum; 501 list_move_tail(&cl->alist, &q->active); 502 } 503 out: 504 return NULL; 505 } 506 507 static int ets_qdisc_priomap_parse(struct nlattr *priomap_attr, 508 unsigned int nbands, u8 *priomap, 509 struct netlink_ext_ack *extack) 510 { 511 const struct nlattr *attr; 512 int prio = 0; 513 u8 band; 514 int rem; 515 int err; 516 517 err = __nla_validate_nested(priomap_attr, TCA_ETS_MAX, 518 ets_priomap_policy, NL_VALIDATE_STRICT, 519 extack); 520 if (err) 521 return err; 522 523 nla_for_each_nested(attr, priomap_attr, rem) { 524 switch (nla_type(attr)) { 525 case TCA_ETS_PRIOMAP_BAND: 526 if (prio > TC_PRIO_MAX) { 527 NL_SET_ERR_MSG_MOD(extack, "Too many priorities in ETS priomap"); 528 return -EINVAL; 529 } 530 band = nla_get_u8(attr); 531 if (band >= nbands) { 532 NL_SET_ERR_MSG_MOD(extack, "Invalid band number in ETS priomap"); 533 return -EINVAL; 534 } 535 priomap[prio++] = band; 536 break; 537 default: 538 WARN_ON_ONCE(1); /* Validate should have caught this. */ 539 return -EINVAL; 540 } 541 } 542 543 return 0; 544 } 545 546 static int ets_qdisc_quanta_parse(struct Qdisc *sch, struct nlattr *quanta_attr, 547 unsigned int nbands, unsigned int nstrict, 548 unsigned int *quanta, 549 struct netlink_ext_ack *extack) 550 { 551 const struct nlattr *attr; 552 int band = nstrict; 553 int rem; 554 int err; 555 556 err = __nla_validate_nested(quanta_attr, TCA_ETS_MAX, 557 ets_quanta_policy, NL_VALIDATE_STRICT, 558 extack); 559 if (err < 0) 560 return err; 561 562 nla_for_each_nested(attr, quanta_attr, rem) { 563 switch (nla_type(attr)) { 564 case TCA_ETS_QUANTA_BAND: 565 if (band >= nbands) { 566 NL_SET_ERR_MSG_MOD(extack, "ETS quanta has more values than bands"); 567 return -EINVAL; 568 } 569 err = ets_quantum_parse(sch, attr, &quanta[band++], 570 extack); 571 if (err) 572 return err; 573 break; 574 default: 575 WARN_ON_ONCE(1); /* Validate should have caught this. */ 576 return -EINVAL; 577 } 578 } 579 580 return 0; 581 } 582 583 static int ets_qdisc_change(struct Qdisc *sch, struct nlattr *opt, 584 struct netlink_ext_ack *extack) 585 { 586 unsigned int quanta[TCQ_ETS_MAX_BANDS] = {0}; 587 struct Qdisc *queues[TCQ_ETS_MAX_BANDS]; 588 struct ets_sched *q = qdisc_priv(sch); 589 struct nlattr *tb[TCA_ETS_MAX + 1]; 590 unsigned int oldbands = q->nbands; 591 u8 priomap[TC_PRIO_MAX + 1]; 592 unsigned int nstrict = 0; 593 unsigned int nbands; 594 unsigned int i; 595 int err; 596 597 if (!opt) { 598 NL_SET_ERR_MSG(extack, "ETS options are required for this operation"); 599 return -EINVAL; 600 } 601 602 err = nla_parse_nested(tb, TCA_ETS_MAX, opt, ets_policy, extack); 603 if (err < 0) 604 return err; 605 606 if (!tb[TCA_ETS_NBANDS]) { 607 NL_SET_ERR_MSG_MOD(extack, "Number of bands is a required argument"); 608 return -EINVAL; 609 } 610 nbands = nla_get_u8(tb[TCA_ETS_NBANDS]); 611 if (nbands < 1 || nbands > TCQ_ETS_MAX_BANDS) { 612 NL_SET_ERR_MSG_MOD(extack, "Invalid number of bands"); 613 return -EINVAL; 614 } 615 /* Unless overridden, traffic goes to the last band. */ 616 memset(priomap, nbands - 1, sizeof(priomap)); 617 618 if (tb[TCA_ETS_NSTRICT]) { 619 nstrict = nla_get_u8(tb[TCA_ETS_NSTRICT]); 620 if (nstrict > nbands) { 621 NL_SET_ERR_MSG_MOD(extack, "Invalid number of strict bands"); 622 return -EINVAL; 623 } 624 } 625 626 if (tb[TCA_ETS_PRIOMAP]) { 627 err = ets_qdisc_priomap_parse(tb[TCA_ETS_PRIOMAP], 628 nbands, priomap, extack); 629 if (err) 630 return err; 631 } 632 633 if (tb[TCA_ETS_QUANTA]) { 634 err = ets_qdisc_quanta_parse(sch, tb[TCA_ETS_QUANTA], 635 nbands, nstrict, quanta, extack); 636 if (err) 637 return err; 638 } 639 /* If there are more bands than strict + quanta provided, the remaining 640 * ones are ETS with quantum of MTU. Initialize the missing values here. 641 */ 642 for (i = nstrict; i < nbands; i++) { 643 if (!quanta[i]) 644 quanta[i] = psched_mtu(qdisc_dev(sch)); 645 } 646 647 /* Before commit, make sure we can allocate all new qdiscs */ 648 for (i = oldbands; i < nbands; i++) { 649 queues[i] = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops, 650 ets_class_id(sch, &q->classes[i]), 651 extack); 652 if (!queues[i]) { 653 while (i > oldbands) 654 qdisc_put(queues[--i]); 655 return -ENOMEM; 656 } 657 } 658 659 sch_tree_lock(sch); 660 661 q->nbands = nbands; 662 for (i = nstrict; i < q->nstrict; i++) { 663 if (q->classes[i].qdisc->q.qlen) { 664 list_add_tail(&q->classes[i].alist, &q->active); 665 q->classes[i].deficit = quanta[i]; 666 } 667 } 668 for (i = q->nbands; i < oldbands; i++) { 669 if (i >= q->nstrict && q->classes[i].qdisc->q.qlen) 670 list_del(&q->classes[i].alist); 671 qdisc_tree_flush_backlog(q->classes[i].qdisc); 672 } 673 q->nstrict = nstrict; 674 memcpy(q->prio2band, priomap, sizeof(priomap)); 675 676 for (i = 0; i < q->nbands; i++) 677 q->classes[i].quantum = quanta[i]; 678 679 for (i = oldbands; i < q->nbands; i++) { 680 q->classes[i].qdisc = queues[i]; 681 if (q->classes[i].qdisc != &noop_qdisc) 682 qdisc_hash_add(q->classes[i].qdisc, true); 683 } 684 685 sch_tree_unlock(sch); 686 687 ets_offload_change(sch); 688 for (i = q->nbands; i < oldbands; i++) { 689 qdisc_put(q->classes[i].qdisc); 690 q->classes[i].qdisc = NULL; 691 q->classes[i].quantum = 0; 692 q->classes[i].deficit = 0; 693 gnet_stats_basic_sync_init(&q->classes[i].bstats); 694 memset(&q->classes[i].qstats, 0, sizeof(q->classes[i].qstats)); 695 } 696 return 0; 697 } 698 699 static int ets_qdisc_init(struct Qdisc *sch, struct nlattr *opt, 700 struct netlink_ext_ack *extack) 701 { 702 struct ets_sched *q = qdisc_priv(sch); 703 int err, i; 704 705 if (!opt) 706 return -EINVAL; 707 708 err = tcf_block_get(&q->block, &q->filter_list, sch, extack); 709 if (err) 710 return err; 711 712 INIT_LIST_HEAD(&q->active); 713 for (i = 0; i < TCQ_ETS_MAX_BANDS; i++) 714 INIT_LIST_HEAD(&q->classes[i].alist); 715 716 return ets_qdisc_change(sch, opt, extack); 717 } 718 719 static void ets_qdisc_reset(struct Qdisc *sch) 720 { 721 struct ets_sched *q = qdisc_priv(sch); 722 int band; 723 724 for (band = q->nstrict; band < q->nbands; band++) { 725 if (q->classes[band].qdisc->q.qlen) 726 list_del(&q->classes[band].alist); 727 } 728 for (band = 0; band < q->nbands; band++) 729 qdisc_reset(q->classes[band].qdisc); 730 sch->qstats.backlog = 0; 731 sch->q.qlen = 0; 732 } 733 734 static void ets_qdisc_destroy(struct Qdisc *sch) 735 { 736 struct ets_sched *q = qdisc_priv(sch); 737 int band; 738 739 ets_offload_destroy(sch); 740 tcf_block_put(q->block); 741 for (band = 0; band < q->nbands; band++) 742 qdisc_put(q->classes[band].qdisc); 743 } 744 745 static int ets_qdisc_dump(struct Qdisc *sch, struct sk_buff *skb) 746 { 747 struct ets_sched *q = qdisc_priv(sch); 748 struct nlattr *opts; 749 struct nlattr *nest; 750 int band; 751 int prio; 752 int err; 753 754 err = ets_offload_dump(sch); 755 if (err) 756 return err; 757 758 opts = nla_nest_start_noflag(skb, TCA_OPTIONS); 759 if (!opts) 760 goto nla_err; 761 762 if (nla_put_u8(skb, TCA_ETS_NBANDS, q->nbands)) 763 goto nla_err; 764 765 if (q->nstrict && 766 nla_put_u8(skb, TCA_ETS_NSTRICT, q->nstrict)) 767 goto nla_err; 768 769 if (q->nbands > q->nstrict) { 770 nest = nla_nest_start(skb, TCA_ETS_QUANTA); 771 if (!nest) 772 goto nla_err; 773 774 for (band = q->nstrict; band < q->nbands; band++) { 775 if (nla_put_u32(skb, TCA_ETS_QUANTA_BAND, 776 q->classes[band].quantum)) 777 goto nla_err; 778 } 779 780 nla_nest_end(skb, nest); 781 } 782 783 nest = nla_nest_start(skb, TCA_ETS_PRIOMAP); 784 if (!nest) 785 goto nla_err; 786 787 for (prio = 0; prio <= TC_PRIO_MAX; prio++) { 788 if (nla_put_u8(skb, TCA_ETS_PRIOMAP_BAND, q->prio2band[prio])) 789 goto nla_err; 790 } 791 792 nla_nest_end(skb, nest); 793 794 return nla_nest_end(skb, opts); 795 796 nla_err: 797 nla_nest_cancel(skb, opts); 798 return -EMSGSIZE; 799 } 800 801 static const struct Qdisc_class_ops ets_class_ops = { 802 .change = ets_class_change, 803 .graft = ets_class_graft, 804 .leaf = ets_class_leaf, 805 .find = ets_class_find, 806 .qlen_notify = ets_class_qlen_notify, 807 .dump = ets_class_dump, 808 .dump_stats = ets_class_dump_stats, 809 .walk = ets_qdisc_walk, 810 .tcf_block = ets_qdisc_tcf_block, 811 .bind_tcf = ets_qdisc_bind_tcf, 812 .unbind_tcf = ets_qdisc_unbind_tcf, 813 }; 814 815 static struct Qdisc_ops ets_qdisc_ops __read_mostly = { 816 .cl_ops = &ets_class_ops, 817 .id = "ets", 818 .priv_size = sizeof(struct ets_sched), 819 .enqueue = ets_qdisc_enqueue, 820 .dequeue = ets_qdisc_dequeue, 821 .peek = qdisc_peek_dequeued, 822 .change = ets_qdisc_change, 823 .init = ets_qdisc_init, 824 .reset = ets_qdisc_reset, 825 .destroy = ets_qdisc_destroy, 826 .dump = ets_qdisc_dump, 827 .owner = THIS_MODULE, 828 }; 829 830 static int __init ets_init(void) 831 { 832 return register_qdisc(&ets_qdisc_ops); 833 } 834 835 static void __exit ets_exit(void) 836 { 837 unregister_qdisc(&ets_qdisc_ops); 838 } 839 840 module_init(ets_init); 841 module_exit(ets_exit); 842 MODULE_LICENSE("GPL"); 843