vmalloc: fix __GFP_HIGHMEM usage for vmalloc_32 on 32b systems
[linux/fpc-iii.git] / include / net / pkt_cls.h
blob753ac9361154be4ff9d05f5aa22473f8fb818ea0
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __NET_PKT_CLS_H
3 #define __NET_PKT_CLS_H
5 #include <linux/pkt_cls.h>
6 #include <linux/workqueue.h>
7 #include <net/sch_generic.h>
8 #include <net/act_api.h>
10 /* Basic packet classifier frontend definitions. */
12 struct tcf_walker {
13 int stop;
14 int skip;
15 int count;
16 int (*fn)(struct tcf_proto *, void *node, struct tcf_walker *);
19 int register_tcf_proto_ops(struct tcf_proto_ops *ops);
20 int unregister_tcf_proto_ops(struct tcf_proto_ops *ops);
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,
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;
34 struct tcf_block_cb;
35 bool tcf_queue_work(struct work_struct *work);
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);
49 static inline struct Qdisc *tcf_block_q(struct tcf_block *block)
51 return block->q;
54 static inline struct net_device *tcf_block_dev(struct tcf_block *block)
56 return tcf_block_q(block)->dev_queue->dev;
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);
74 int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
75 struct tcf_result *res, bool compat_mode);
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)
82 return 0;
85 static inline
86 int tcf_block_get_ext(struct tcf_block **p_block, struct Qdisc *q,
87 struct tcf_block_ext_info *ei)
89 return 0;
92 static inline void tcf_block_put(struct tcf_block *block)
96 static inline
97 void tcf_block_put_ext(struct tcf_block *block, struct Qdisc *q,
98 struct tcf_block_ext_info *ei)
102 static inline struct Qdisc *tcf_block_q(struct tcf_block *block)
104 return NULL;
107 static inline struct net_device *tcf_block_dev(struct tcf_block *block)
109 return NULL;
112 static inline
113 int tc_setup_cb_block_register(struct tcf_block *block, tc_setup_cb_t *cb,
114 void *cb_priv)
116 return 0;
119 static inline
120 void tc_setup_cb_block_unregister(struct tcf_block *block, tc_setup_cb_t *cb,
121 void *cb_priv)
125 static inline
126 void *tcf_block_cb_priv(struct tcf_block_cb *block_cb)
128 return NULL;
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)
135 return NULL;
138 static inline
139 void tcf_block_cb_incref(struct tcf_block_cb *block_cb)
143 static inline
144 unsigned int tcf_block_cb_decref(struct tcf_block_cb *block_cb)
146 return 0;
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)
154 return NULL;
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)
162 return 0;
165 static inline
166 void __tcf_block_cb_unregister(struct tcf_block_cb *block_cb)
170 static inline
171 void tcf_block_cb_unregister(struct tcf_block *block,
172 tc_setup_cb_t *cb, void *cb_ident)
176 static inline int tcf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
177 struct tcf_result *res, bool compat_mode)
179 return TC_ACT_UNSPEC;
181 #endif
183 static inline unsigned long
184 __cls_set_class(unsigned long *clp, unsigned long cl)
186 return xchg(clp, cl);
189 static inline unsigned long
190 cls_set_class(struct Qdisc *q, unsigned long *clp, unsigned long cl)
192 unsigned long old_cl;
194 sch_tree_lock(q);
195 old_cl = __cls_set_class(clp, cl);
196 sch_tree_unlock(q);
197 return old_cl;
200 static inline void
201 tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base)
203 struct Qdisc *q = tp->chain->block->q;
204 unsigned long cl;
206 /* Check q as it is not set for shared blocks. In that case,
207 * setting class is not supported.
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);
217 static inline void
218 tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r)
220 struct Qdisc *q = tp->chain->block->q;
221 unsigned long cl;
223 if (!q)
224 return;
225 if ((cl = __cls_set_class(&r->class, 0)) != 0)
226 q->ops->cl_ops->unbind_tcf(q, cl);
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.
239 int action;
240 int police;
243 static inline int tcf_exts_init(struct tcf_exts *exts, int action, int police)
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;
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.
263 static inline bool tcf_exts_get_net(struct tcf_exts *exts)
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
273 static inline void tcf_exts_put_net(struct tcf_exts *exts)
275 #ifdef CONFIG_NET_CLS_ACT
276 if (exts->net)
277 put_net(exts->net);
278 #endif
281 static inline void tcf_exts_to_list(const struct tcf_exts *exts,
282 struct list_head *actions)
284 #ifdef CONFIG_NET_CLS_ACT
285 int i;
287 for (i = 0; i < exts->nr_actions; i++) {
288 struct tc_action *a = exts->actions[i];
290 list_add_tail(&a->list, actions);
292 #endif
295 static inline void
296 tcf_exts_stats_update(const struct tcf_exts *exts,
297 u64 bytes, u64 packets, u64 lastuse)
299 #ifdef CONFIG_NET_CLS_ACT
300 int i;
302 preempt_disable();
304 for (i = 0; i < exts->nr_actions; i++) {
305 struct tc_action *a = exts->actions[i];
307 tcf_action_stats_update(a, bytes, packets, lastuse);
310 preempt_enable();
311 #endif
315 * tcf_exts_has_actions - check if at least one action is present
316 * @exts: tc filter extensions handle
318 * Returns true if at least one action is present.
320 static inline bool tcf_exts_has_actions(struct tcf_exts *exts)
322 #ifdef CONFIG_NET_CLS_ACT
323 return exts->nr_actions;
324 #else
325 return false;
326 #endif
330 * tcf_exts_has_one_action - check if exactly one action is present
331 * @exts: tc filter extensions handle
333 * Returns true if exactly one action is present.
335 static inline bool tcf_exts_has_one_action(struct tcf_exts *exts)
337 #ifdef CONFIG_NET_CLS_ACT
338 return exts->nr_actions == 1;
339 #else
340 return false;
341 #endif
345 * tcf_exts_exec - execute tc filter extensions
346 * @skb: socket buffer
347 * @exts: tc filter extensions handle
348 * @res: desired result
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.
355 static inline int
356 tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts,
357 struct tcf_result *res)
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;
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);
374 * struct tcf_pkt_info - packet information
376 struct tcf_pkt_info {
377 unsigned char * ptr;
378 int nexthdr;
381 #ifdef CONFIG_NET_EMATCH
383 struct tcf_ematch_ops;
386 * struct tcf_ematch - extended match (ematch)
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
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;
403 static inline int tcf_em_is_container(struct tcf_ematch *em)
405 return !em->ops;
408 static inline int tcf_em_is_simple(struct tcf_ematch *em)
410 return em->flags & TCF_EM_SIMPLE;
413 static inline int tcf_em_is_inverted(struct tcf_ematch *em)
415 return em->flags & TCF_EM_INVERT;
418 static inline int tcf_em_last_match(struct tcf_ematch *em)
420 return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END;
423 static inline int tcf_em_early_end(struct tcf_ematch *em, int result)
425 if (tcf_em_last_match(em))
426 return 1;
428 if (result == 0 && em->flags & TCF_EM_REL_AND)
429 return 1;
431 if (result != 0 && em->flags & TCF_EM_REL_OR)
432 return 1;
434 return 0;
438 * struct tcf_ematch_tree - ematch tree handle
440 * @hdr: ematch tree header supplied by userspace
441 * @matches: array of ematches
443 struct tcf_ematch_tree {
444 struct tcf_ematch_tree_hdr hdr;
445 struct tcf_ematch * matches;
450 * struct tcf_ematch_ops - ematch module operations
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)
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;
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 *);
484 * tcf_em_tree_match - evaulate an ematch tree
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
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.
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.
497 static inline int tcf_em_tree_match(struct sk_buff *skb,
498 struct tcf_ematch_tree *tree,
499 struct tcf_pkt_info *info)
501 if (tree->hdr.nmatches)
502 return __tcf_em_tree_match(skb, tree, info);
503 else
504 return 1;
507 #define MODULE_ALIAS_TCF_EMATCH(kind) MODULE_ALIAS("ematch-kind-" __stringify(kind))
509 #else /* CONFIG_NET_EMATCH */
511 struct tcf_ematch_tree {
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)
519 #endif /* CONFIG_NET_EMATCH */
521 static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer)
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);
532 return NULL;
535 static inline int tcf_valid_offset(const struct sk_buff *skb,
536 const unsigned char *ptr, const int len)
538 return likely((ptr + len) <= skb_tail_pointer(skb) &&
539 ptr >= skb->head &&
540 (ptr <= (ptr + len)));
543 #ifdef CONFIG_NET_CLS_IND
544 #include <net/net_namespace.h>
546 static inline int
547 tcf_change_indev(struct net *net, struct nlattr *indev_tlv)
549 char indev[IFNAMSIZ];
550 struct net_device *dev;
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;
560 static inline bool
561 tcf_match_indev(struct sk_buff *skb, int ifindex)
563 if (!ifindex)
564 return true;
565 if (!skb->skb_iif)
566 return false;
567 return ifindex == skb->skb_iif;
569 #endif /* CONFIG_NET_CLS_IND */
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);
574 enum tc_block_command {
575 TC_BLOCK_BIND,
576 TC_BLOCK_UNBIND,
579 struct tc_block_offload {
580 enum tc_block_command command;
581 enum tcf_block_binder_type binder_type;
582 struct tcf_block *block;
585 struct tc_cls_common_offload {
586 u32 chain_index;
587 __be16 protocol;
588 u32 prio;
591 static inline void
592 tc_cls_common_offload_init(struct tc_cls_common_offload *cls_common,
593 const struct tcf_proto *tp)
595 cls_common->chain_index = tp->chain->index;
596 cls_common->protocol = tp->protocol;
597 cls_common->prio = tp->prio;
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;
610 struct tc_cls_u32_hnode {
611 u32 handle;
612 u32 prio;
613 unsigned int divisor;
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,
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;
635 static inline bool tc_can_offload(const struct net_device *dev)
637 return dev->features & NETIF_F_HW_TC;
640 static inline bool tc_skip_hw(u32 flags)
642 return (flags & TCA_CLS_FLAGS_SKIP_HW) ? true : false;
645 static inline bool tc_skip_sw(u32 flags)
647 return (flags & TCA_CLS_FLAGS_SKIP_SW) ? true : false;
650 /* SKIP_HW and SKIP_SW are mutually exclusive flags. */
651 static inline bool tc_flags_valid(u32 flags)
653 if (flags & ~(TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW))
654 return false;
656 if (!(flags ^ (TCA_CLS_FLAGS_SKIP_HW | TCA_CLS_FLAGS_SKIP_SW)))
657 return false;
659 return true;
662 static inline bool tc_in_hw(u32 flags)
664 return (flags & TCA_CLS_FLAGS_IN_HW) ? true : false;
667 enum tc_fl_command {
668 TC_CLSFLOWER_REPLACE,
669 TC_CLSFLOWER_DESTROY,
670 TC_CLSFLOWER_STATS,
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;
684 enum tc_matchall_command {
685 TC_CLSMATCHALL_REPLACE,
686 TC_CLSMATCHALL_DESTROY,
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;
696 enum tc_clsbpf_command {
697 TC_CLSBPF_OFFLOAD,
698 TC_CLSBPF_STATS,
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;
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];
722 /* This structure holds cookie structure that is passed from user
723 * to the kernel for actions and classifiers
725 struct tc_cookie {
726 u8 *data;
727 u32 len;
730 enum tc_red_command {
731 TC_RED_REPLACE,
732 TC_RED_DESTROY,
733 TC_RED_STATS,
734 TC_RED_XSTATS,
737 struct tc_red_qopt_offload_params {
738 u32 min;
739 u32 max;
740 u32 probability;
741 bool is_ecn;
743 struct tc_red_qopt_offload_stats {
744 struct gnet_stats_basic_packed *bstats;
745 struct gnet_stats_queue *qstats;
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;
759 #endif