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

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

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

~ [ 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