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