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 #include <net/net_namespace.h> 10 11 /* TC action not accessible from user space */ 12 #define TC_ACT_CONSUMED (TC_ACT_VALUE_MAX + 1) 13 14 /* Basic packet classifier frontend definitions. */ 15 16 struct tcf_walker { 17 int stop; 18 int skip; 19 int count; 20 bool nonempty; 21 unsigned long cookie; 22 int (*fn)(struct tcf_proto *, void *node, struct tcf_walker *); 23 }; 24 25 int register_tcf_proto_ops(struct tcf_proto_ops *ops); 26 int unregister_tcf_proto_ops(struct tcf_proto_ops *ops); 27 28 struct tcf_block_ext_info { 29 enum flow_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_qevent { 36 struct tcf_block *block; 37 struct tcf_block_ext_info info; 38 struct tcf_proto __rcu *filter_chain; 39 }; 40 41 struct tcf_block_cb; 42 bool tcf_queue_work(struct rcu_work *rwork, work_func_t func); 43 44 #ifdef CONFIG_NET_CLS 45 struct tcf_chain *tcf_chain_get_by_act(struct tcf_block *block, 46 u32 chain_index); 47 void tcf_chain_put_by_act(struct tcf_chain *chain); 48 struct tcf_chain *tcf_get_next_chain(struct tcf_block *block, 49 struct tcf_chain *chain); 50 struct tcf_proto *tcf_get_next_proto(struct tcf_chain *chain, 51 struct tcf_proto *tp); 52 void tcf_block_netif_keep_dst(struct tcf_block *block); 53 int tcf_block_get(struct tcf_block **p_block, 54 struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q, 55 struct netlink_ext_ack *extack); 56 int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q, 57 struct tcf_block_ext_info *ei, 58 struct netlink_ext_ack *extack); 59 void tcf_block_put(struct tcf_block *block); 60 void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q, 61 struct tcf_block_ext_info *ei); 62 63 static inline bool tcf_block_shared(struct tcf_block *block) 64 { 65 return block->index; 66 } 67 68 static inline bool tcf_block_non_null_shared(struct tcf_block *block) 69 { 70 return block && block->index; 71 } 72 73 static inline struct Qdisc *tcf_block_q(struct tcf_block *block) 74 { 75 WARN_ON(tcf_block_shared(block)); 76 return block->q; 77 } 78 79 int tcf_classify(struct sk_buff *skb, 80 const struct tcf_block *block, 81 const struct tcf_proto *tp, struct tcf_result *res, 82 bool compat_mode); 83 84 #else 85 static inline bool tcf_block_shared(struct tcf_block *block) 86 { 87 return false; 88 } 89 90 static inline bool tcf_block_non_null_shared(struct tcf_block *block) 91 { 92 return false; 93 } 94 95 static inline 96 int tcf_block_get(struct tcf_block **p_block, 97 struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q, 98 struct netlink_ext_ack *extack) 99 { 100 return 0; 101 } 102 103 static inline 104 int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q, 105 struct tcf_block_ext_info *ei, 106 struct netlink_ext_ack *extack) 107 { 108 return 0; 109 } 110 111 static inline void tcf_block_put(struct tcf_block *block) 112 { 113 } 114 115 static inline 116 void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q, 117 struct tcf_block_ext_info *ei) 118 { 119 } 120 121 static inline struct Qdisc *tcf_block_q(struct tcf_block *block) 122 { 123 return NULL; 124 } 125 126 static inline 127 int tc_setup_cb_block_register(struct tcf_block *block, flow_setup_cb_t *cb, 128 void *cb_priv) 129 { 130 return 0; 131 } 132 133 static inline 134 void tc_setup_cb_block_unregister(struct tcf_block *block, flow_setup_cb_t *cb, 135 void *cb_priv) 136 { 137 } 138 139 static inline int tcf_classify(struct sk_buff *skb, 140 const struct tcf_block *block, 141 const struct tcf_proto *tp, 142 struct tcf_result *res, bool compat_mode) 143 { 144 return TC_ACT_UNSPEC; 145 } 146 147 #endif 148 149 static inline unsigned long 150 __cls_set_class(unsigned long *clp, unsigned long cl) 151 { 152 return xchg(clp, cl); 153 } 154 155 static inline void 156 __tcf_bind_filter(struct Qdisc *q, struct tcf_result *r, unsigned long base) 157 { 158 unsigned long cl; 159 160 cl = q->ops->cl_ops->bind_tcf(q, base, r->classid); 161 cl = __cls_set_class(&r->class, cl); 162 if (cl) 163 q->ops->cl_ops->unbind_tcf(q, cl); 164 } 165 166 static inline void 167 tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base) 168 { 169 struct Qdisc *q = tp->chain->block->q; 170 171 /* Check q as it is not set for shared blocks. In that case, 172 * setting class is not supported. 173 */ 174 if (!q) 175 return; 176 sch_tree_lock(q); 177 __tcf_bind_filter(q, r, base); 178 sch_tree_unlock(q); 179 } 180 181 static inline void 182 __tcf_unbind_filter(struct Qdisc *q, struct tcf_result *r) 183 { 184 unsigned long cl; 185 186 if ((cl = __cls_set_class(&r->class, 0)) != 0) 187 q->ops->cl_ops->unbind_tcf(q, cl); 188 } 189 190 static inline void 191 tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r) 192 { 193 struct Qdisc *q = tp->chain->block->q; 194 195 if (!q) 196 return; 197 __tcf_unbind_filter(q, r); 198 } 199 200 struct tcf_exts { 201 #ifdef CONFIG_NET_CLS_ACT 202 __u32 type; /* for backward compat(TCA_OLD_COMPAT) */ 203 int nr_actions; 204 struct tc_action **actions; 205 struct net *net; 206 netns_tracker ns_tracker; 207 #endif 208 /* Map to export classifier specific extension TLV types to the 209 * generic extensions API. Unsupported extensions must be set to 0. 210 */ 211 int action; 212 int police; 213 }; 214 215 static inline int tcf_exts_init(struct tcf_exts *exts, struct net *net, 216 int action, int police) 217 { 218 #ifdef CONFIG_NET_CLS_ACT 219 exts->type = 0; 220 exts->nr_actions = 0; 221 /* Note: we do not own yet a reference on net. 222 * This reference might be taken later from tcf_exts_get_net(). 223 */ 224 exts->net = net; 225 exts->actions = kcalloc(TCA_ACT_MAX_PRIO, sizeof(struct tc_action *), 226 GFP_KERNEL); 227 if (!exts->actions) 228 return -ENOMEM; 229 #endif 230 exts->action = action; 231 exts->police = police; 232 return 0; 233 } 234 235 /* Return false if the netns is being destroyed in cleanup_net(). Callers 236 * need to do cleanup synchronously in this case, otherwise may race with 237 * tc_action_net_exit(). Return true for other cases. 238 */ 239 static inline bool tcf_exts_get_net(struct tcf_exts *exts) 240 { 241 #ifdef CONFIG_NET_CLS_ACT 242 exts->net = maybe_get_net(exts->net); 243 if (exts->net) 244 netns_tracker_alloc(exts->net, &exts->ns_tracker, GFP_KERNEL); 245 return exts->net != NULL; 246 #else 247 return true; 248 #endif 249 } 250 251 static inline void tcf_exts_put_net(struct tcf_exts *exts) 252 { 253 #ifdef CONFIG_NET_CLS_ACT 254 if (exts->net) 255 put_net_track(exts->net, &exts->ns_tracker); 256 #endif 257 } 258 259 #ifdef CONFIG_NET_CLS_ACT 260 #define tcf_exts_for_each_action(i, a, exts) \ 261 for (i = 0; i < TCA_ACT_MAX_PRIO && ((a) = (exts)->actions[i]); i++) 262 #else 263 #define tcf_exts_for_each_action(i, a, exts) \ 264 for (; 0; (void)(i), (void)(a), (void)(exts)) 265 #endif 266 267 #define tcf_act_for_each_action(i, a, actions) \ 268 for (i = 0; i < TCA_ACT_MAX_PRIO && ((a) = actions[i]); i++) 269 270 static inline void 271 tcf_exts_hw_stats_update(const struct tcf_exts *exts, 272 u64 bytes, u64 packets, u64 drops, u64 lastuse, 273 u8 used_hw_stats, bool used_hw_stats_valid) 274 { 275 #ifdef CONFIG_NET_CLS_ACT 276 int i; 277 278 for (i = 0; i < exts->nr_actions; i++) { 279 struct tc_action *a = exts->actions[i]; 280 281 /* if stats from hw, just skip */ 282 if (tcf_action_update_hw_stats(a)) { 283 preempt_disable(); 284 tcf_action_stats_update(a, bytes, packets, drops, 285 lastuse, true); 286 preempt_enable(); 287 288 a->used_hw_stats = used_hw_stats; 289 a->used_hw_stats_valid = used_hw_stats_valid; 290 } 291 } 292 #endif 293 } 294 295 /** 296 * tcf_exts_has_actions - check if at least one action is present 297 * @exts: tc filter extensions handle 298 * 299 * Returns true if at least one action is present. 300 */ 301 static inline bool tcf_exts_has_actions(struct tcf_exts *exts) 302 { 303 #ifdef CONFIG_NET_CLS_ACT 304 return exts->nr_actions; 305 #else 306 return false; 307 #endif 308 } 309 310 /** 311 * tcf_exts_exec - execute tc filter extensions 312 * @skb: socket buffer 313 * @exts: tc filter extensions handle 314 * @res: desired result 315 * 316 * Executes all configured extensions. Returns TC_ACT_OK on a normal execution, 317 * a negative number if the filter must be considered unmatched or 318 * a positive action code (TC_ACT_*) which must be returned to the 319 * underlying layer. 320 */ 321 static inline int 322 tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts, 323 struct tcf_result *res) 324 { 325 #ifdef CONFIG_NET_CLS_ACT 326 return tcf_action_exec(skb, exts->actions, exts->nr_actions, res); 327 #endif 328 return TC_ACT_OK; 329 } 330 331 int tcf_exts_validate(struct net *net, struct tcf_proto *tp, 332 struct nlattr **tb, struct nlattr *rate_tlv, 333 struct tcf_exts *exts, u32 flags, 334 struct netlink_ext_ack *extack); 335 int tcf_exts_validate_ex(struct net *net, struct tcf_proto *tp, struct nlattr **tb, 336 struct nlattr *rate_tlv, struct tcf_exts *exts, 337 u32 flags, u32 fl_flags, struct netlink_ext_ack *extack); 338 void tcf_exts_destroy(struct tcf_exts *exts); 339 void tcf_exts_change(struct tcf_exts *dst, struct tcf_exts *src); 340 int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts); 341 int tcf_exts_terse_dump(struct sk_buff *skb, struct tcf_exts *exts); 342 int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts); 343 344 /** 345 * struct tcf_pkt_info - packet information 346 * 347 * @ptr: start of the pkt data 348 * @nexthdr: offset of the next header 349 */ 350 struct tcf_pkt_info { 351 unsigned char * ptr; 352 int nexthdr; 353 }; 354 355 #ifdef CONFIG_NET_EMATCH 356 357 struct tcf_ematch_ops; 358 359 /** 360 * struct tcf_ematch - extended match (ematch) 361 * 362 * @matchid: identifier to allow userspace to reidentify a match 363 * @flags: flags specifying attributes and the relation to other matches 364 * @ops: the operations lookup table of the corresponding ematch module 365 * @datalen: length of the ematch specific configuration data 366 * @data: ematch specific data 367 * @net: the network namespace 368 */ 369 struct tcf_ematch { 370 struct tcf_ematch_ops * ops; 371 unsigned long data; 372 unsigned int datalen; 373 u16 matchid; 374 u16 flags; 375 struct net *net; 376 }; 377 378 static inline int tcf_em_is_container(struct tcf_ematch *em) 379 { 380 return !em->ops; 381 } 382 383 static inline int tcf_em_is_simple(struct tcf_ematch *em) 384 { 385 return em->flags & TCF_EM_SIMPLE; 386 } 387 388 static inline int tcf_em_is_inverted(struct tcf_ematch *em) 389 { 390 return em->flags & TCF_EM_INVERT; 391 } 392 393 static inline int tcf_em_last_match(struct tcf_ematch *em) 394 { 395 return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END; 396 } 397 398 static inline int tcf_em_early_end(struct tcf_ematch *em, int result) 399 { 400 if (tcf_em_last_match(em)) 401 return 1; 402 403 if (result == 0 && em->flags & TCF_EM_REL_AND) 404 return 1; 405 406 if (result != 0 && em->flags & TCF_EM_REL_OR) 407 return 1; 408 409 return 0; 410 } 411 412 /** 413 * struct tcf_ematch_tree - ematch tree handle 414 * 415 * @hdr: ematch tree header supplied by userspace 416 * @matches: array of ematches 417 */ 418 struct tcf_ematch_tree { 419 struct tcf_ematch_tree_hdr hdr; 420 struct tcf_ematch * matches; 421 422 }; 423 424 /** 425 * struct tcf_ematch_ops - ematch module operations 426 * 427 * @kind: identifier (kind) of this ematch module 428 * @datalen: length of expected configuration data (optional) 429 * @change: called during validation (optional) 430 * @match: called during ematch tree evaluation, must return 1/0 431 * @destroy: called during destroyage (optional) 432 * @dump: called during dumping process (optional) 433 * @owner: owner, must be set to THIS_MODULE 434 * @link: link to previous/next ematch module (internal use) 435 */ 436 struct tcf_ematch_ops { 437 int kind; 438 int datalen; 439 int (*change)(struct net *net, void *, 440 int, struct tcf_ematch *); 441 int (*match)(struct sk_buff *, struct tcf_ematch *, 442 struct tcf_pkt_info *); 443 void (*destroy)(struct tcf_ematch *); 444 int (*dump)(struct sk_buff *, struct tcf_ematch *); 445 struct module *owner; 446 struct list_head link; 447 }; 448 449 int tcf_em_register(struct tcf_ematch_ops *); 450 void tcf_em_unregister(struct tcf_ematch_ops *); 451 int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *, 452 struct tcf_ematch_tree *); 453 void tcf_em_tree_destroy(struct tcf_ematch_tree *); 454 int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int); 455 int __tcf_em_tree_match(struct sk_buff *, struct tcf_ematch_tree *, 456 struct tcf_pkt_info *); 457 458 /** 459 * tcf_em_tree_match - evaulate an ematch tree 460 * 461 * @skb: socket buffer of the packet in question 462 * @tree: ematch tree to be used for evaluation 463 * @info: packet information examined by classifier 464 * 465 * This function matches @skb against the ematch tree in @tree by going 466 * through all ematches respecting their logic relations returning 467 * as soon as the result is obvious. 468 * 469 * Returns 1 if the ematch tree as-one matches, no ematches are configured 470 * or ematch is not enabled in the kernel, otherwise 0 is returned. 471 */ 472 static inline int tcf_em_tree_match(struct sk_buff *skb, 473 struct tcf_ematch_tree *tree, 474 struct tcf_pkt_info *info) 475 { 476 if (tree->hdr.nmatches) 477 return __tcf_em_tree_match(skb, tree, info); 478 else 479 return 1; 480 } 481 482 #define MODULE_ALIAS_TCF_EMATCH(kind) MODULE_ALIAS("ematch-kind-" __stringify(kind)) 483 484 #else /* CONFIG_NET_EMATCH */ 485 486 struct tcf_ematch_tree { 487 }; 488 489 #define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0) 490 #define tcf_em_tree_destroy(t) do { (void)(t); } while(0) 491 #define tcf_em_tree_dump(skb, t, tlv) (0) 492 #define tcf_em_tree_match(skb, t, info) ((void)(info), 1) 493 494 #endif /* CONFIG_NET_EMATCH */ 495 496 static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer) 497 { 498 switch (layer) { 499 case TCF_LAYER_LINK: 500 return skb_mac_header(skb); 501 case TCF_LAYER_NETWORK: 502 return skb_network_header(skb); 503 case TCF_LAYER_TRANSPORT: 504 return skb_transport_header(skb); 505 } 506 507 return NULL; 508 } 509 510 static inline int tcf_valid_offset(const struct sk_buff *skb, 511 const unsigned char *ptr, const int len) 512 { 513 return likely((ptr + len) <= skb_tail_pointer(skb) && 514 ptr >= skb->head && 515 (ptr <= (ptr + len))); 516 } 517 518 static inline int 519 tcf_change_indev(struct net *net, struct nlattr *indev_tlv, 520 struct netlink_ext_ack *extack) 521 { 522 char indev[IFNAMSIZ]; 523 struct net_device *dev; 524 525 if (nla_strscpy(indev, indev_tlv, IFNAMSIZ) < 0) { 526 NL_SET_ERR_MSG_ATTR(extack, indev_tlv, 527 "Interface name too long"); 528 return -EINVAL; 529 } 530 dev = __dev_get_by_name(net, indev); 531 if (!dev) { 532 NL_SET_ERR_MSG_ATTR(extack, indev_tlv, 533 "Network device not found"); 534 return -ENODEV; 535 } 536 return dev->ifindex; 537 } 538 539 static inline bool 540 tcf_match_indev(struct sk_buff *skb, int ifindex) 541 { 542 if (!ifindex) 543 return true; 544 if (!skb->skb_iif) 545 return false; 546 return ifindex == skb->skb_iif; 547 } 548 549 int tc_setup_offload_action(struct flow_action *flow_action, 550 const struct tcf_exts *exts); 551 void tc_cleanup_offload_action(struct flow_action *flow_action); 552 int tc_setup_action(struct flow_action *flow_action, 553 struct tc_action *actions[]); 554 555 int tc_setup_cb_call(struct tcf_block *block, enum tc_setup_type type, 556 void *type_data, bool err_stop, bool rtnl_held); 557 int tc_setup_cb_add(struct tcf_block *block, struct tcf_proto *tp, 558 enum tc_setup_type type, void *type_data, bool err_stop, 559 u32 *flags, unsigned int *in_hw_count, bool rtnl_held); 560 int tc_setup_cb_replace(struct tcf_block *block, struct tcf_proto *tp, 561 enum tc_setup_type type, void *type_data, bool err_stop, 562 u32 *old_flags, unsigned int *old_in_hw_count, 563 u32 *new_flags, unsigned int *new_in_hw_count, 564 bool rtnl_held); 565 int tc_setup_cb_destroy(struct tcf_block *block, struct tcf_proto *tp, 566 enum tc_setup_type type, void *type_data, bool err_stop, 567 u32 *flags, unsigned int *in_hw_count, bool rtnl_held); 568 int tc_setup_cb_reoffload(struct tcf_block *block, struct tcf_proto *tp, 569 bool add, flow_setup_cb_t *cb, 570 enum tc_setup_type type, void *type_data, 571 void *cb_priv, u32 *flags, unsigned int *in_hw_count); 572 unsigned int tcf_exts_num_actions(struct tcf_exts *exts); 573 574 #ifdef CONFIG_NET_CLS_ACT 575 int tcf_qevent_init(struct tcf_qevent *qe, struct Qdisc *sch, 576 enum flow_block_binder_type binder_type, 577 struct nlattr *block_index_attr, 578 struct netlink_ext_ack *extack); 579 void tcf_qevent_destroy(struct tcf_qevent *qe, struct Qdisc *sch); 580 int tcf_qevent_validate_change(struct tcf_qevent *qe, struct nlattr *block_index_attr, 581 struct netlink_ext_ack *extack); 582 struct sk_buff *tcf_qevent_handle(struct tcf_qevent *qe, struct Qdisc *sch, struct sk_buff *skb, 583 struct sk_buff **to_free, int *ret); 584 int tcf_qevent_dump(struct sk_buff *skb, int attr_name, struct tcf_qevent *qe); 585 #else 586 static inline int tcf_qevent_init(struct tcf_qevent *qe, struct Qdisc *sch, 587 enum flow_block_binder_type binder_type, 588 struct nlattr *block_index_attr, 589 struct netlink_ext_ack *extack) 590 { 591 return 0; 592 } 593 594 static inline void tcf_qevent_destroy(struct tcf_qevent *qe, struct Qdisc *sch) 595 { 596 } 597 598 static inline int tcf_qevent_validate_change(struct tcf_qevent *qe, struct nlattr *block_index_attr, 599 struct netlink_ext_ack *extack) 600 { 601 return 0; 602 } 603 604 static inline struct sk_buff * 605 tcf_qevent_handle(struct tcf_qevent *qe, struct Qdisc *sch, struct sk_buff *skb, 606 struct sk_buff **to_free, int *ret) 607 { 608 return skb; 609 } 610 611 static inline int tcf_qevent_dump(struct sk_buff *skb, int attr_name, struct tcf_qevent *qe) 612 { 613 return 0; 614 } 615 #endif 616 617 struct tc_cls_u32_knode { 618 struct tcf_exts *exts; 619 struct tcf_result *res; 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 flow_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 flow_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 flow_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 >> 16; 720 if (tc_skip_sw(flags) || flags & TCA_CLS_FLAGS_VERBOSE) 721 cls_common->extack = extack; 722 } 723 724 #if IS_ENABLED(CONFIG_NET_TC_SKB_EXT) 725 static inline struct tc_skb_ext *tc_skb_ext_alloc(struct sk_buff *skb) 726 { 727 struct tc_skb_ext *tc_skb_ext = skb_ext_add(skb, TC_SKB_EXT); 728 729 if (tc_skb_ext) 730 memset(tc_skb_ext, 0, sizeof(*tc_skb_ext)); 731 return tc_skb_ext; 732 } 733 #endif 734 735 enum tc_matchall_command { 736 TC_CLSMATCHALL_REPLACE, 737 TC_CLSMATCHALL_DESTROY, 738 TC_CLSMATCHALL_STATS, 739 }; 740 741 struct tc_cls_matchall_offload { 742 struct flow_cls_common_offload common; 743 enum tc_matchall_command command; 744 struct flow_rule *rule; 745 struct flow_stats stats; 746 unsigned long cookie; 747 }; 748 749 enum tc_clsbpf_command { 750 TC_CLSBPF_OFFLOAD, 751 TC_CLSBPF_STATS, 752 }; 753 754 struct tc_cls_bpf_offload { 755 struct flow_cls_common_offload common; 756 enum tc_clsbpf_command command; 757 struct tcf_exts *exts; 758 struct bpf_prog *prog; 759 struct bpf_prog *oldprog; 760 const char *name; 761 bool exts_integrated; 762 }; 763 764 struct tc_mqprio_qopt_offload { 765 /* struct tc_mqprio_qopt must always be the first element */ 766 struct tc_mqprio_qopt qopt; 767 u16 mode; 768 u16 shaper; 769 u32 flags; 770 u64 min_rate[TC_QOPT_MAX_QUEUE]; 771 u64 max_rate[TC_QOPT_MAX_QUEUE]; 772 }; 773 774 /* This structure holds cookie structure that is passed from user 775 * to the kernel for actions and classifiers 776 */ 777 struct tc_cookie { 778 u8 *data; 779 u32 len; 780 struct rcu_head rcu; 781 }; 782 783 struct tc_qopt_offload_stats { 784 struct gnet_stats_basic_sync *bstats; 785 struct gnet_stats_queue *qstats; 786 }; 787 788 enum tc_mq_command { 789 TC_MQ_CREATE, 790 TC_MQ_DESTROY, 791 TC_MQ_STATS, 792 TC_MQ_GRAFT, 793 }; 794 795 struct tc_mq_opt_offload_graft_params { 796 unsigned long queue; 797 u32 child_handle; 798 }; 799 800 struct tc_mq_qopt_offload { 801 enum tc_mq_command command; 802 u32 handle; 803 union { 804 struct tc_qopt_offload_stats stats; 805 struct tc_mq_opt_offload_graft_params graft_params; 806 }; 807 }; 808 809 enum tc_htb_command { 810 /* Root */ 811 TC_HTB_CREATE, /* Initialize HTB offload. */ 812 TC_HTB_DESTROY, /* Destroy HTB offload. */ 813 814 /* Classes */ 815 /* Allocate qid and create leaf. */ 816 TC_HTB_LEAF_ALLOC_QUEUE, 817 /* Convert leaf to inner, preserve and return qid, create new leaf. */ 818 TC_HTB_LEAF_TO_INNER, 819 /* Delete leaf, while siblings remain. */ 820 TC_HTB_LEAF_DEL, 821 /* Delete leaf, convert parent to leaf, preserving qid. */ 822 TC_HTB_LEAF_DEL_LAST, 823 /* TC_HTB_LEAF_DEL_LAST, but delete driver data on hardware errors. */ 824 TC_HTB_LEAF_DEL_LAST_FORCE, 825 /* Modify parameters of a node. */ 826 TC_HTB_NODE_MODIFY, 827 828 /* Class qdisc */ 829 TC_HTB_LEAF_QUERY_QUEUE, /* Query qid by classid. */ 830 }; 831 832 struct tc_htb_qopt_offload { 833 struct netlink_ext_ack *extack; 834 enum tc_htb_command command; 835 u32 parent_classid; 836 u16 classid; 837 u16 qid; 838 u64 rate; 839 u64 ceil; 840 }; 841 842 #define TC_HTB_CLASSID_ROOT U32_MAX 843 844 enum tc_red_command { 845 TC_RED_REPLACE, 846 TC_RED_DESTROY, 847 TC_RED_STATS, 848 TC_RED_XSTATS, 849 TC_RED_GRAFT, 850 }; 851 852 struct tc_red_qopt_offload_params { 853 u32 min; 854 u32 max; 855 u32 probability; 856 u32 limit; 857 bool is_ecn; 858 bool is_harddrop; 859 bool is_nodrop; 860 struct gnet_stats_queue *qstats; 861 }; 862 863 struct tc_red_qopt_offload { 864 enum tc_red_command command; 865 u32 handle; 866 u32 parent; 867 union { 868 struct tc_red_qopt_offload_params set; 869 struct tc_qopt_offload_stats stats; 870 struct red_stats *xstats; 871 u32 child_handle; 872 }; 873 }; 874 875 enum tc_gred_command { 876 TC_GRED_REPLACE, 877 TC_GRED_DESTROY, 878 TC_GRED_STATS, 879 }; 880 881 struct tc_gred_vq_qopt_offload_params { 882 bool present; 883 u32 limit; 884 u32 prio; 885 u32 min; 886 u32 max; 887 bool is_ecn; 888 bool is_harddrop; 889 u32 probability; 890 /* Only need backlog, see struct tc_prio_qopt_offload_params */ 891 u32 *backlog; 892 }; 893 894 struct tc_gred_qopt_offload_params { 895 bool grio_on; 896 bool wred_on; 897 unsigned int dp_cnt; 898 unsigned int dp_def; 899 struct gnet_stats_queue *qstats; 900 struct tc_gred_vq_qopt_offload_params tab[MAX_DPs]; 901 }; 902 903 struct tc_gred_qopt_offload_stats { 904 struct gnet_stats_basic_sync bstats[MAX_DPs]; 905 struct gnet_stats_queue qstats[MAX_DPs]; 906 struct red_stats *xstats[MAX_DPs]; 907 }; 908 909 struct tc_gred_qopt_offload { 910 enum tc_gred_command command; 911 u32 handle; 912 u32 parent; 913 union { 914 struct tc_gred_qopt_offload_params set; 915 struct tc_gred_qopt_offload_stats stats; 916 }; 917 }; 918 919 enum tc_prio_command { 920 TC_PRIO_REPLACE, 921 TC_PRIO_DESTROY, 922 TC_PRIO_STATS, 923 TC_PRIO_GRAFT, 924 }; 925 926 struct tc_prio_qopt_offload_params { 927 int bands; 928 u8 priomap[TC_PRIO_MAX + 1]; 929 /* At the point of un-offloading the Qdisc, the reported backlog and 930 * qlen need to be reduced by the portion that is in HW. 931 */ 932 struct gnet_stats_queue *qstats; 933 }; 934 935 struct tc_prio_qopt_offload_graft_params { 936 u8 band; 937 u32 child_handle; 938 }; 939 940 struct tc_prio_qopt_offload { 941 enum tc_prio_command command; 942 u32 handle; 943 u32 parent; 944 union { 945 struct tc_prio_qopt_offload_params replace_params; 946 struct tc_qopt_offload_stats stats; 947 struct tc_prio_qopt_offload_graft_params graft_params; 948 }; 949 }; 950 951 enum tc_root_command { 952 TC_ROOT_GRAFT, 953 }; 954 955 struct tc_root_qopt_offload { 956 enum tc_root_command command; 957 u32 handle; 958 bool ingress; 959 }; 960 961 enum tc_ets_command { 962 TC_ETS_REPLACE, 963 TC_ETS_DESTROY, 964 TC_ETS_STATS, 965 TC_ETS_GRAFT, 966 }; 967 968 struct tc_ets_qopt_offload_replace_params { 969 unsigned int bands; 970 u8 priomap[TC_PRIO_MAX + 1]; 971 unsigned int quanta[TCQ_ETS_MAX_BANDS]; /* 0 for strict bands. */ 972 unsigned int weights[TCQ_ETS_MAX_BANDS]; 973 struct gnet_stats_queue *qstats; 974 }; 975 976 struct tc_ets_qopt_offload_graft_params { 977 u8 band; 978 u32 child_handle; 979 }; 980 981 struct tc_ets_qopt_offload { 982 enum tc_ets_command command; 983 u32 handle; 984 u32 parent; 985 union { 986 struct tc_ets_qopt_offload_replace_params replace_params; 987 struct tc_qopt_offload_stats stats; 988 struct tc_ets_qopt_offload_graft_params graft_params; 989 }; 990 }; 991 992 enum tc_tbf_command { 993 TC_TBF_REPLACE, 994 TC_TBF_DESTROY, 995 TC_TBF_STATS, 996 TC_TBF_GRAFT, 997 }; 998 999 struct tc_tbf_qopt_offload_replace_params { 1000 struct psched_ratecfg rate; 1001 u32 max_size; 1002 struct gnet_stats_queue *qstats; 1003 }; 1004 1005 struct tc_tbf_qopt_offload { 1006 enum tc_tbf_command command; 1007 u32 handle; 1008 u32 parent; 1009 union { 1010 struct tc_tbf_qopt_offload_replace_params replace_params; 1011 struct tc_qopt_offload_stats stats; 1012 u32 child_handle; 1013 }; 1014 }; 1015 1016 enum tc_fifo_command { 1017 TC_FIFO_REPLACE, 1018 TC_FIFO_DESTROY, 1019 TC_FIFO_STATS, 1020 }; 1021 1022 struct tc_fifo_qopt_offload { 1023 enum tc_fifo_command command; 1024 u32 handle; 1025 u32 parent; 1026 union { 1027 struct tc_qopt_offload_stats stats; 1028 }; 1029 }; 1030 1031 #endif 1032