1 // SPDX-License-Identifier: GPL-2.0-or-later 2 3 #include <linux/bits.h> 4 #include <linux/bitfield.h> 5 #include <linux/idr.h> 6 #include <linux/kernel.h> 7 #include <linux/netdevice.h> 8 #include <linux/netlink.h> 9 #include <linux/skbuff.h> 10 #include <linux/xarray.h> 11 #include <net/devlink.h> 12 #include <net/net_shaper.h> 13 14 #include "shaper_nl_gen.h" 15 16 #include "../core/dev.h" 17 18 #define NET_SHAPER_SCOPE_SHIFT 26 19 #define NET_SHAPER_ID_MASK GENMASK(NET_SHAPER_SCOPE_SHIFT - 1, 0) 20 #define NET_SHAPER_SCOPE_MASK GENMASK(31, NET_SHAPER_SCOPE_SHIFT) 21 22 #define NET_SHAPER_ID_UNSPEC NET_SHAPER_ID_MASK 23 24 struct net_shaper_hierarchy { 25 struct xarray shapers; 26 }; 27 28 struct net_shaper_nl_ctx { 29 struct net_shaper_binding binding; 30 netdevice_tracker dev_tracker; 31 unsigned long start_index; 32 }; 33 34 static struct net_shaper_binding *net_shaper_binding_from_ctx(void *ctx) 35 { 36 return &((struct net_shaper_nl_ctx *)ctx)->binding; 37 } 38 39 static void net_shaper_lock(struct net_shaper_binding *binding) 40 { 41 switch (binding->type) { 42 case NET_SHAPER_BINDING_TYPE_NETDEV: 43 mutex_lock(&binding->netdev->lock); 44 break; 45 } 46 } 47 48 static void net_shaper_unlock(struct net_shaper_binding *binding) 49 { 50 switch (binding->type) { 51 case NET_SHAPER_BINDING_TYPE_NETDEV: 52 mutex_unlock(&binding->netdev->lock); 53 break; 54 } 55 } 56 57 static struct net_shaper_hierarchy * 58 net_shaper_hierarchy(struct net_shaper_binding *binding) 59 { 60 /* Pairs with WRITE_ONCE() in net_shaper_hierarchy_setup. */ 61 if (binding->type == NET_SHAPER_BINDING_TYPE_NETDEV) 62 return READ_ONCE(binding->netdev->net_shaper_hierarchy); 63 64 /* No other type supported yet. */ 65 return NULL; 66 } 67 68 static const struct net_shaper_ops * 69 net_shaper_ops(struct net_shaper_binding *binding) 70 { 71 if (binding->type == NET_SHAPER_BINDING_TYPE_NETDEV) 72 return binding->netdev->netdev_ops->net_shaper_ops; 73 74 /* No other type supported yet. */ 75 return NULL; 76 } 77 78 /* Count the number of [multi] attributes of the given type. */ 79 static int net_shaper_list_len(struct genl_info *info, int type) 80 { 81 struct nlattr *attr; 82 int rem, cnt = 0; 83 84 nla_for_each_attr_type(attr, type, genlmsg_data(info->genlhdr), 85 genlmsg_len(info->genlhdr), rem) 86 cnt++; 87 return cnt; 88 } 89 90 static int net_shaper_handle_size(void) 91 { 92 return nla_total_size(nla_total_size(sizeof(u32)) + 93 nla_total_size(sizeof(u32))); 94 } 95 96 static int net_shaper_fill_binding(struct sk_buff *msg, 97 const struct net_shaper_binding *binding, 98 u32 type) 99 { 100 /* Should never happen, as currently only NETDEV is supported. */ 101 if (WARN_ON_ONCE(binding->type != NET_SHAPER_BINDING_TYPE_NETDEV)) 102 return -EINVAL; 103 104 if (nla_put_u32(msg, type, binding->netdev->ifindex)) 105 return -EMSGSIZE; 106 107 return 0; 108 } 109 110 static int net_shaper_fill_handle(struct sk_buff *msg, 111 const struct net_shaper_handle *handle, 112 u32 type) 113 { 114 struct nlattr *handle_attr; 115 116 if (handle->scope == NET_SHAPER_SCOPE_UNSPEC) 117 return 0; 118 119 handle_attr = nla_nest_start(msg, type); 120 if (!handle_attr) 121 return -EMSGSIZE; 122 123 if (nla_put_u32(msg, NET_SHAPER_A_HANDLE_SCOPE, handle->scope) || 124 (handle->scope >= NET_SHAPER_SCOPE_QUEUE && 125 nla_put_u32(msg, NET_SHAPER_A_HANDLE_ID, handle->id))) 126 goto handle_nest_cancel; 127 128 nla_nest_end(msg, handle_attr); 129 return 0; 130 131 handle_nest_cancel: 132 nla_nest_cancel(msg, handle_attr); 133 return -EMSGSIZE; 134 } 135 136 static int 137 net_shaper_fill_one(struct sk_buff *msg, 138 const struct net_shaper_binding *binding, 139 const struct net_shaper *shaper, 140 const struct genl_info *info) 141 { 142 void *hdr; 143 144 hdr = genlmsg_iput(msg, info); 145 if (!hdr) 146 return -EMSGSIZE; 147 148 if (net_shaper_fill_binding(msg, binding, NET_SHAPER_A_IFINDEX) || 149 net_shaper_fill_handle(msg, &shaper->parent, 150 NET_SHAPER_A_PARENT) || 151 net_shaper_fill_handle(msg, &shaper->handle, 152 NET_SHAPER_A_HANDLE) || 153 ((shaper->bw_min || shaper->bw_max || shaper->burst) && 154 nla_put_u32(msg, NET_SHAPER_A_METRIC, shaper->metric)) || 155 (shaper->bw_min && 156 nla_put_uint(msg, NET_SHAPER_A_BW_MIN, shaper->bw_min)) || 157 (shaper->bw_max && 158 nla_put_uint(msg, NET_SHAPER_A_BW_MAX, shaper->bw_max)) || 159 (shaper->burst && 160 nla_put_uint(msg, NET_SHAPER_A_BURST, shaper->burst)) || 161 (shaper->priority && 162 nla_put_u32(msg, NET_SHAPER_A_PRIORITY, shaper->priority)) || 163 (shaper->weight && 164 nla_put_u32(msg, NET_SHAPER_A_WEIGHT, shaper->weight))) 165 goto nla_put_failure; 166 167 genlmsg_end(msg, hdr); 168 169 return 0; 170 171 nla_put_failure: 172 genlmsg_cancel(msg, hdr); 173 return -EMSGSIZE; 174 } 175 176 /* Initialize the context fetching the relevant device and 177 * acquiring a reference to it. 178 */ 179 static int net_shaper_ctx_setup(const struct genl_info *info, int type, 180 struct net_shaper_nl_ctx *ctx) 181 { 182 struct net *ns = genl_info_net(info); 183 struct net_device *dev; 184 int ifindex; 185 186 if (GENL_REQ_ATTR_CHECK(info, type)) 187 return -EINVAL; 188 189 ifindex = nla_get_u32(info->attrs[type]); 190 dev = netdev_get_by_index(ns, ifindex, &ctx->dev_tracker, GFP_KERNEL); 191 if (!dev) { 192 NL_SET_BAD_ATTR(info->extack, info->attrs[type]); 193 return -ENOENT; 194 } 195 196 if (!dev->netdev_ops->net_shaper_ops) { 197 NL_SET_BAD_ATTR(info->extack, info->attrs[type]); 198 netdev_put(dev, &ctx->dev_tracker); 199 return -EOPNOTSUPP; 200 } 201 202 ctx->binding.type = NET_SHAPER_BINDING_TYPE_NETDEV; 203 ctx->binding.netdev = dev; 204 return 0; 205 } 206 207 static void net_shaper_ctx_cleanup(struct net_shaper_nl_ctx *ctx) 208 { 209 if (ctx->binding.type == NET_SHAPER_BINDING_TYPE_NETDEV) 210 netdev_put(ctx->binding.netdev, &ctx->dev_tracker); 211 } 212 213 static u32 net_shaper_handle_to_index(const struct net_shaper_handle *handle) 214 { 215 return FIELD_PREP(NET_SHAPER_SCOPE_MASK, handle->scope) | 216 FIELD_PREP(NET_SHAPER_ID_MASK, handle->id); 217 } 218 219 static void net_shaper_index_to_handle(u32 index, 220 struct net_shaper_handle *handle) 221 { 222 handle->scope = FIELD_GET(NET_SHAPER_SCOPE_MASK, index); 223 handle->id = FIELD_GET(NET_SHAPER_ID_MASK, index); 224 } 225 226 static void net_shaper_default_parent(const struct net_shaper_handle *handle, 227 struct net_shaper_handle *parent) 228 { 229 switch (handle->scope) { 230 case NET_SHAPER_SCOPE_UNSPEC: 231 case NET_SHAPER_SCOPE_NETDEV: 232 case __NET_SHAPER_SCOPE_MAX: 233 parent->scope = NET_SHAPER_SCOPE_UNSPEC; 234 break; 235 236 case NET_SHAPER_SCOPE_QUEUE: 237 case NET_SHAPER_SCOPE_NODE: 238 parent->scope = NET_SHAPER_SCOPE_NETDEV; 239 break; 240 } 241 parent->id = 0; 242 } 243 244 /* 245 * MARK_0 is already in use due to XA_FLAGS_ALLOC, can't reuse such flag as 246 * it's cleared by xa_store(). 247 */ 248 #define NET_SHAPER_NOT_VALID XA_MARK_1 249 250 static struct net_shaper * 251 net_shaper_lookup(struct net_shaper_binding *binding, 252 const struct net_shaper_handle *handle) 253 { 254 struct net_shaper_hierarchy *hierarchy = net_shaper_hierarchy(binding); 255 u32 index = net_shaper_handle_to_index(handle); 256 257 if (!hierarchy || xa_get_mark(&hierarchy->shapers, index, 258 NET_SHAPER_NOT_VALID)) 259 return NULL; 260 261 return xa_load(&hierarchy->shapers, index); 262 } 263 264 /* Allocate on demand the per device shaper's hierarchy container. 265 * Called under the net shaper lock 266 */ 267 static struct net_shaper_hierarchy * 268 net_shaper_hierarchy_setup(struct net_shaper_binding *binding) 269 { 270 struct net_shaper_hierarchy *hierarchy = net_shaper_hierarchy(binding); 271 272 if (hierarchy) 273 return hierarchy; 274 275 hierarchy = kmalloc(sizeof(*hierarchy), GFP_KERNEL); 276 if (!hierarchy) 277 return NULL; 278 279 /* The flag is required for ID allocation */ 280 xa_init_flags(&hierarchy->shapers, XA_FLAGS_ALLOC); 281 282 switch (binding->type) { 283 case NET_SHAPER_BINDING_TYPE_NETDEV: 284 /* Pairs with READ_ONCE in net_shaper_hierarchy. */ 285 WRITE_ONCE(binding->netdev->net_shaper_hierarchy, hierarchy); 286 break; 287 } 288 return hierarchy; 289 } 290 291 /* Prepare the hierarchy container to actually insert the given shaper, doing 292 * in advance the needed allocations. 293 */ 294 static int net_shaper_pre_insert(struct net_shaper_binding *binding, 295 struct net_shaper_handle *handle, 296 struct netlink_ext_ack *extack) 297 { 298 struct net_shaper_hierarchy *hierarchy = net_shaper_hierarchy(binding); 299 struct net_shaper *prev, *cur; 300 bool id_allocated = false; 301 int ret, index; 302 303 if (!hierarchy) 304 return -ENOMEM; 305 306 index = net_shaper_handle_to_index(handle); 307 cur = xa_load(&hierarchy->shapers, index); 308 if (cur) 309 return 0; 310 311 /* Allocated a new id, if needed. */ 312 if (handle->scope == NET_SHAPER_SCOPE_NODE && 313 handle->id == NET_SHAPER_ID_UNSPEC) { 314 u32 min, max; 315 316 handle->id = NET_SHAPER_ID_MASK - 1; 317 max = net_shaper_handle_to_index(handle); 318 handle->id = 0; 319 min = net_shaper_handle_to_index(handle); 320 321 ret = xa_alloc(&hierarchy->shapers, &index, NULL, 322 XA_LIMIT(min, max), GFP_KERNEL); 323 if (ret < 0) { 324 NL_SET_ERR_MSG(extack, "Can't allocate new id for NODE shaper"); 325 return ret; 326 } 327 328 net_shaper_index_to_handle(index, handle); 329 id_allocated = true; 330 } 331 332 cur = kzalloc(sizeof(*cur), GFP_KERNEL); 333 if (!cur) { 334 ret = -ENOMEM; 335 goto free_id; 336 } 337 338 /* Mark 'tentative' shaper inside the hierarchy container. 339 * xa_set_mark is a no-op if the previous store fails. 340 */ 341 xa_lock(&hierarchy->shapers); 342 prev = __xa_store(&hierarchy->shapers, index, cur, GFP_KERNEL); 343 __xa_set_mark(&hierarchy->shapers, index, NET_SHAPER_NOT_VALID); 344 xa_unlock(&hierarchy->shapers); 345 if (xa_err(prev)) { 346 NL_SET_ERR_MSG(extack, "Can't insert shaper into device store"); 347 kfree_rcu(cur, rcu); 348 ret = xa_err(prev); 349 goto free_id; 350 } 351 return 0; 352 353 free_id: 354 if (id_allocated) 355 xa_erase(&hierarchy->shapers, index); 356 return ret; 357 } 358 359 /* Commit the tentative insert with the actual values. 360 * Must be called only after a successful net_shaper_pre_insert(). 361 */ 362 static void net_shaper_commit(struct net_shaper_binding *binding, 363 int nr_shapers, const struct net_shaper *shapers) 364 { 365 struct net_shaper_hierarchy *hierarchy = net_shaper_hierarchy(binding); 366 struct net_shaper *cur; 367 int index; 368 int i; 369 370 xa_lock(&hierarchy->shapers); 371 for (i = 0; i < nr_shapers; ++i) { 372 index = net_shaper_handle_to_index(&shapers[i].handle); 373 374 cur = xa_load(&hierarchy->shapers, index); 375 if (WARN_ON_ONCE(!cur)) 376 continue; 377 378 /* Successful update: drop the tentative mark 379 * and update the hierarchy container. 380 */ 381 __xa_clear_mark(&hierarchy->shapers, index, 382 NET_SHAPER_NOT_VALID); 383 *cur = shapers[i]; 384 } 385 xa_unlock(&hierarchy->shapers); 386 } 387 388 /* Rollback all the tentative inserts from the hierarchy. */ 389 static void net_shaper_rollback(struct net_shaper_binding *binding) 390 { 391 struct net_shaper_hierarchy *hierarchy = net_shaper_hierarchy(binding); 392 struct net_shaper *cur; 393 unsigned long index; 394 395 if (!hierarchy) 396 return; 397 398 xa_lock(&hierarchy->shapers); 399 xa_for_each_marked(&hierarchy->shapers, index, cur, 400 NET_SHAPER_NOT_VALID) { 401 __xa_erase(&hierarchy->shapers, index); 402 kfree(cur); 403 } 404 xa_unlock(&hierarchy->shapers); 405 } 406 407 static int net_shaper_parse_handle(const struct nlattr *attr, 408 const struct genl_info *info, 409 struct net_shaper_handle *handle) 410 { 411 struct nlattr *tb[NET_SHAPER_A_HANDLE_MAX + 1]; 412 struct nlattr *id_attr; 413 u32 id = 0; 414 int ret; 415 416 ret = nla_parse_nested(tb, NET_SHAPER_A_HANDLE_MAX, attr, 417 net_shaper_handle_nl_policy, info->extack); 418 if (ret < 0) 419 return ret; 420 421 if (NL_REQ_ATTR_CHECK(info->extack, attr, tb, 422 NET_SHAPER_A_HANDLE_SCOPE)) 423 return -EINVAL; 424 425 handle->scope = nla_get_u32(tb[NET_SHAPER_A_HANDLE_SCOPE]); 426 427 /* The default id for NODE scope shapers is an invalid one 428 * to help the 'group' operation discriminate between new 429 * NODE shaper creation (ID_UNSPEC) and reuse of existing 430 * shaper (any other value). 431 */ 432 id_attr = tb[NET_SHAPER_A_HANDLE_ID]; 433 if (id_attr) 434 id = nla_get_u32(id_attr); 435 else if (handle->scope == NET_SHAPER_SCOPE_NODE) 436 id = NET_SHAPER_ID_UNSPEC; 437 438 handle->id = id; 439 return 0; 440 } 441 442 static int net_shaper_validate_caps(struct net_shaper_binding *binding, 443 struct nlattr **tb, 444 const struct genl_info *info, 445 struct net_shaper *shaper) 446 { 447 const struct net_shaper_ops *ops = net_shaper_ops(binding); 448 struct nlattr *bad = NULL; 449 unsigned long caps = 0; 450 451 ops->capabilities(binding, shaper->handle.scope, &caps); 452 453 if (tb[NET_SHAPER_A_PRIORITY] && 454 !(caps & BIT(NET_SHAPER_A_CAPS_SUPPORT_PRIORITY))) 455 bad = tb[NET_SHAPER_A_PRIORITY]; 456 if (tb[NET_SHAPER_A_WEIGHT] && 457 !(caps & BIT(NET_SHAPER_A_CAPS_SUPPORT_WEIGHT))) 458 bad = tb[NET_SHAPER_A_WEIGHT]; 459 if (tb[NET_SHAPER_A_BW_MIN] && 460 !(caps & BIT(NET_SHAPER_A_CAPS_SUPPORT_BW_MIN))) 461 bad = tb[NET_SHAPER_A_BW_MIN]; 462 if (tb[NET_SHAPER_A_BW_MAX] && 463 !(caps & BIT(NET_SHAPER_A_CAPS_SUPPORT_BW_MAX))) 464 bad = tb[NET_SHAPER_A_BW_MAX]; 465 if (tb[NET_SHAPER_A_BURST] && 466 !(caps & BIT(NET_SHAPER_A_CAPS_SUPPORT_BURST))) 467 bad = tb[NET_SHAPER_A_BURST]; 468 469 if (!caps) 470 bad = tb[NET_SHAPER_A_HANDLE]; 471 472 if (bad) { 473 NL_SET_BAD_ATTR(info->extack, bad); 474 return -EOPNOTSUPP; 475 } 476 477 if (shaper->handle.scope == NET_SHAPER_SCOPE_QUEUE && 478 binding->type == NET_SHAPER_BINDING_TYPE_NETDEV && 479 shaper->handle.id >= binding->netdev->real_num_tx_queues) { 480 NL_SET_ERR_MSG_FMT(info->extack, 481 "Not existing queue id %d max %d", 482 shaper->handle.id, 483 binding->netdev->real_num_tx_queues); 484 return -ENOENT; 485 } 486 487 /* The metric is really used only if there is *any* rate-related 488 * setting, either in current attributes set or in pre-existing 489 * values. 490 */ 491 if (shaper->burst || shaper->bw_min || shaper->bw_max) { 492 u32 metric_cap = NET_SHAPER_A_CAPS_SUPPORT_METRIC_BPS + 493 shaper->metric; 494 495 /* The metric test can fail even when the user did not 496 * specify the METRIC attribute. Pointing to rate related 497 * attribute will be confusing, as the attribute itself 498 * could be indeed supported, with a different metric. 499 * Be more specific. 500 */ 501 if (!(caps & BIT(metric_cap))) { 502 NL_SET_ERR_MSG_FMT(info->extack, "Bad metric %d", 503 shaper->metric); 504 return -EOPNOTSUPP; 505 } 506 } 507 return 0; 508 } 509 510 static int net_shaper_parse_info(struct net_shaper_binding *binding, 511 struct nlattr **tb, 512 const struct genl_info *info, 513 struct net_shaper *shaper, 514 bool *exists) 515 { 516 struct net_shaper *old; 517 int ret; 518 519 /* The shaper handle is the only mandatory attribute. */ 520 if (NL_REQ_ATTR_CHECK(info->extack, NULL, tb, NET_SHAPER_A_HANDLE)) 521 return -EINVAL; 522 523 ret = net_shaper_parse_handle(tb[NET_SHAPER_A_HANDLE], info, 524 &shaper->handle); 525 if (ret) 526 return ret; 527 528 if (shaper->handle.scope == NET_SHAPER_SCOPE_UNSPEC) { 529 NL_SET_BAD_ATTR(info->extack, tb[NET_SHAPER_A_HANDLE]); 530 return -EINVAL; 531 } 532 533 /* Fetch existing hierarchy, if any, so that user provide info will 534 * incrementally update the existing shaper configuration. 535 */ 536 old = net_shaper_lookup(binding, &shaper->handle); 537 if (old) 538 *shaper = *old; 539 *exists = !!old; 540 541 if (tb[NET_SHAPER_A_METRIC]) 542 shaper->metric = nla_get_u32(tb[NET_SHAPER_A_METRIC]); 543 544 if (tb[NET_SHAPER_A_BW_MIN]) 545 shaper->bw_min = nla_get_uint(tb[NET_SHAPER_A_BW_MIN]); 546 547 if (tb[NET_SHAPER_A_BW_MAX]) 548 shaper->bw_max = nla_get_uint(tb[NET_SHAPER_A_BW_MAX]); 549 550 if (tb[NET_SHAPER_A_BURST]) 551 shaper->burst = nla_get_uint(tb[NET_SHAPER_A_BURST]); 552 553 if (tb[NET_SHAPER_A_PRIORITY]) 554 shaper->priority = nla_get_u32(tb[NET_SHAPER_A_PRIORITY]); 555 556 if (tb[NET_SHAPER_A_WEIGHT]) 557 shaper->weight = nla_get_u32(tb[NET_SHAPER_A_WEIGHT]); 558 559 ret = net_shaper_validate_caps(binding, tb, info, shaper); 560 if (ret < 0) 561 return ret; 562 563 return 0; 564 } 565 566 static int net_shaper_validate_nesting(struct net_shaper_binding *binding, 567 const struct net_shaper *shaper, 568 struct netlink_ext_ack *extack) 569 { 570 const struct net_shaper_ops *ops = net_shaper_ops(binding); 571 unsigned long caps = 0; 572 573 ops->capabilities(binding, shaper->handle.scope, &caps); 574 if (!(caps & BIT(NET_SHAPER_A_CAPS_SUPPORT_NESTING))) { 575 NL_SET_ERR_MSG_FMT(extack, 576 "Nesting not supported for scope %d", 577 shaper->handle.scope); 578 return -EOPNOTSUPP; 579 } 580 return 0; 581 } 582 583 /* Fetch the existing leaf and update it with the user-provided 584 * attributes. 585 */ 586 static int net_shaper_parse_leaf(struct net_shaper_binding *binding, 587 const struct nlattr *attr, 588 const struct genl_info *info, 589 const struct net_shaper *node, 590 struct net_shaper *shaper) 591 { 592 struct nlattr *tb[NET_SHAPER_A_WEIGHT + 1]; 593 bool exists; 594 int ret; 595 596 ret = nla_parse_nested(tb, NET_SHAPER_A_WEIGHT, attr, 597 net_shaper_leaf_info_nl_policy, info->extack); 598 if (ret < 0) 599 return ret; 600 601 ret = net_shaper_parse_info(binding, tb, info, shaper, &exists); 602 if (ret < 0) 603 return ret; 604 605 if (shaper->handle.scope != NET_SHAPER_SCOPE_QUEUE) { 606 NL_SET_BAD_ATTR(info->extack, tb[NET_SHAPER_A_HANDLE]); 607 return -EINVAL; 608 } 609 610 if (node->handle.scope == NET_SHAPER_SCOPE_NODE) { 611 ret = net_shaper_validate_nesting(binding, shaper, 612 info->extack); 613 if (ret < 0) 614 return ret; 615 } 616 617 if (!exists) 618 net_shaper_default_parent(&shaper->handle, &shaper->parent); 619 return 0; 620 } 621 622 /* Alike net_parse_shaper_info(), but additionally allow the user specifying 623 * the shaper's parent handle. 624 */ 625 static int net_shaper_parse_node(struct net_shaper_binding *binding, 626 struct nlattr **tb, 627 const struct genl_info *info, 628 struct net_shaper *shaper) 629 { 630 bool exists; 631 int ret; 632 633 ret = net_shaper_parse_info(binding, tb, info, shaper, &exists); 634 if (ret) 635 return ret; 636 637 if (shaper->handle.scope != NET_SHAPER_SCOPE_NODE && 638 shaper->handle.scope != NET_SHAPER_SCOPE_NETDEV) { 639 NL_SET_BAD_ATTR(info->extack, tb[NET_SHAPER_A_HANDLE]); 640 return -EINVAL; 641 } 642 643 if (tb[NET_SHAPER_A_PARENT]) { 644 ret = net_shaper_parse_handle(tb[NET_SHAPER_A_PARENT], info, 645 &shaper->parent); 646 if (ret) 647 return ret; 648 649 if (shaper->parent.scope != NET_SHAPER_SCOPE_NODE && 650 shaper->parent.scope != NET_SHAPER_SCOPE_NETDEV) { 651 NL_SET_BAD_ATTR(info->extack, tb[NET_SHAPER_A_PARENT]); 652 return -EINVAL; 653 } 654 } 655 return 0; 656 } 657 658 static int net_shaper_generic_pre(struct genl_info *info, int type) 659 { 660 struct net_shaper_nl_ctx *ctx = (struct net_shaper_nl_ctx *)info->ctx; 661 662 BUILD_BUG_ON(sizeof(*ctx) > sizeof(info->ctx)); 663 664 return net_shaper_ctx_setup(info, type, ctx); 665 } 666 667 int net_shaper_nl_pre_doit(const struct genl_split_ops *ops, 668 struct sk_buff *skb, struct genl_info *info) 669 { 670 return net_shaper_generic_pre(info, NET_SHAPER_A_IFINDEX); 671 } 672 673 static void net_shaper_generic_post(struct genl_info *info) 674 { 675 net_shaper_ctx_cleanup((struct net_shaper_nl_ctx *)info->ctx); 676 } 677 678 void net_shaper_nl_post_doit(const struct genl_split_ops *ops, 679 struct sk_buff *skb, struct genl_info *info) 680 { 681 net_shaper_generic_post(info); 682 } 683 684 int net_shaper_nl_pre_dumpit(struct netlink_callback *cb) 685 { 686 struct net_shaper_nl_ctx *ctx = (struct net_shaper_nl_ctx *)cb->ctx; 687 const struct genl_info *info = genl_info_dump(cb); 688 689 return net_shaper_ctx_setup(info, NET_SHAPER_A_IFINDEX, ctx); 690 } 691 692 int net_shaper_nl_post_dumpit(struct netlink_callback *cb) 693 { 694 net_shaper_ctx_cleanup((struct net_shaper_nl_ctx *)cb->ctx); 695 return 0; 696 } 697 698 int net_shaper_nl_cap_pre_doit(const struct genl_split_ops *ops, 699 struct sk_buff *skb, struct genl_info *info) 700 { 701 return net_shaper_generic_pre(info, NET_SHAPER_A_CAPS_IFINDEX); 702 } 703 704 void net_shaper_nl_cap_post_doit(const struct genl_split_ops *ops, 705 struct sk_buff *skb, struct genl_info *info) 706 { 707 net_shaper_generic_post(info); 708 } 709 710 int net_shaper_nl_cap_pre_dumpit(struct netlink_callback *cb) 711 { 712 struct net_shaper_nl_ctx *ctx = (struct net_shaper_nl_ctx *)cb->ctx; 713 714 return net_shaper_ctx_setup(genl_info_dump(cb), 715 NET_SHAPER_A_CAPS_IFINDEX, ctx); 716 } 717 718 int net_shaper_nl_cap_post_dumpit(struct netlink_callback *cb) 719 { 720 struct net_shaper_nl_ctx *ctx = (struct net_shaper_nl_ctx *)cb->ctx; 721 722 net_shaper_ctx_cleanup(ctx); 723 return 0; 724 } 725 726 int net_shaper_nl_get_doit(struct sk_buff *skb, struct genl_info *info) 727 { 728 struct net_shaper_binding *binding; 729 struct net_shaper_handle handle; 730 struct net_shaper *shaper; 731 struct sk_buff *msg; 732 int ret; 733 734 if (GENL_REQ_ATTR_CHECK(info, NET_SHAPER_A_HANDLE)) 735 return -EINVAL; 736 737 binding = net_shaper_binding_from_ctx(info->ctx); 738 ret = net_shaper_parse_handle(info->attrs[NET_SHAPER_A_HANDLE], info, 739 &handle); 740 if (ret < 0) 741 return ret; 742 743 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 744 if (!msg) 745 return -ENOMEM; 746 747 rcu_read_lock(); 748 shaper = net_shaper_lookup(binding, &handle); 749 if (!shaper) { 750 NL_SET_BAD_ATTR(info->extack, 751 info->attrs[NET_SHAPER_A_HANDLE]); 752 rcu_read_unlock(); 753 ret = -ENOENT; 754 goto free_msg; 755 } 756 757 ret = net_shaper_fill_one(msg, binding, shaper, info); 758 rcu_read_unlock(); 759 if (ret) 760 goto free_msg; 761 762 ret = genlmsg_reply(msg, info); 763 if (ret) 764 goto free_msg; 765 766 return 0; 767 768 free_msg: 769 nlmsg_free(msg); 770 return ret; 771 } 772 773 int net_shaper_nl_get_dumpit(struct sk_buff *skb, 774 struct netlink_callback *cb) 775 { 776 struct net_shaper_nl_ctx *ctx = (struct net_shaper_nl_ctx *)cb->ctx; 777 const struct genl_info *info = genl_info_dump(cb); 778 struct net_shaper_hierarchy *hierarchy; 779 struct net_shaper_binding *binding; 780 struct net_shaper *shaper; 781 int ret = 0; 782 783 /* Don't error out dumps performed before any set operation. */ 784 binding = net_shaper_binding_from_ctx(ctx); 785 hierarchy = net_shaper_hierarchy(binding); 786 if (!hierarchy) 787 return 0; 788 789 rcu_read_lock(); 790 for (; (shaper = xa_find(&hierarchy->shapers, &ctx->start_index, 791 U32_MAX, XA_PRESENT)); ctx->start_index++) { 792 ret = net_shaper_fill_one(skb, binding, shaper, info); 793 if (ret) 794 break; 795 } 796 rcu_read_unlock(); 797 798 return ret; 799 } 800 801 int net_shaper_nl_set_doit(struct sk_buff *skb, struct genl_info *info) 802 { 803 struct net_shaper_hierarchy *hierarchy; 804 struct net_shaper_binding *binding; 805 const struct net_shaper_ops *ops; 806 struct net_shaper_handle handle; 807 struct net_shaper shaper = {}; 808 bool exists; 809 int ret; 810 811 binding = net_shaper_binding_from_ctx(info->ctx); 812 813 net_shaper_lock(binding); 814 ret = net_shaper_parse_info(binding, info->attrs, info, &shaper, 815 &exists); 816 if (ret) 817 goto unlock; 818 819 if (!exists) 820 net_shaper_default_parent(&shaper.handle, &shaper.parent); 821 822 hierarchy = net_shaper_hierarchy_setup(binding); 823 if (!hierarchy) { 824 ret = -ENOMEM; 825 goto unlock; 826 } 827 828 /* The 'set' operation can't create node-scope shapers. */ 829 handle = shaper.handle; 830 if (handle.scope == NET_SHAPER_SCOPE_NODE && 831 !net_shaper_lookup(binding, &handle)) { 832 ret = -ENOENT; 833 goto unlock; 834 } 835 836 ret = net_shaper_pre_insert(binding, &handle, info->extack); 837 if (ret) 838 goto unlock; 839 840 ops = net_shaper_ops(binding); 841 ret = ops->set(binding, &shaper, info->extack); 842 if (ret) { 843 net_shaper_rollback(binding); 844 goto unlock; 845 } 846 847 net_shaper_commit(binding, 1, &shaper); 848 849 unlock: 850 net_shaper_unlock(binding); 851 return ret; 852 } 853 854 static int __net_shaper_delete(struct net_shaper_binding *binding, 855 struct net_shaper *shaper, 856 struct netlink_ext_ack *extack) 857 { 858 struct net_shaper_hierarchy *hierarchy = net_shaper_hierarchy(binding); 859 struct net_shaper_handle parent_handle, handle = shaper->handle; 860 const struct net_shaper_ops *ops = net_shaper_ops(binding); 861 int ret; 862 863 again: 864 parent_handle = shaper->parent; 865 866 ret = ops->delete(binding, &handle, extack); 867 if (ret < 0) 868 return ret; 869 870 xa_erase(&hierarchy->shapers, net_shaper_handle_to_index(&handle)); 871 kfree_rcu(shaper, rcu); 872 873 /* Eventually delete the parent, if it is left over with no leaves. */ 874 if (parent_handle.scope == NET_SHAPER_SCOPE_NODE) { 875 shaper = net_shaper_lookup(binding, &parent_handle); 876 if (shaper && !--shaper->leaves) { 877 handle = parent_handle; 878 goto again; 879 } 880 } 881 return 0; 882 } 883 884 static int net_shaper_handle_cmp(const struct net_shaper_handle *a, 885 const struct net_shaper_handle *b) 886 { 887 /* Must avoid holes in struct net_shaper_handle. */ 888 BUILD_BUG_ON(sizeof(*a) != 8); 889 890 return memcmp(a, b, sizeof(*a)); 891 } 892 893 static int net_shaper_parent_from_leaves(int leaves_count, 894 const struct net_shaper *leaves, 895 struct net_shaper *node, 896 struct netlink_ext_ack *extack) 897 { 898 struct net_shaper_handle parent = leaves[0].parent; 899 int i; 900 901 for (i = 1; i < leaves_count; ++i) { 902 if (net_shaper_handle_cmp(&leaves[i].parent, &parent)) { 903 NL_SET_ERR_MSG_FMT(extack, "All the leaves shapers must have the same old parent"); 904 return -EINVAL; 905 } 906 } 907 908 node->parent = parent; 909 return 0; 910 } 911 912 static int __net_shaper_group(struct net_shaper_binding *binding, 913 bool update_node, int leaves_count, 914 struct net_shaper *leaves, 915 struct net_shaper *node, 916 struct netlink_ext_ack *extack) 917 { 918 const struct net_shaper_ops *ops = net_shaper_ops(binding); 919 struct net_shaper_handle leaf_handle; 920 struct net_shaper *parent = NULL; 921 bool new_node = false; 922 int i, ret; 923 924 if (node->handle.scope == NET_SHAPER_SCOPE_NODE) { 925 new_node = node->handle.id == NET_SHAPER_ID_UNSPEC; 926 927 if (!new_node && !net_shaper_lookup(binding, &node->handle)) { 928 /* The related attribute is not available when 929 * reaching here from the delete() op. 930 */ 931 NL_SET_ERR_MSG_FMT(extack, "Node shaper %d:%d does not exists", 932 node->handle.scope, node->handle.id); 933 return -ENOENT; 934 } 935 936 /* When unspecified, the node parent scope is inherited from 937 * the leaves. 938 */ 939 if (node->parent.scope == NET_SHAPER_SCOPE_UNSPEC) { 940 ret = net_shaper_parent_from_leaves(leaves_count, 941 leaves, node, 942 extack); 943 if (ret) 944 return ret; 945 } 946 947 } else { 948 net_shaper_default_parent(&node->handle, &node->parent); 949 } 950 951 if (node->parent.scope == NET_SHAPER_SCOPE_NODE) { 952 parent = net_shaper_lookup(binding, &node->parent); 953 if (!parent) { 954 NL_SET_ERR_MSG_FMT(extack, "Node parent shaper %d:%d does not exists", 955 node->parent.scope, node->parent.id); 956 return -ENOENT; 957 } 958 959 ret = net_shaper_validate_nesting(binding, node, extack); 960 if (ret < 0) 961 return ret; 962 } 963 964 if (update_node) { 965 /* For newly created node scope shaper, the following will 966 * update the handle, due to id allocation. 967 */ 968 ret = net_shaper_pre_insert(binding, &node->handle, extack); 969 if (ret) 970 return ret; 971 } 972 973 for (i = 0; i < leaves_count; ++i) { 974 leaf_handle = leaves[i].handle; 975 976 ret = net_shaper_pre_insert(binding, &leaf_handle, extack); 977 if (ret) 978 goto rollback; 979 980 if (!net_shaper_handle_cmp(&leaves[i].parent, &node->handle)) 981 continue; 982 983 /* The leaves shapers will be nested to the node, update the 984 * linking accordingly. 985 */ 986 leaves[i].parent = node->handle; 987 node->leaves++; 988 } 989 990 ret = ops->group(binding, leaves_count, leaves, node, extack); 991 if (ret < 0) 992 goto rollback; 993 994 /* The node's parent gains a new leaf only when the node itself 995 * is created by this group operation 996 */ 997 if (new_node && parent) 998 parent->leaves++; 999 if (update_node) 1000 net_shaper_commit(binding, 1, node); 1001 net_shaper_commit(binding, leaves_count, leaves); 1002 return 0; 1003 1004 rollback: 1005 net_shaper_rollback(binding); 1006 return ret; 1007 } 1008 1009 static int net_shaper_pre_del_node(struct net_shaper_binding *binding, 1010 const struct net_shaper *shaper, 1011 struct netlink_ext_ack *extack) 1012 { 1013 struct net_shaper_hierarchy *hierarchy = net_shaper_hierarchy(binding); 1014 struct net_shaper *cur, *leaves, node = {}; 1015 int ret, leaves_count = 0; 1016 unsigned long index; 1017 bool update_node; 1018 1019 if (!shaper->leaves) 1020 return 0; 1021 1022 /* Fetch the new node information. */ 1023 node.handle = shaper->parent; 1024 cur = net_shaper_lookup(binding, &node.handle); 1025 if (cur) { 1026 node = *cur; 1027 } else { 1028 /* A scope NODE shaper can be nested only to the NETDEV scope 1029 * shaper without creating the latter, this check may fail only 1030 * if the data is in inconsistent status. 1031 */ 1032 if (WARN_ON_ONCE(node.handle.scope != NET_SHAPER_SCOPE_NETDEV)) 1033 return -EINVAL; 1034 } 1035 1036 leaves = kcalloc(shaper->leaves, sizeof(struct net_shaper), 1037 GFP_KERNEL); 1038 if (!leaves) 1039 return -ENOMEM; 1040 1041 /* Build the leaves arrays. */ 1042 xa_for_each(&hierarchy->shapers, index, cur) { 1043 if (net_shaper_handle_cmp(&cur->parent, &shaper->handle)) 1044 continue; 1045 1046 if (WARN_ON_ONCE(leaves_count == shaper->leaves)) { 1047 ret = -EINVAL; 1048 goto free; 1049 } 1050 1051 leaves[leaves_count++] = *cur; 1052 } 1053 1054 /* When re-linking to the netdev shaper, avoid the eventual, implicit, 1055 * creation of the new node, would be surprising since the user is 1056 * doing a delete operation. 1057 */ 1058 update_node = node.handle.scope != NET_SHAPER_SCOPE_NETDEV; 1059 ret = __net_shaper_group(binding, update_node, leaves_count, 1060 leaves, &node, extack); 1061 1062 free: 1063 kfree(leaves); 1064 return ret; 1065 } 1066 1067 int net_shaper_nl_delete_doit(struct sk_buff *skb, struct genl_info *info) 1068 { 1069 struct net_shaper_hierarchy *hierarchy; 1070 struct net_shaper_binding *binding; 1071 struct net_shaper_handle handle; 1072 struct net_shaper *shaper; 1073 int ret; 1074 1075 if (GENL_REQ_ATTR_CHECK(info, NET_SHAPER_A_HANDLE)) 1076 return -EINVAL; 1077 1078 binding = net_shaper_binding_from_ctx(info->ctx); 1079 1080 net_shaper_lock(binding); 1081 ret = net_shaper_parse_handle(info->attrs[NET_SHAPER_A_HANDLE], info, 1082 &handle); 1083 if (ret) 1084 goto unlock; 1085 1086 hierarchy = net_shaper_hierarchy(binding); 1087 if (!hierarchy) { 1088 ret = -ENOENT; 1089 goto unlock; 1090 } 1091 1092 shaper = net_shaper_lookup(binding, &handle); 1093 if (!shaper) { 1094 ret = -ENOENT; 1095 goto unlock; 1096 } 1097 1098 if (handle.scope == NET_SHAPER_SCOPE_NODE) { 1099 ret = net_shaper_pre_del_node(binding, shaper, info->extack); 1100 if (ret) 1101 goto unlock; 1102 } 1103 1104 ret = __net_shaper_delete(binding, shaper, info->extack); 1105 1106 unlock: 1107 net_shaper_unlock(binding); 1108 return ret; 1109 } 1110 1111 static int net_shaper_group_send_reply(struct net_shaper_binding *binding, 1112 const struct net_shaper_handle *handle, 1113 struct genl_info *info, 1114 struct sk_buff *msg) 1115 { 1116 void *hdr; 1117 1118 hdr = genlmsg_iput(msg, info); 1119 if (!hdr) 1120 goto free_msg; 1121 1122 if (net_shaper_fill_binding(msg, binding, NET_SHAPER_A_IFINDEX) || 1123 net_shaper_fill_handle(msg, handle, NET_SHAPER_A_HANDLE)) 1124 goto free_msg; 1125 1126 genlmsg_end(msg, hdr); 1127 1128 return genlmsg_reply(msg, info); 1129 1130 free_msg: 1131 /* Should never happen as msg is pre-allocated with enough space. */ 1132 WARN_ONCE(true, "calculated message payload length (%d)", 1133 net_shaper_handle_size()); 1134 nlmsg_free(msg); 1135 return -EMSGSIZE; 1136 } 1137 1138 int net_shaper_nl_group_doit(struct sk_buff *skb, struct genl_info *info) 1139 { 1140 struct net_shaper **old_nodes, *leaves, node = {}; 1141 struct net_shaper_hierarchy *hierarchy; 1142 struct net_shaper_binding *binding; 1143 int i, ret, rem, leaves_count; 1144 int old_nodes_count = 0; 1145 struct sk_buff *msg; 1146 struct nlattr *attr; 1147 1148 if (GENL_REQ_ATTR_CHECK(info, NET_SHAPER_A_LEAVES)) 1149 return -EINVAL; 1150 1151 binding = net_shaper_binding_from_ctx(info->ctx); 1152 1153 /* The group operation is optional. */ 1154 if (!net_shaper_ops(binding)->group) 1155 return -EOPNOTSUPP; 1156 1157 net_shaper_lock(binding); 1158 leaves_count = net_shaper_list_len(info, NET_SHAPER_A_LEAVES); 1159 if (!leaves_count) { 1160 NL_SET_BAD_ATTR(info->extack, 1161 info->attrs[NET_SHAPER_A_LEAVES]); 1162 ret = -EINVAL; 1163 goto unlock; 1164 } 1165 1166 leaves = kcalloc(leaves_count, sizeof(struct net_shaper) + 1167 sizeof(struct net_shaper *), GFP_KERNEL); 1168 if (!leaves) { 1169 ret = -ENOMEM; 1170 goto unlock; 1171 } 1172 old_nodes = (void *)&leaves[leaves_count]; 1173 1174 ret = net_shaper_parse_node(binding, info->attrs, info, &node); 1175 if (ret) 1176 goto free_leaves; 1177 1178 i = 0; 1179 nla_for_each_attr_type(attr, NET_SHAPER_A_LEAVES, 1180 genlmsg_data(info->genlhdr), 1181 genlmsg_len(info->genlhdr), rem) { 1182 if (WARN_ON_ONCE(i >= leaves_count)) 1183 goto free_leaves; 1184 1185 ret = net_shaper_parse_leaf(binding, attr, info, 1186 &node, &leaves[i]); 1187 if (ret) 1188 goto free_leaves; 1189 i++; 1190 } 1191 1192 /* Prepare the msg reply in advance, to avoid device operation 1193 * rollback on allocation failure. 1194 */ 1195 msg = genlmsg_new(net_shaper_handle_size(), GFP_KERNEL); 1196 if (!msg) 1197 goto free_leaves; 1198 1199 hierarchy = net_shaper_hierarchy_setup(binding); 1200 if (!hierarchy) { 1201 ret = -ENOMEM; 1202 goto free_msg; 1203 } 1204 1205 /* Record the node shapers that this group() operation can make 1206 * childless for later cleanup. 1207 */ 1208 for (i = 0; i < leaves_count; i++) { 1209 if (leaves[i].parent.scope == NET_SHAPER_SCOPE_NODE && 1210 net_shaper_handle_cmp(&leaves[i].parent, &node.handle)) { 1211 struct net_shaper *tmp; 1212 1213 tmp = net_shaper_lookup(binding, &leaves[i].parent); 1214 if (!tmp) 1215 continue; 1216 1217 old_nodes[old_nodes_count++] = tmp; 1218 } 1219 } 1220 1221 ret = __net_shaper_group(binding, true, leaves_count, leaves, &node, 1222 info->extack); 1223 if (ret) 1224 goto free_msg; 1225 1226 /* Check if we need to delete any node left alone by the new leaves 1227 * linkage. 1228 */ 1229 for (i = 0; i < old_nodes_count; ++i) { 1230 struct net_shaper *tmp = old_nodes[i]; 1231 1232 if (--tmp->leaves > 0) 1233 continue; 1234 1235 /* Errors here are not fatal: the grouping operation is 1236 * completed, and user-space can still explicitly clean-up 1237 * left-over nodes. 1238 */ 1239 __net_shaper_delete(binding, tmp, info->extack); 1240 } 1241 1242 ret = net_shaper_group_send_reply(binding, &node.handle, info, msg); 1243 if (ret) 1244 GENL_SET_ERR_MSG_FMT(info, "Can't send reply"); 1245 1246 free_leaves: 1247 kfree(leaves); 1248 1249 unlock: 1250 net_shaper_unlock(binding); 1251 return ret; 1252 1253 free_msg: 1254 kfree_skb(msg); 1255 goto free_leaves; 1256 } 1257 1258 static int 1259 net_shaper_cap_fill_one(struct sk_buff *msg, 1260 struct net_shaper_binding *binding, 1261 enum net_shaper_scope scope, unsigned long flags, 1262 const struct genl_info *info) 1263 { 1264 unsigned long cur; 1265 void *hdr; 1266 1267 hdr = genlmsg_iput(msg, info); 1268 if (!hdr) 1269 return -EMSGSIZE; 1270 1271 if (net_shaper_fill_binding(msg, binding, NET_SHAPER_A_CAPS_IFINDEX) || 1272 nla_put_u32(msg, NET_SHAPER_A_CAPS_SCOPE, scope)) 1273 goto nla_put_failure; 1274 1275 for (cur = NET_SHAPER_A_CAPS_SUPPORT_METRIC_BPS; 1276 cur <= NET_SHAPER_A_CAPS_MAX; ++cur) { 1277 if (flags & BIT(cur) && nla_put_flag(msg, cur)) 1278 goto nla_put_failure; 1279 } 1280 1281 genlmsg_end(msg, hdr); 1282 1283 return 0; 1284 1285 nla_put_failure: 1286 genlmsg_cancel(msg, hdr); 1287 return -EMSGSIZE; 1288 } 1289 1290 int net_shaper_nl_cap_get_doit(struct sk_buff *skb, struct genl_info *info) 1291 { 1292 struct net_shaper_binding *binding; 1293 const struct net_shaper_ops *ops; 1294 enum net_shaper_scope scope; 1295 unsigned long flags = 0; 1296 struct sk_buff *msg; 1297 int ret; 1298 1299 if (GENL_REQ_ATTR_CHECK(info, NET_SHAPER_A_CAPS_SCOPE)) 1300 return -EINVAL; 1301 1302 binding = net_shaper_binding_from_ctx(info->ctx); 1303 scope = nla_get_u32(info->attrs[NET_SHAPER_A_CAPS_SCOPE]); 1304 ops = net_shaper_ops(binding); 1305 ops->capabilities(binding, scope, &flags); 1306 if (!flags) 1307 return -EOPNOTSUPP; 1308 1309 msg = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1310 if (!msg) 1311 return -ENOMEM; 1312 1313 ret = net_shaper_cap_fill_one(msg, binding, scope, flags, info); 1314 if (ret) 1315 goto free_msg; 1316 1317 ret = genlmsg_reply(msg, info); 1318 if (ret) 1319 goto free_msg; 1320 return 0; 1321 1322 free_msg: 1323 nlmsg_free(msg); 1324 return ret; 1325 } 1326 1327 int net_shaper_nl_cap_get_dumpit(struct sk_buff *skb, 1328 struct netlink_callback *cb) 1329 { 1330 const struct genl_info *info = genl_info_dump(cb); 1331 struct net_shaper_binding *binding; 1332 const struct net_shaper_ops *ops; 1333 enum net_shaper_scope scope; 1334 int ret; 1335 1336 binding = net_shaper_binding_from_ctx(cb->ctx); 1337 ops = net_shaper_ops(binding); 1338 for (scope = 0; scope <= NET_SHAPER_SCOPE_MAX; ++scope) { 1339 unsigned long flags = 0; 1340 1341 ops->capabilities(binding, scope, &flags); 1342 if (!flags) 1343 continue; 1344 1345 ret = net_shaper_cap_fill_one(skb, binding, scope, flags, 1346 info); 1347 if (ret) 1348 return ret; 1349 } 1350 1351 return 0; 1352 } 1353 1354 static void net_shaper_flush(struct net_shaper_binding *binding) 1355 { 1356 struct net_shaper_hierarchy *hierarchy = net_shaper_hierarchy(binding); 1357 struct net_shaper *cur; 1358 unsigned long index; 1359 1360 if (!hierarchy) 1361 return; 1362 1363 net_shaper_lock(binding); 1364 xa_lock(&hierarchy->shapers); 1365 xa_for_each(&hierarchy->shapers, index, cur) { 1366 __xa_erase(&hierarchy->shapers, index); 1367 kfree(cur); 1368 } 1369 xa_unlock(&hierarchy->shapers); 1370 net_shaper_unlock(binding); 1371 1372 kfree(hierarchy); 1373 } 1374 1375 void net_shaper_flush_netdev(struct net_device *dev) 1376 { 1377 struct net_shaper_binding binding = { 1378 .type = NET_SHAPER_BINDING_TYPE_NETDEV, 1379 .netdev = dev, 1380 }; 1381 1382 net_shaper_flush(&binding); 1383 } 1384 1385 void net_shaper_set_real_num_tx_queues(struct net_device *dev, 1386 unsigned int txq) 1387 { 1388 struct net_shaper_hierarchy *hierarchy; 1389 struct net_shaper_binding binding; 1390 int i; 1391 1392 binding.type = NET_SHAPER_BINDING_TYPE_NETDEV; 1393 binding.netdev = dev; 1394 hierarchy = net_shaper_hierarchy(&binding); 1395 if (!hierarchy) 1396 return; 1397 1398 /* Only drivers implementing shapers support ensure 1399 * the lock is acquired in advance. 1400 */ 1401 lockdep_assert_held(&dev->lock); 1402 1403 /* Take action only when decreasing the tx queue number. */ 1404 for (i = txq; i < dev->real_num_tx_queues; ++i) { 1405 struct net_shaper_handle handle, parent_handle; 1406 struct net_shaper *shaper; 1407 u32 index; 1408 1409 handle.scope = NET_SHAPER_SCOPE_QUEUE; 1410 handle.id = i; 1411 shaper = net_shaper_lookup(&binding, &handle); 1412 if (!shaper) 1413 continue; 1414 1415 /* Don't touch the H/W for the queue shaper, the drivers already 1416 * deleted the queue and related resources. 1417 */ 1418 parent_handle = shaper->parent; 1419 index = net_shaper_handle_to_index(&handle); 1420 xa_erase(&hierarchy->shapers, index); 1421 kfree_rcu(shaper, rcu); 1422 1423 /* The recursion on parent does the full job. */ 1424 if (parent_handle.scope != NET_SHAPER_SCOPE_NODE) 1425 continue; 1426 1427 shaper = net_shaper_lookup(&binding, &parent_handle); 1428 if (shaper && !--shaper->leaves) 1429 __net_shaper_delete(&binding, shaper, NULL); 1430 } 1431 } 1432 1433 static int __init shaper_init(void) 1434 { 1435 return genl_register_family(&net_shaper_nl_family); 1436 } 1437 1438 subsys_initcall(shaper_init); 1439