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