1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef __NET_PKT_CLS_H 3 #define __NET_PKT_CLS_H 4 5 #include <linux/pkt_cls.h> 6 #include <linux/workqueue.h> 7 #include <net/sch_generic.h> 8 #include <net/act_api.h> 9 10 /* Basic packet classifier frontend definitions. */ 11 12 struct tcf_walker { 13 int stop; 14 int skip; 15 int count; 16 int (*fn)(struct tcf_proto *, void *node, struct tcf_walker *); 17 }; 18 19 int register_tcf_proto_ops(struct tcf_proto_ops *ops); 20 int unregister_tcf_proto_ops(struct tcf_proto_ops *ops); 21 22 enum tcf_block_binder_type { 23 TCF_BLOCK_BINDER_TYPE_UNSPEC, 24 TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS, 25 TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS, 26 }; 27 28 struct tcf_block_ext_info { 29 enum tcf_block_binder_type binder_type; 30 tcf_chain_head_change_t *chain_head_change; 31 void *chain_head_change_priv; 32 u32 block_index; 33 }; 34 35 struct tcf_block_cb; 36 bool tcf_queue_work(struct rcu_work *rwork, work_func_t func); 37 38 #ifdef CONFIG_NET_CLS 39 struct tcf_chain *tcf_chain_get(struct tcf_block *block, u32 chain_index, 40 bool create); 41 void tcf_chain_put(struct tcf_chain *chain); 42 void tcf_block_netif_keep_dst(struct tcf_block *block); 43 int tcf_block_get(struct tcf_block **p_block, 44 struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q, 45 struct netlink_ext_ack *extack); 46 int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q, 47 struct tcf_block_ext_info *ei, 48 struct netlink_ext_ack *extack); 49 void tcf_block_put(struct tcf_block *block); 50 void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q, 51 struct tcf_block_ext_info *ei); 52 53 static inline bool tcf_block_shared(struct tcf_block *block) 54 { 55 return block->index; 56 } 57 58 static inline struct Qdisc *tcf_block_q(struct tcf_block *block) 59 { 60 WARN_ON(tcf_block_shared(block)); 61 return block->q; 62 } 63 64 static inline struct net_device *tcf_block_dev(struct tcf_block *block) 65 { 66 return tcf_block_q(block)->dev_queue->dev; 67 } 68 69 void *tcf_block_cb_priv(struct tcf_block_cb *block_cb); 70 struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block, 71 tc_setup_cb_t *cb, void *cb_ident); 72 void tcf_block_cb_incref(struct tcf_block_cb *block_cb); 73 unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb); 74 struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block, 75 tc_setup_cb_t *cb, void *cb_ident, 76 void *cb_priv, 77 struct netlink_ext_ack *extack); 78 int tcf_block_cb_register(struct tcf_block *block, 79 tc_setup_cb_t *cb, void *cb_ident, 80 void *cb_priv, struct netlink_ext_ack *extack); 81 void __tcf_block_cb_unregister(struct tcf_block *block, 82 struct tcf_block_cb *block_cb); 83 void tcf_block_cb_unregister(struct tcf_block *block, 84 tc_setup_cb_t *cb, void *cb_ident); 85 86 int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp, 87 struct tcf_result *res, bool compat_mode); 88 89 #else 90 static inline 91 int tcf_block_get(struct tcf_block **p_block, 92 struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q, 93 struct netlink_ext_ack *extack) 94 { 95 return 0; 96 } 97 98 static inline 99 int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q, 100 struct tcf_block_ext_info *ei, 101 struct netlink_ext_ack *extack) 102 { 103 return 0; 104 } 105 106 static inline void tcf_block_put(struct tcf_block *block) 107 { 108 } 109 110 static inline 111 void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q, 112 struct tcf_block_ext_info *ei) 113 { 114 } 115 116 static inline bool tcf_block_shared(struct tcf_block *block) 117 { 118 return false; 119 } 120 121 static inline struct Qdisc *tcf_block_q(struct tcf_block *block) 122 { 123 return NULL; 124 } 125 126 static inline struct net_device *tcf_block_dev(struct tcf_block *block) 127 { 128 return NULL; 129 } 130 131 static inline 132 int tc_setup_cb_block_register(struct tcf_block *block, tc_setup_cb_t *cb, 133 void *cb_priv) 134 { 135 return 0; 136 } 137 138 static inline 139 void tc_setup_cb_block_unregister(struct tcf_block *block, tc_setup_cb_t *cb, 140 void *cb_priv) 141 { 142 } 143 144 static inline 145 void *tcf_block_cb_priv(struct tcf_block_cb *block_cb) 146 { 147 return NULL; 148 } 149 150 static inline 151 struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block, 152 tc_setup_cb_t *cb, void *cb_ident) 153 { 154 return NULL; 155 } 156 157 static inline 158 void tcf_block_cb_incref(struct tcf_block_cb *block_cb) 159 { 160 } 161 162 static inline 163 unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb) 164 { 165 return 0; 166 } 167 168 static inline 169 struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block, 170 tc_setup_cb_t *cb, void *cb_ident, 171 void *cb_priv, 172 struct netlink_ext_ack *extack) 173 { 174 return NULL; 175 } 176 177 static inline 178 int tcf_block_cb_register(struct tcf_block *block, 179 tc_setup_cb_t *cb, void *cb_ident, 180 void *cb_priv, struct netlink_ext_ack *extack) 181 { 182 return 0; 183 } 184 185 static inline 186 void __tcf_block_cb_unregister(struct tcf_block *block, 187 struct tcf_block_cb *block_cb) 188 { 189 } 190 191 static inline 192 void tcf_block_cb_unregister(struct tcf_block *block, 193 tc_setup_cb_t *cb, void *cb_ident) 194 { 195 } 196 197 static inline int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp, 198 struct tcf_result *res, bool compat_mode) 199 { 200 return TC_ACT_UNSPEC; 201 } 202 #endif 203 204 static inline unsigned long 205 __cls_set_class(unsigned long *clp, unsigned long cl) 206 { 207 return xchg(clp, cl); 208 } 209 210 static inline unsigned long 211 cls_set_class(struct Qdisc *q, unsigned long *clp, unsigned long cl) 212 { 213 unsigned long old_cl; 214 215 sch_tree_lock(q); 216 old_cl = __cls_set_class(clp, cl); 217 sch_tree_unlock(q); 218 return old_cl; 219 } 220 221 static inline void 222 tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base) 223 { 224 struct Qdisc *q = tp->chain->block->q; 225 unsigned long cl; 226 227 /* Check q as it is not set for shared blocks. In that case, 228 * setting class is not supported. 229 */ 230 if (!q) 231 return; 232 cl = q->ops->cl_ops->bind_tcf(q, base, r->classid); 233 cl = cls_set_class(q, &r->class, cl); 234 if (cl) 235 q->ops->cl_ops->unbind_tcf(q, cl); 236 } 237 238 static inline void 239 tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r) 240 { 241 struct Qdisc *q = tp->chain->block->q; 242 unsigned long cl; 243 244 if (!q) 245 return; 246 if ((cl = __cls_set_class(&r->class, 0)) != 0) 247 q->ops->cl_ops->unbind_tcf(q, cl); 248 } 249 250 struct tcf_exts { 251 #ifdef CONFIG_NET_CLS_ACT 252 __u32 type; /* for backward compat(TCA_OLD_COMPAT) */ 253 int nr_actions; 254 struct tc_action **actions; 255 struct net *net; 256 #endif 257 /* Map to export classifier specific extension TLV types to the 258 * generic extensions API. Unsupported extensions must be set to 0. 259 */ 260 int action; 261 int police; 262 }; 263 264 static inline int tcf_exts_init(struct tcf_exts *exts, int action, int police) 265 { 266 #ifdef CONFIG_NET_CLS_ACT 267 exts->type = 0; 268 exts->nr_actions = 0; 269 exts->net = NULL; 270 exts->actions = kcalloc(TCA_ACT_MAX_PRIO, sizeof(struct tc_action *), 271 GFP_KERNEL); 272 if (!exts->actions) 273 return -ENOMEM; 274 #endif 275 exts->action = action; 276 exts->police = police; 277 return 0; 278 } 279 280 /* Return false if the netns is being destroyed in cleanup_net(). Callers 281 * need to do cleanup synchronously in this case, otherwise may race with 282 * tc_action_net_exit(). Return true for other cases. 283 */ 284 static inline bool tcf_exts_get_net(struct tcf_exts *exts) 285 { 286 #ifdef CONFIG_NET_CLS_ACT 287 exts->net = maybe_get_net(exts->net); 288 return exts->net != NULL; 289 #else 290 return true; 291 #endif 292 } 293 294 static inline void tcf_exts_put_net(struct tcf_exts *exts) 295 { 296 #ifdef CONFIG_NET_CLS_ACT 297 if (exts->net) 298 put_net(exts->net); 299 #endif 300 } 301 302 static inline void tcf_exts_to_list(const struct tcf_exts *exts, 303 struct list_head *actions) 304 { 305 #ifdef CONFIG_NET_CLS_ACT 306 int i; 307 308 for (i = 0; i < exts->nr_actions; i++) { 309 struct tc_action *a = exts->actions[i]; 310 311 list_add_tail(&a->list, actions); 312 } 313 #endif 314 } 315 316 static inline void 317 tcf_exts_stats_update(const struct tcf_exts *exts, 318 u64 bytes, u64 packets, u64 lastuse) 319 { 320 #ifdef CONFIG_NET_CLS_ACT 321 int i; 322 323 preempt_disable(); 324 325 for (i = 0; i < exts->nr_actions; i++) { 326 struct tc_action *a = exts->actions[i]; 327 328 tcf_action_stats_update(a, bytes, packets, lastuse); 329 } 330 331 preempt_enable(); 332 #endif 333 } 334 335 /** 336 * tcf_exts_has_actions - check if at least one action is present 337 * @exts: tc filter extensions handle 338 * 339 * Returns true if at least one action is present. 340 */ 341 static inline bool tcf_exts_has_actions(struct tcf_exts *exts) 342 { 343 #ifdef CONFIG_NET_CLS_ACT 344 return exts->nr_actions; 345 #else 346 return false; 347 #endif 348 } 349 350 /** 351 * tcf_exts_has_one_action - check if exactly one action is present 352 * @exts: tc filter extensions handle 353 * 354 * Returns true if exactly one action is present. 355 */ 356 static inline bool tcf_exts_has_one_action(struct tcf_exts *exts) 357 { 358 #ifdef CONFIG_NET_CLS_ACT 359 return exts->nr_actions == 1; 360 #else 361 return false; 362 #endif 363 } 364 365 /** 366 * tcf_exts_exec - execute tc filter extensions 367 * @skb: socket buffer 368 * @exts: tc filter extensions handle 369 * @res: desired result 370 * 371 * Executes all configured extensions. Returns TC_ACT_OK on a normal execution, 372 * a negative number if the filter must be considered unmatched or 373 * a positive action code (TC_ACT_*) which must be returned to the 374 * underlying layer. 375 */ 376 static inline int 377 tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts, 378 struct tcf_result *res) 379 { 380 #ifdef CONFIG_NET_CLS_ACT 381 return tcf_action_exec(skb, exts->actions, exts->nr_actions, res); 382 #endif 383 return TC_ACT_OK; 384 } 385 386 int tcf_exts_validate(struct net *net, struct tcf_proto *tp, 387 struct nlattr **tb, struct nlattr *rate_tlv, 388 struct tcf_exts *exts, bool ovr, 389 struct netlink_ext_ack *extack); 390 void tcf_exts_destroy(struct tcf_exts *exts); 391 void tcf_exts_change(struct tcf_exts *dst, struct tcf_exts *src); 392 int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts); 393 int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts); 394 395 /** 396 * struct tcf_pkt_info - packet information 397 */ 398 struct tcf_pkt_info { 399 unsigned char * ptr; 400 int nexthdr; 401 }; 402 403 #ifdef CONFIG_NET_EMATCH 404 405 struct tcf_ematch_ops; 406 407 /** 408 * struct tcf_ematch - extended match (ematch) 409 * 410 * @matchid: identifier to allow userspace to reidentify a match 411 * @flags: flags specifying attributes and the relation to other matches 412 * @ops: the operations lookup table of the corresponding ematch module 413 * @datalen: length of the ematch specific configuration data 414 * @data: ematch specific data 415 */ 416 struct tcf_ematch { 417 struct tcf_ematch_ops * ops; 418 unsigned long data; 419 unsigned int datalen; 420 u16 matchid; 421 u16 flags; 422 struct net *net; 423 }; 424 425 static inline int tcf_em_is_container(struct tcf_ematch *em) 426 { 427 return !em->ops; 428 } 429 430 static inline int tcf_em_is_simple(struct tcf_ematch *em) 431 { 432 return em->flags & TCF_EM_SIMPLE; 433 } 434 435 static inline int tcf_em_is_inverted(struct tcf_ematch *em) 436 { 437 return em->flags & TCF_EM_INVERT; 438 } 439 440 static inline int tcf_em_last_match(struct tcf_ematch *em) 441 { 442 return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END; 443 } 444 445 static inline int tcf_em_early_end(struct tcf_ematch *em, int result) 446 { 447 if (tcf_em_last_match(em)) 448 return 1; 449 450 if (result == 0 && em->flags & TCF_EM_REL_AND) 451 return 1; 452 453 if (result != 0 && em->flags & TCF_EM_REL_OR) 454 return 1; 455 456 return 0; 457 } 458 459 /** 460 * struct tcf_ematch_tree - ematch tree handle 461 * 462 * @hdr: ematch tree header supplied by userspace 463 * @matches: array of ematches 464 */ 465 struct tcf_ematch_tree { 466 struct tcf_ematch_tree_hdr hdr; 467 struct tcf_ematch * matches; 468 469 }; 470 471 /** 472 * struct tcf_ematch_ops - ematch module operations 473 * 474 * @kind: identifier (kind) of this ematch module 475 * @datalen: length of expected configuration data (optional) 476 * @change: called during validation (optional) 477 * @match: called during ematch tree evaluation, must return 1/0 478 * @destroy: called during destroyage (optional) 479 * @dump: called during dumping process (optional) 480 * @owner: owner, must be set to THIS_MODULE 481 * @link: link to previous/next ematch module (internal use) 482 */ 483 struct tcf_ematch_ops { 484 int kind; 485 int datalen; 486 int (*change)(struct net *net, void *, 487 int, struct tcf_ematch *); 488 int (*match)(struct sk_buff *, struct tcf_ematch *, 489 struct tcf_pkt_info *); 490 void (*destroy)(struct tcf_ematch *); 491 int (*dump)(struct sk_buff *, struct tcf_ematch *); 492 struct module *owner; 493 struct list_head link; 494 }; 495 496 int tcf_em_register(struct tcf_ematch_ops *); 497 void tcf_em_unregister(struct tcf_ematch_ops *); 498 int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *, 499 struct tcf_ematch_tree *); 500 void tcf_em_tree_destroy(struct tcf_ematch_tree *); 501 int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int); 502 int __tcf_em_tree_match(struct sk_buff *, struct tcf_ematch_tree *, 503 struct tcf_pkt_info *); 504 505 /** 506 * tcf_em_tree_match - evaulate an ematch tree 507 * 508 * @skb: socket buffer of the packet in question 509 * @tree: ematch tree to be used for evaluation 510 * @info: packet information examined by classifier 511 * 512 * This function matches @skb against the ematch tree in @tree by going 513 * through all ematches respecting their logic relations returning 514 * as soon as the result is obvious. 515 * 516 * Returns 1 if the ematch tree as-one matches, no ematches are configured 517 * or ematch is not enabled in the kernel, otherwise 0 is returned. 518 */ 519 static inline int tcf_em_tree_match(struct sk_buff *skb, 520 struct tcf_ematch_tree *tree, 521 struct tcf_pkt_info *info) 522 { 523 if (tree->hdr.nmatches) 524 return __tcf_em_tree_match(skb, tree, info); 525 else 526 return 1; 527 } 528 529 #define MODULE_ALIAS_TCF_EMATCH(kind) MODULE_ALIAS("ematch-kind-" __stringify(kind)) 530 531 #else /* CONFIG_NET_EMATCH */ 532 533 struct tcf_ematch_tree { 534 }; 535 536 #define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0) 537 #define tcf_em_tree_destroy(t) do { (void)(t); } while(0) 538 #define tcf_em_tree_dump(skb, t, tlv) (0) 539 #define tcf_em_tree_match(skb, t, info) ((void)(info), 1) 540 541 #endif /* CONFIG_NET_EMATCH */ 542 543 static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer) 544 { 545 switch (layer) { 546 case TCF_LAYER_LINK: 547 return skb_mac_header(skb); 548 case TCF_LAYER_NETWORK: 549 return skb_network_header(skb); 550 case TCF_LAYER_TRANSPORT: 551 return skb_transport_header(skb); 552 } 553 554 return NULL; 555 } 556 557 static inline int tcf_valid_offset(const struct sk_buff *skb, 558 const unsigned char *ptr, const int len) 559 { 560 return likely((ptr + len) <= skb_tail_pointer(skb) && 561 ptr >= skb->head && 562 (ptr <= (ptr + len))); 563 } 564 565 #ifdef CONFIG_NET_CLS_IND 566 #include <net/net_namespace.h> 567 568 static inline int 569 tcf_change_indev(struct net *net, struct nlattr *indev_tlv, 570 struct netlink_ext_ack *extack) 571 { 572 char indev[IFNAMSIZ]; 573 struct net_device *dev; 574 575 if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ) { 576 NL_SET_ERR_MSG(extack, "Interface name too long"); 577 return -EINVAL; 578 } 579 dev = __dev_get_by_name(net, indev); 580 if (!dev) 581 return -ENODEV; 582 return dev->ifindex; 583 } 584 585 static inline bool 586 tcf_match_indev(struct sk_buff *skb, int ifindex) 587 { 588 if (!ifindex) 589 return true; 590 if (!skb->skb_iif) 591 return false; 592 return ifindex == skb->skb_iif; 593 } 594 #endif /* CONFIG_NET_CLS_IND */ 595 596 int tc_setup_cb_call(struct tcf_block *block, struct tcf_exts *exts, 597 enum tc_setup_type type, void *type_data, bool err_stop); 598 599 enum tc_block_command { 600 TC_BLOCK_BIND, 601 TC_BLOCK_UNBIND, 602 }; 603 604 struct tc_block_offload { 605 enum tc_block_command command; 606 enum tcf_block_binder_type binder_type; 607 struct tcf_block *block; 608 struct netlink_ext_ack *extack; 609 }; 610 611 struct tc_cls_common_offload { 612 u32 chain_index; 613 __be16 protocol; 614 u32 prio; 615 struct netlink_ext_ack *extack; 616 }; 617 618 struct tc_cls_u32_knode { 619 struct tcf_exts *exts; 620 struct tc_u32_sel *sel; 621 u32 handle; 622 u32 val; 623 u32 mask; 624 u32 link_handle; 625 u8 fshift; 626 }; 627 628 struct tc_cls_u32_hnode { 629 u32 handle; 630 u32 prio; 631 unsigned int divisor; 632 }; 633 634 enum tc_clsu32_command { 635 TC_CLSU32_NEW_KNODE, 636 TC_CLSU32_REPLACE_KNODE, 637 TC_CLSU32_DELETE_KNODE, 638 TC_CLSU32_NEW_HNODE, 639 TC_CLSU32_REPLACE_HNODE, 640 TC_CLSU32_DELETE_HNODE, 641 }; 642 643 struct tc_cls_u32_offload { 644 struct tc_cls_common_offload common; 645 /* knode values */ 646 enum tc_clsu32_command command; 647 union { 648 struct tc_cls_u32_knode knode; 649 struct tc_cls_u32_hnode hnode; 650 }; 651 }; 652 653 static inline bool tc_can_offload(const struct net_device *dev) 654 { 655 return dev->features & NETIF_F_HW_TC; 656 } 657 658 static inline bool tc_can_offload_extack(const struct net_device *dev, 659 struct netlink_ext_ack *extack) 660 { 661 bool can = tc_can_offload(dev); 662 663 if (!can) 664 NL_SET_ERR_MSG(extack, "TC offload is disabled on net device"); 665 666 return can; 667 } 668 669 static inline bool 670 tc_cls_can_offload_and_chain0(const struct net_device *dev, 671 struct tc_cls_common_offload *common) 672 { 673 if (!tc_can_offload_extack(dev, common->extack)) 674 return false; 675 if (common->chain_index) { 676 NL_SET_ERR_MSG(common->extack, 677 "Driver supports only offload of chain 0"); 678 return false; 679 } 680 return true; 681 } 682 683 static inline bool tc_skip_hw(u32 flags) 684 { 685 return (flags & TCA_CLS_FLAGS_SKIP_HW) ? true : false; 686 } 687 688 static inline bool tc_skip_sw(u32 flags) 689 { 690 return (flags & TCA_CLS_FLAGS_SKIP_SW) ? true : false; 691 } 692 693 /* SKIP_HW and SKIP_SW are mutually exclusive flags. */ 694 static inline bool tc_flags_valid(u32 flags) 695 { 696 if (flags & ~(TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW | 697 TCA_CLS_FLAGS_VERBOSE)) 698 return false; 699 700 flags &= TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW; 701 if (!(flags ^ (TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW))) 702 return false; 703 704 return true; 705 } 706 707 static inline bool tc_in_hw(u32 flags) 708 { 709 return (flags & TCA_CLS_FLAGS_IN_HW) ? true : false; 710 } 711 712 static inline void 713 tc_cls_common_offload_init(struct tc_cls_common_offload *cls_common, 714 const struct tcf_proto *tp, u32 flags, 715 struct netlink_ext_ack *extack) 716 { 717 cls_common->chain_index = tp->chain->index; 718 cls_common->protocol = tp->protocol; 719 cls_common->prio = tp->prio; 720 if (tc_skip_sw(flags) || flags & TCA_CLS_FLAGS_VERBOSE) 721 cls_common->extack = extack; 722 } 723 724 enum tc_fl_command { 725 TC_CLSFLOWER_REPLACE, 726 TC_CLSFLOWER_DESTROY, 727 TC_CLSFLOWER_STATS, 728 }; 729 730 struct tc_cls_flower_offload { 731 struct tc_cls_common_offload common; 732 enum tc_fl_command command; 733 unsigned long cookie; 734 struct flow_dissector *dissector; 735 struct fl_flow_key *mask; 736 struct fl_flow_key *key; 737 struct tcf_exts *exts; 738 u32 classid; 739 }; 740 741 enum tc_matchall_command { 742 TC_CLSMATCHALL_REPLACE, 743 TC_CLSMATCHALL_DESTROY, 744 }; 745 746 struct tc_cls_matchall_offload { 747 struct tc_cls_common_offload common; 748 enum tc_matchall_command command; 749 struct tcf_exts *exts; 750 unsigned long cookie; 751 }; 752 753 enum tc_clsbpf_command { 754 TC_CLSBPF_OFFLOAD, 755 TC_CLSBPF_STATS, 756 }; 757 758 struct tc_cls_bpf_offload { 759 struct tc_cls_common_offload common; 760 enum tc_clsbpf_command command; 761 struct tcf_exts *exts; 762 struct bpf_prog *prog; 763 struct bpf_prog *oldprog; 764 const char *name; 765 bool exts_integrated; 766 }; 767 768 struct tc_mqprio_qopt_offload { 769 /* struct tc_mqprio_qopt must always be the first element */ 770 struct tc_mqprio_qopt qopt; 771 u16 mode; 772 u16 shaper; 773 u32 flags; 774 u64 min_rate[TC_QOPT_MAX_QUEUE]; 775 u64 max_rate[TC_QOPT_MAX_QUEUE]; 776 }; 777 778 /* This structure holds cookie structure that is passed from user 779 * to the kernel for actions and classifiers 780 */ 781 struct tc_cookie { 782 u8 *data; 783 u32 len; 784 }; 785 786 struct tc_qopt_offload_stats { 787 struct gnet_stats_basic_packed *bstats; 788 struct gnet_stats_queue *qstats; 789 }; 790 791 enum tc_mq_command { 792 TC_MQ_CREATE, 793 TC_MQ_DESTROY, 794 TC_MQ_STATS, 795 }; 796 797 struct tc_mq_qopt_offload { 798 enum tc_mq_command command; 799 u32 handle; 800 struct tc_qopt_offload_stats stats; 801 }; 802 803 enum tc_red_command { 804 TC_RED_REPLACE, 805 TC_RED_DESTROY, 806 TC_RED_STATS, 807 TC_RED_XSTATS, 808 }; 809 810 struct tc_red_qopt_offload_params { 811 u32 min; 812 u32 max; 813 u32 probability; 814 bool is_ecn; 815 struct gnet_stats_queue *qstats; 816 }; 817 818 struct tc_red_qopt_offload { 819 enum tc_red_command command; 820 u32 handle; 821 u32 parent; 822 union { 823 struct tc_red_qopt_offload_params set; 824 struct tc_qopt_offload_stats stats; 825 struct red_stats *xstats; 826 }; 827 }; 828 829 enum tc_prio_command { 830 TC_PRIO_REPLACE, 831 TC_PRIO_DESTROY, 832 TC_PRIO_STATS, 833 TC_PRIO_GRAFT, 834 }; 835 836 struct tc_prio_qopt_offload_params { 837 int bands; 838 u8 priomap[TC_PRIO_MAX + 1]; 839 /* In case that a prio qdisc is offloaded and now is changed to a 840 * non-offloadedable config, it needs to update the backlog & qlen 841 * values to negate the HW backlog & qlen values (and only them). 842 */ 843 struct gnet_stats_queue *qstats; 844 }; 845 846 struct tc_prio_qopt_offload_graft_params { 847 u8 band; 848 u32 child_handle; 849 }; 850 851 struct tc_prio_qopt_offload { 852 enum tc_prio_command command; 853 u32 handle; 854 u32 parent; 855 union { 856 struct tc_prio_qopt_offload_params replace_params; 857 struct tc_qopt_offload_stats stats; 858 struct tc_prio_qopt_offload_graft_params graft_params; 859 }; 860 }; 861 862 #endif 863