include/net/pkt_cls.h

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