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