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