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