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