~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/net/pkt_cls.h

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp