a3101582f642c1a903f93e30fd090cfb940f7fc2
[sfrench/cifs-2.6.git] / 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         unsigned long cookie;
17         int     (*fn)(struct tcf_proto *, void *node, struct tcf_walker *);
18 };
19
20 int register_tcf_proto_ops(struct tcf_proto_ops *ops);
21 int unregister_tcf_proto_ops(struct tcf_proto_ops *ops);
22
23 enum tcf_block_binder_type {
24         TCF_BLOCK_BINDER_TYPE_UNSPEC,
25         TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS,
26         TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS,
27 };
28
29 struct tcf_block_ext_info {
30         enum tcf_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(struct tcf_block *block, u32 chain_index,
41                                 bool create);
42 void tcf_chain_put(struct tcf_chain *chain);
43 void tcf_block_netif_keep_dst(struct tcf_block *block);
44 int tcf_block_get(struct tcf_block **p_block,
45                   struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q,
46                   struct netlink_ext_ack *extack);
47 int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q,
48                       struct tcf_block_ext_info *ei,
49                       struct netlink_ext_ack *extack);
50 void tcf_block_put(struct tcf_block *block);
51 void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q,
52                        struct tcf_block_ext_info *ei);
53
54 static inline bool tcf_block_shared(struct tcf_block *block)
55 {
56         return block->index;
57 }
58
59 static inline struct Qdisc *tcf_block_q(struct tcf_block *block)
60 {
61         WARN_ON(tcf_block_shared(block));
62         return block->q;
63 }
64
65 static inline struct net_device *tcf_block_dev(struct tcf_block *block)
66 {
67         return tcf_block_q(block)->dev_queue->dev;
68 }
69
70 void *tcf_block_cb_priv(struct tcf_block_cb *block_cb);
71 struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block,
72                                          tc_setup_cb_t *cb, void *cb_ident);
73 void tcf_block_cb_incref(struct tcf_block_cb *block_cb);
74 unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb);
75 struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block,
76                                              tc_setup_cb_t *cb, void *cb_ident,
77                                              void *cb_priv,
78                                              struct netlink_ext_ack *extack);
79 int tcf_block_cb_register(struct tcf_block *block,
80                           tc_setup_cb_t *cb, void *cb_ident,
81                           void *cb_priv, struct netlink_ext_ack *extack);
82 void __tcf_block_cb_unregister(struct tcf_block *block,
83                                struct tcf_block_cb *block_cb);
84 void tcf_block_cb_unregister(struct tcf_block *block,
85                              tc_setup_cb_t *cb, void *cb_ident);
86
87 int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
88                  struct tcf_result *res, bool compat_mode);
89
90 #else
91 static inline
92 int tcf_block_get(struct tcf_block **p_block,
93                   struct tcf_proto __rcu **p_filter_chain, struct Qdisc *q,
94                   struct netlink_ext_ack *extack)
95 {
96         return 0;
97 }
98
99 static inline
100 int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q,
101                       struct tcf_block_ext_info *ei,
102                       struct netlink_ext_ack *extack)
103 {
104         return 0;
105 }
106
107 static inline void tcf_block_put(struct tcf_block *block)
108 {
109 }
110
111 static inline
112 void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q,
113                        struct tcf_block_ext_info *ei)
114 {
115 }
116
117 static inline struct Qdisc *tcf_block_q(struct tcf_block *block)
118 {
119         return NULL;
120 }
121
122 static inline struct net_device *tcf_block_dev(struct tcf_block *block)
123 {
124         return NULL;
125 }
126
127 static inline
128 int tc_setup_cb_block_register(struct tcf_block *block, tc_setup_cb_t *cb,
129                                void *cb_priv)
130 {
131         return 0;
132 }
133
134 static inline
135 void tc_setup_cb_block_unregister(struct tcf_block *block, tc_setup_cb_t *cb,
136                                   void *cb_priv)
137 {
138 }
139
140 static inline
141 void *tcf_block_cb_priv(struct tcf_block_cb *block_cb)
142 {
143         return NULL;
144 }
145
146 static inline
147 struct tcf_block_cb *tcf_block_cb_lookup(struct tcf_block *block,
148                                          tc_setup_cb_t *cb, void *cb_ident)
149 {
150         return NULL;
151 }
152
153 static inline
154 void tcf_block_cb_incref(struct tcf_block_cb *block_cb)
155 {
156 }
157
158 static inline
159 unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb)
160 {
161         return 0;
162 }
163
164 static inline
165 struct tcf_block_cb *__tcf_block_cb_register(struct tcf_block *block,
166                                              tc_setup_cb_t *cb, void *cb_ident,
167                                              void *cb_priv,
168                                              struct netlink_ext_ack *extack)
169 {
170         return NULL;
171 }
172
173 static inline
174 int tcf_block_cb_register(struct tcf_block *block,
175                           tc_setup_cb_t *cb, void *cb_ident,
176                           void *cb_priv, struct netlink_ext_ack *extack)
177 {
178         return 0;
179 }
180
181 static inline
182 void __tcf_block_cb_unregister(struct tcf_block *block,
183                                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         struct netlink_ext_ack *extack;
605 };
606
607 struct tc_cls_common_offload {
608         u32 chain_index;
609         __be16 protocol;
610         u32 prio;
611         struct netlink_ext_ack *extack;
612 };
613
614 struct tc_cls_u32_knode {
615         struct tcf_exts *exts;
616         struct tc_u32_sel *sel;
617         u32 handle;
618         u32 val;
619         u32 mask;
620         u32 link_handle;
621         u8 fshift;
622 };
623
624 struct tc_cls_u32_hnode {
625         u32 handle;
626         u32 prio;
627         unsigned int divisor;
628 };
629
630 enum tc_clsu32_command {
631         TC_CLSU32_NEW_KNODE,
632         TC_CLSU32_REPLACE_KNODE,
633         TC_CLSU32_DELETE_KNODE,
634         TC_CLSU32_NEW_HNODE,
635         TC_CLSU32_REPLACE_HNODE,
636         TC_CLSU32_DELETE_HNODE,
637 };
638
639 struct tc_cls_u32_offload {
640         struct tc_cls_common_offload common;
641         /* knode values */
642         enum tc_clsu32_command command;
643         union {
644                 struct tc_cls_u32_knode knode;
645                 struct tc_cls_u32_hnode hnode;
646         };
647 };
648
649 static inline bool tc_can_offload(const struct net_device *dev)
650 {
651         return dev->features & NETIF_F_HW_TC;
652 }
653
654 static inline bool tc_can_offload_extack(const struct net_device *dev,
655                                          struct netlink_ext_ack *extack)
656 {
657         bool can = tc_can_offload(dev);
658
659         if (!can)
660                 NL_SET_ERR_MSG(extack, "TC offload is disabled on net device");
661
662         return can;
663 }
664
665 static inline bool
666 tc_cls_can_offload_and_chain0(const struct net_device *dev,
667                               struct tc_cls_common_offload *common)
668 {
669         if (!tc_can_offload_extack(dev, common->extack))
670                 return false;
671         if (common->chain_index) {
672                 NL_SET_ERR_MSG(common->extack,
673                                "Driver supports only offload of chain 0");
674                 return false;
675         }
676         return true;
677 }
678
679 static inline bool tc_skip_hw(u32 flags)
680 {
681         return (flags & TCA_CLS_FLAGS_SKIP_HW) ? true : false;
682 }
683
684 static inline bool tc_skip_sw(u32 flags)
685 {
686         return (flags & TCA_CLS_FLAGS_SKIP_SW) ? true : false;
687 }
688
689 /* SKIP_HW and SKIP_SW are mutually exclusive flags. */
690 static inline bool tc_flags_valid(u32 flags)
691 {
692         if (flags & ~(TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW |
693                       TCA_CLS_FLAGS_VERBOSE))
694                 return false;
695
696         flags &= TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW;
697         if (!(flags ^ (TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW)))
698                 return false;
699
700         return true;
701 }
702
703 static inline bool tc_in_hw(u32 flags)
704 {
705         return (flags & TCA_CLS_FLAGS_IN_HW) ? true : false;
706 }
707
708 static inline void
709 tc_cls_common_offload_init(struct tc_cls_common_offload *cls_common,
710                            const struct tcf_proto *tp, u32 flags,
711                            struct netlink_ext_ack *extack)
712 {
713         cls_common->chain_index = tp->chain->index;
714         cls_common->protocol = tp->protocol;
715         cls_common->prio = tp->prio;
716         if (tc_skip_sw(flags) || flags & TCA_CLS_FLAGS_VERBOSE)
717                 cls_common->extack = extack;
718 }
719
720 enum tc_fl_command {
721         TC_CLSFLOWER_REPLACE,
722         TC_CLSFLOWER_DESTROY,
723         TC_CLSFLOWER_STATS,
724         TC_CLSFLOWER_TMPLT_CREATE,
725         TC_CLSFLOWER_TMPLT_DESTROY,
726 };
727
728 struct tc_cls_flower_offload {
729         struct tc_cls_common_offload common;
730         enum tc_fl_command command;
731         unsigned long cookie;
732         struct flow_dissector *dissector;
733         struct fl_flow_key *mask;
734         struct fl_flow_key *key;
735         struct tcf_exts *exts;
736         u32 classid;
737 };
738
739 enum tc_matchall_command {
740         TC_CLSMATCHALL_REPLACE,
741         TC_CLSMATCHALL_DESTROY,
742 };
743
744 struct tc_cls_matchall_offload {
745         struct tc_cls_common_offload common;
746         enum tc_matchall_command command;
747         struct tcf_exts *exts;
748         unsigned long cookie;
749 };
750
751 enum tc_clsbpf_command {
752         TC_CLSBPF_OFFLOAD,
753         TC_CLSBPF_STATS,
754 };
755
756 struct tc_cls_bpf_offload {
757         struct tc_cls_common_offload common;
758         enum tc_clsbpf_command command;
759         struct tcf_exts *exts;
760         struct bpf_prog *prog;
761         struct bpf_prog *oldprog;
762         const char *name;
763         bool exts_integrated;
764 };
765
766 struct tc_mqprio_qopt_offload {
767         /* struct tc_mqprio_qopt must always be the first element */
768         struct tc_mqprio_qopt qopt;
769         u16 mode;
770         u16 shaper;
771         u32 flags;
772         u64 min_rate[TC_QOPT_MAX_QUEUE];
773         u64 max_rate[TC_QOPT_MAX_QUEUE];
774 };
775
776 /* This structure holds cookie structure that is passed from user
777  * to the kernel for actions and classifiers
778  */
779 struct tc_cookie {
780         u8  *data;
781         u32 len;
782         struct rcu_head rcu;
783 };
784
785 struct tc_qopt_offload_stats {
786         struct gnet_stats_basic_packed *bstats;
787         struct gnet_stats_queue *qstats;
788 };
789
790 enum tc_mq_command {
791         TC_MQ_CREATE,
792         TC_MQ_DESTROY,
793         TC_MQ_STATS,
794 };
795
796 struct tc_mq_qopt_offload {
797         enum tc_mq_command command;
798         u32 handle;
799         struct tc_qopt_offload_stats stats;
800 };
801
802 enum tc_red_command {
803         TC_RED_REPLACE,
804         TC_RED_DESTROY,
805         TC_RED_STATS,
806         TC_RED_XSTATS,
807 };
808
809 struct tc_red_qopt_offload_params {
810         u32 min;
811         u32 max;
812         u32 probability;
813         bool is_ecn;
814         struct gnet_stats_queue *qstats;
815 };
816
817 struct tc_red_qopt_offload {
818         enum tc_red_command command;
819         u32 handle;
820         u32 parent;
821         union {
822                 struct tc_red_qopt_offload_params set;
823                 struct tc_qopt_offload_stats stats;
824                 struct red_stats *xstats;
825         };
826 };
827
828 enum tc_prio_command {
829         TC_PRIO_REPLACE,
830         TC_PRIO_DESTROY,
831         TC_PRIO_STATS,
832         TC_PRIO_GRAFT,
833 };
834
835 struct tc_prio_qopt_offload_params {
836         int bands;
837         u8 priomap[TC_PRIO_MAX + 1];
838         /* In case that a prio qdisc is offloaded and now is changed to a
839          * non-offloadedable config, it needs to update the backlog & qlen
840          * values to negate the HW backlog & qlen values (and only them).
841          */
842         struct gnet_stats_queue *qstats;
843 };
844
845 struct tc_prio_qopt_offload_graft_params {
846         u8 band;
847         u32 child_handle;
848 };
849
850 struct tc_prio_qopt_offload {
851         enum tc_prio_command command;
852         u32 handle;
853         u32 parent;
854         union {
855                 struct tc_prio_qopt_offload_params replace_params;
856                 struct tc_qopt_offload_stats stats;
857                 struct tc_prio_qopt_offload_graft_params graft_params;
858         };
859 };
860
861 #endif