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