2 * net/sched/cls_flow.c Generic flow classifier
4 * Copyright (c) 2007, 2008 Patrick McHardy <kaber@trash.net>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
12 #include <linux/kernel.h>
13 #include <linux/init.h>
14 #include <linux/list.h>
15 #include <linux/jhash.h>
16 #include <linux/random.h>
17 #include <linux/pkt_cls.h>
18 #include <linux/skbuff.h>
21 #include <linux/ipv6.h>
22 #include <linux/if_vlan.h>
23 #include <linux/slab.h>
24 #include <linux/module.h>
25 #include <net/inet_sock.h>
27 #include <net/pkt_cls.h>
29 #include <net/route.h>
30 #include <net/flow_dissector.h>
32 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
33 #include <net/netfilter/nf_conntrack.h>
37 struct list_head filters
;
42 struct list_head list
;
44 struct tcf_ematch_tree ematches
;
46 struct timer_list perturb_timer
;
63 static inline u32
addr_fold(void *addr
)
65 unsigned long a
= (unsigned long)addr
;
67 return (a
& 0xFFFFFFFF) ^ (BITS_PER_LONG
> 32 ? a
>> 32 : 0);
70 static u32
flow_get_src(const struct sk_buff
*skb
, const struct flow_keys
*flow
)
72 __be32 src
= flow_get_u32_src(flow
);
77 return addr_fold(skb
->sk
);
80 static u32
flow_get_dst(const struct sk_buff
*skb
, const struct flow_keys
*flow
)
82 __be32 dst
= flow_get_u32_dst(flow
);
87 return addr_fold(skb_dst(skb
)) ^ (__force u16
) tc_skb_protocol(skb
);
90 static u32
flow_get_proto(const struct sk_buff
*skb
,
91 const struct flow_keys
*flow
)
93 return flow
->basic
.ip_proto
;
96 static u32
flow_get_proto_src(const struct sk_buff
*skb
,
97 const struct flow_keys
*flow
)
99 if (flow
->ports
.ports
)
100 return ntohs(flow
->ports
.src
);
102 return addr_fold(skb
->sk
);
105 static u32
flow_get_proto_dst(const struct sk_buff
*skb
,
106 const struct flow_keys
*flow
)
108 if (flow
->ports
.ports
)
109 return ntohs(flow
->ports
.dst
);
111 return addr_fold(skb_dst(skb
)) ^ (__force u16
) tc_skb_protocol(skb
);
114 static u32
flow_get_iif(const struct sk_buff
*skb
)
119 static u32
flow_get_priority(const struct sk_buff
*skb
)
121 return skb
->priority
;
124 static u32
flow_get_mark(const struct sk_buff
*skb
)
129 static u32
flow_get_nfct(const struct sk_buff
*skb
)
131 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
132 return addr_fold(skb_nfct(skb
));
138 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
139 #define CTTUPLE(skb, member) \
141 enum ip_conntrack_info ctinfo; \
142 const struct nf_conn *ct = nf_ct_get(skb, &ctinfo); \
145 ct->tuplehash[CTINFO2DIR(ctinfo)].tuple.member; \
148 #define CTTUPLE(skb, member) \
155 static u32
flow_get_nfct_src(const struct sk_buff
*skb
,
156 const struct flow_keys
*flow
)
158 switch (tc_skb_protocol(skb
)) {
159 case htons(ETH_P_IP
):
160 return ntohl(CTTUPLE(skb
, src
.u3
.ip
));
161 case htons(ETH_P_IPV6
):
162 return ntohl(CTTUPLE(skb
, src
.u3
.ip6
[3]));
165 return flow_get_src(skb
, flow
);
168 static u32
flow_get_nfct_dst(const struct sk_buff
*skb
,
169 const struct flow_keys
*flow
)
171 switch (tc_skb_protocol(skb
)) {
172 case htons(ETH_P_IP
):
173 return ntohl(CTTUPLE(skb
, dst
.u3
.ip
));
174 case htons(ETH_P_IPV6
):
175 return ntohl(CTTUPLE(skb
, dst
.u3
.ip6
[3]));
178 return flow_get_dst(skb
, flow
);
181 static u32
flow_get_nfct_proto_src(const struct sk_buff
*skb
,
182 const struct flow_keys
*flow
)
184 return ntohs(CTTUPLE(skb
, src
.u
.all
));
186 return flow_get_proto_src(skb
, flow
);
189 static u32
flow_get_nfct_proto_dst(const struct sk_buff
*skb
,
190 const struct flow_keys
*flow
)
192 return ntohs(CTTUPLE(skb
, dst
.u
.all
));
194 return flow_get_proto_dst(skb
, flow
);
197 static u32
flow_get_rtclassid(const struct sk_buff
*skb
)
199 #ifdef CONFIG_IP_ROUTE_CLASSID
201 return skb_dst(skb
)->tclassid
;
206 static u32
flow_get_skuid(const struct sk_buff
*skb
)
208 struct sock
*sk
= skb_to_full_sk(skb
);
210 if (sk
&& sk
->sk_socket
&& sk
->sk_socket
->file
) {
211 kuid_t skuid
= sk
->sk_socket
->file
->f_cred
->fsuid
;
213 return from_kuid(&init_user_ns
, skuid
);
218 static u32
flow_get_skgid(const struct sk_buff
*skb
)
220 struct sock
*sk
= skb_to_full_sk(skb
);
222 if (sk
&& sk
->sk_socket
&& sk
->sk_socket
->file
) {
223 kgid_t skgid
= sk
->sk_socket
->file
->f_cred
->fsgid
;
225 return from_kgid(&init_user_ns
, skgid
);
230 static u32
flow_get_vlan_tag(const struct sk_buff
*skb
)
232 u16
uninitialized_var(tag
);
234 if (vlan_get_tag(skb
, &tag
) < 0)
236 return tag
& VLAN_VID_MASK
;
239 static u32
flow_get_rxhash(struct sk_buff
*skb
)
241 return skb_get_hash(skb
);
244 static u32
flow_key_get(struct sk_buff
*skb
, int key
, struct flow_keys
*flow
)
248 return flow_get_src(skb
, flow
);
250 return flow_get_dst(skb
, flow
);
252 return flow_get_proto(skb
, flow
);
253 case FLOW_KEY_PROTO_SRC
:
254 return flow_get_proto_src(skb
, flow
);
255 case FLOW_KEY_PROTO_DST
:
256 return flow_get_proto_dst(skb
, flow
);
258 return flow_get_iif(skb
);
259 case FLOW_KEY_PRIORITY
:
260 return flow_get_priority(skb
);
262 return flow_get_mark(skb
);
264 return flow_get_nfct(skb
);
265 case FLOW_KEY_NFCT_SRC
:
266 return flow_get_nfct_src(skb
, flow
);
267 case FLOW_KEY_NFCT_DST
:
268 return flow_get_nfct_dst(skb
, flow
);
269 case FLOW_KEY_NFCT_PROTO_SRC
:
270 return flow_get_nfct_proto_src(skb
, flow
);
271 case FLOW_KEY_NFCT_PROTO_DST
:
272 return flow_get_nfct_proto_dst(skb
, flow
);
273 case FLOW_KEY_RTCLASSID
:
274 return flow_get_rtclassid(skb
);
276 return flow_get_skuid(skb
);
278 return flow_get_skgid(skb
);
279 case FLOW_KEY_VLAN_TAG
:
280 return flow_get_vlan_tag(skb
);
281 case FLOW_KEY_RXHASH
:
282 return flow_get_rxhash(skb
);
289 #define FLOW_KEYS_NEEDED ((1 << FLOW_KEY_SRC) | \
290 (1 << FLOW_KEY_DST) | \
291 (1 << FLOW_KEY_PROTO) | \
292 (1 << FLOW_KEY_PROTO_SRC) | \
293 (1 << FLOW_KEY_PROTO_DST) | \
294 (1 << FLOW_KEY_NFCT_SRC) | \
295 (1 << FLOW_KEY_NFCT_DST) | \
296 (1 << FLOW_KEY_NFCT_PROTO_SRC) | \
297 (1 << FLOW_KEY_NFCT_PROTO_DST))
299 static int flow_classify(struct sk_buff
*skb
, const struct tcf_proto
*tp
,
300 struct tcf_result
*res
)
302 struct flow_head
*head
= rcu_dereference_bh(tp
->root
);
303 struct flow_filter
*f
;
309 list_for_each_entry_rcu(f
, &head
->filters
, list
) {
310 u32 keys
[FLOW_KEY_MAX
+ 1];
311 struct flow_keys flow_keys
;
313 if (!tcf_em_tree_match(skb
, &f
->ematches
, NULL
))
316 keymask
= f
->keymask
;
317 if (keymask
& FLOW_KEYS_NEEDED
)
318 skb_flow_dissect_flow_keys(skb
, &flow_keys
, 0);
320 for (n
= 0; n
< f
->nkeys
; n
++) {
321 key
= ffs(keymask
) - 1;
322 keymask
&= ~(1 << key
);
323 keys
[n
] = flow_key_get(skb
, key
, &flow_keys
);
326 if (f
->mode
== FLOW_MODE_HASH
)
327 classid
= jhash2(keys
, f
->nkeys
, f
->hashrnd
);
330 classid
= (classid
& f
->mask
) ^ f
->xor;
331 classid
= (classid
>> f
->rshift
) + f
->addend
;
335 classid
%= f
->divisor
;
338 res
->classid
= TC_H_MAKE(f
->baseclass
, f
->baseclass
+ classid
);
340 r
= tcf_exts_exec(skb
, &f
->exts
, res
);
348 static void flow_perturbation(unsigned long arg
)
350 struct flow_filter
*f
= (struct flow_filter
*)arg
;
352 get_random_bytes(&f
->hashrnd
, 4);
353 if (f
->perturb_period
)
354 mod_timer(&f
->perturb_timer
, jiffies
+ f
->perturb_period
);
357 static const struct nla_policy flow_policy
[TCA_FLOW_MAX
+ 1] = {
358 [TCA_FLOW_KEYS
] = { .type
= NLA_U32
},
359 [TCA_FLOW_MODE
] = { .type
= NLA_U32
},
360 [TCA_FLOW_BASECLASS
] = { .type
= NLA_U32
},
361 [TCA_FLOW_RSHIFT
] = { .type
= NLA_U32
},
362 [TCA_FLOW_ADDEND
] = { .type
= NLA_U32
},
363 [TCA_FLOW_MASK
] = { .type
= NLA_U32
},
364 [TCA_FLOW_XOR
] = { .type
= NLA_U32
},
365 [TCA_FLOW_DIVISOR
] = { .type
= NLA_U32
},
366 [TCA_FLOW_ACT
] = { .type
= NLA_NESTED
},
367 [TCA_FLOW_POLICE
] = { .type
= NLA_NESTED
},
368 [TCA_FLOW_EMATCHES
] = { .type
= NLA_NESTED
},
369 [TCA_FLOW_PERTURB
] = { .type
= NLA_U32
},
372 static void flow_destroy_filter(struct rcu_head
*head
)
374 struct flow_filter
*f
= container_of(head
, struct flow_filter
, rcu
);
376 del_timer_sync(&f
->perturb_timer
);
377 tcf_exts_destroy(&f
->exts
);
378 tcf_em_tree_destroy(&f
->ematches
);
382 static int flow_change(struct net
*net
, struct sk_buff
*in_skb
,
383 struct tcf_proto
*tp
, unsigned long base
,
384 u32 handle
, struct nlattr
**tca
,
385 unsigned long *arg
, bool ovr
)
387 struct flow_head
*head
= rtnl_dereference(tp
->root
);
388 struct flow_filter
*fold
, *fnew
;
389 struct nlattr
*opt
= tca
[TCA_OPTIONS
];
390 struct nlattr
*tb
[TCA_FLOW_MAX
+ 1];
392 struct tcf_ematch_tree t
;
393 unsigned int nkeys
= 0;
394 unsigned int perturb_period
= 0;
403 err
= nla_parse_nested(tb
, TCA_FLOW_MAX
, opt
, flow_policy
, NULL
);
407 if (tb
[TCA_FLOW_BASECLASS
]) {
408 baseclass
= nla_get_u32(tb
[TCA_FLOW_BASECLASS
]);
409 if (TC_H_MIN(baseclass
) == 0)
413 if (tb
[TCA_FLOW_KEYS
]) {
414 keymask
= nla_get_u32(tb
[TCA_FLOW_KEYS
]);
416 nkeys
= hweight32(keymask
);
420 if (fls(keymask
) - 1 > FLOW_KEY_MAX
)
423 if ((keymask
& (FLOW_KEY_SKUID
|FLOW_KEY_SKGID
)) &&
424 sk_user_ns(NETLINK_CB(in_skb
).sk
) != &init_user_ns
)
428 err
= tcf_exts_init(&e
, TCA_FLOW_ACT
, TCA_FLOW_POLICE
);
431 err
= tcf_exts_validate(net
, tp
, tb
, tca
[TCA_RATE
], &e
, ovr
);
435 err
= tcf_em_tree_validate(tp
, tb
[TCA_FLOW_EMATCHES
], &t
);
440 fnew
= kzalloc(sizeof(*fnew
), GFP_KERNEL
);
444 err
= tcf_exts_init(&fnew
->exts
, TCA_FLOW_ACT
, TCA_FLOW_POLICE
);
448 fold
= (struct flow_filter
*)*arg
;
451 if (fold
->handle
!= handle
&& handle
)
454 /* Copy fold into fnew */
456 fnew
->handle
= fold
->handle
;
457 fnew
->nkeys
= fold
->nkeys
;
458 fnew
->keymask
= fold
->keymask
;
459 fnew
->mode
= fold
->mode
;
460 fnew
->mask
= fold
->mask
;
461 fnew
->xor = fold
->xor;
462 fnew
->rshift
= fold
->rshift
;
463 fnew
->addend
= fold
->addend
;
464 fnew
->divisor
= fold
->divisor
;
465 fnew
->baseclass
= fold
->baseclass
;
466 fnew
->hashrnd
= fold
->hashrnd
;
469 if (tb
[TCA_FLOW_MODE
])
470 mode
= nla_get_u32(tb
[TCA_FLOW_MODE
]);
471 if (mode
!= FLOW_MODE_HASH
&& nkeys
> 1)
474 if (mode
== FLOW_MODE_HASH
)
475 perturb_period
= fold
->perturb_period
;
476 if (tb
[TCA_FLOW_PERTURB
]) {
477 if (mode
!= FLOW_MODE_HASH
)
479 perturb_period
= nla_get_u32(tb
[TCA_FLOW_PERTURB
]) * HZ
;
485 if (!tb
[TCA_FLOW_KEYS
])
488 mode
= FLOW_MODE_MAP
;
489 if (tb
[TCA_FLOW_MODE
])
490 mode
= nla_get_u32(tb
[TCA_FLOW_MODE
]);
491 if (mode
!= FLOW_MODE_HASH
&& nkeys
> 1)
494 if (tb
[TCA_FLOW_PERTURB
]) {
495 if (mode
!= FLOW_MODE_HASH
)
497 perturb_period
= nla_get_u32(tb
[TCA_FLOW_PERTURB
]) * HZ
;
500 if (TC_H_MAJ(baseclass
) == 0)
501 baseclass
= TC_H_MAKE(tp
->q
->handle
, baseclass
);
502 if (TC_H_MIN(baseclass
) == 0)
503 baseclass
= TC_H_MAKE(baseclass
, 1);
505 fnew
->handle
= handle
;
508 get_random_bytes(&fnew
->hashrnd
, 4);
511 setup_deferrable_timer(&fnew
->perturb_timer
, flow_perturbation
,
512 (unsigned long)fnew
);
514 tcf_exts_change(tp
, &fnew
->exts
, &e
);
515 tcf_em_tree_change(tp
, &fnew
->ematches
, &t
);
517 netif_keep_dst(qdisc_dev(tp
->q
));
519 if (tb
[TCA_FLOW_KEYS
]) {
520 fnew
->keymask
= keymask
;
526 if (tb
[TCA_FLOW_MASK
])
527 fnew
->mask
= nla_get_u32(tb
[TCA_FLOW_MASK
]);
528 if (tb
[TCA_FLOW_XOR
])
529 fnew
->xor = nla_get_u32(tb
[TCA_FLOW_XOR
]);
530 if (tb
[TCA_FLOW_RSHIFT
])
531 fnew
->rshift
= nla_get_u32(tb
[TCA_FLOW_RSHIFT
]);
532 if (tb
[TCA_FLOW_ADDEND
])
533 fnew
->addend
= nla_get_u32(tb
[TCA_FLOW_ADDEND
]);
535 if (tb
[TCA_FLOW_DIVISOR
])
536 fnew
->divisor
= nla_get_u32(tb
[TCA_FLOW_DIVISOR
]);
538 fnew
->baseclass
= baseclass
;
540 fnew
->perturb_period
= perturb_period
;
542 mod_timer(&fnew
->perturb_timer
, jiffies
+ perturb_period
);
545 list_add_tail_rcu(&fnew
->list
, &head
->filters
);
547 list_replace_rcu(&fold
->list
, &fnew
->list
);
549 *arg
= (unsigned long)fnew
;
552 call_rcu(&fold
->rcu
, flow_destroy_filter
);
556 tcf_exts_destroy(&fnew
->exts
);
558 tcf_em_tree_destroy(&t
);
561 tcf_exts_destroy(&e
);
565 static int flow_delete(struct tcf_proto
*tp
, unsigned long arg
, bool *last
)
567 struct flow_head
*head
= rtnl_dereference(tp
->root
);
568 struct flow_filter
*f
= (struct flow_filter
*)arg
;
570 list_del_rcu(&f
->list
);
571 call_rcu(&f
->rcu
, flow_destroy_filter
);
572 *last
= list_empty(&head
->filters
);
576 static int flow_init(struct tcf_proto
*tp
)
578 struct flow_head
*head
;
580 head
= kzalloc(sizeof(*head
), GFP_KERNEL
);
583 INIT_LIST_HEAD(&head
->filters
);
584 rcu_assign_pointer(tp
->root
, head
);
588 static void flow_destroy(struct tcf_proto
*tp
)
590 struct flow_head
*head
= rtnl_dereference(tp
->root
);
591 struct flow_filter
*f
, *next
;
593 list_for_each_entry_safe(f
, next
, &head
->filters
, list
) {
594 list_del_rcu(&f
->list
);
595 call_rcu(&f
->rcu
, flow_destroy_filter
);
597 kfree_rcu(head
, rcu
);
600 static unsigned long flow_get(struct tcf_proto
*tp
, u32 handle
)
602 struct flow_head
*head
= rtnl_dereference(tp
->root
);
603 struct flow_filter
*f
;
605 list_for_each_entry(f
, &head
->filters
, list
)
606 if (f
->handle
== handle
)
607 return (unsigned long)f
;
611 static int flow_dump(struct net
*net
, struct tcf_proto
*tp
, unsigned long fh
,
612 struct sk_buff
*skb
, struct tcmsg
*t
)
614 struct flow_filter
*f
= (struct flow_filter
*)fh
;
620 t
->tcm_handle
= f
->handle
;
622 nest
= nla_nest_start(skb
, TCA_OPTIONS
);
624 goto nla_put_failure
;
626 if (nla_put_u32(skb
, TCA_FLOW_KEYS
, f
->keymask
) ||
627 nla_put_u32(skb
, TCA_FLOW_MODE
, f
->mode
))
628 goto nla_put_failure
;
630 if (f
->mask
!= ~0 || f
->xor != 0) {
631 if (nla_put_u32(skb
, TCA_FLOW_MASK
, f
->mask
) ||
632 nla_put_u32(skb
, TCA_FLOW_XOR
, f
->xor))
633 goto nla_put_failure
;
636 nla_put_u32(skb
, TCA_FLOW_RSHIFT
, f
->rshift
))
637 goto nla_put_failure
;
639 nla_put_u32(skb
, TCA_FLOW_ADDEND
, f
->addend
))
640 goto nla_put_failure
;
643 nla_put_u32(skb
, TCA_FLOW_DIVISOR
, f
->divisor
))
644 goto nla_put_failure
;
646 nla_put_u32(skb
, TCA_FLOW_BASECLASS
, f
->baseclass
))
647 goto nla_put_failure
;
649 if (f
->perturb_period
&&
650 nla_put_u32(skb
, TCA_FLOW_PERTURB
, f
->perturb_period
/ HZ
))
651 goto nla_put_failure
;
653 if (tcf_exts_dump(skb
, &f
->exts
) < 0)
654 goto nla_put_failure
;
655 #ifdef CONFIG_NET_EMATCH
656 if (f
->ematches
.hdr
.nmatches
&&
657 tcf_em_tree_dump(skb
, &f
->ematches
, TCA_FLOW_EMATCHES
) < 0)
658 goto nla_put_failure
;
660 nla_nest_end(skb
, nest
);
662 if (tcf_exts_dump_stats(skb
, &f
->exts
) < 0)
663 goto nla_put_failure
;
668 nla_nest_cancel(skb
, nest
);
672 static void flow_walk(struct tcf_proto
*tp
, struct tcf_walker
*arg
)
674 struct flow_head
*head
= rtnl_dereference(tp
->root
);
675 struct flow_filter
*f
;
677 list_for_each_entry(f
, &head
->filters
, list
) {
678 if (arg
->count
< arg
->skip
)
680 if (arg
->fn(tp
, (unsigned long)f
, arg
) < 0) {
689 static struct tcf_proto_ops cls_flow_ops __read_mostly
= {
691 .classify
= flow_classify
,
693 .destroy
= flow_destroy
,
694 .change
= flow_change
,
695 .delete = flow_delete
,
699 .owner
= THIS_MODULE
,
702 static int __init
cls_flow_init(void)
704 return register_tcf_proto_ops(&cls_flow_ops
);
707 static void __exit
cls_flow_exit(void)
709 unregister_tcf_proto_ops(&cls_flow_ops
);
712 module_init(cls_flow_init
);
713 module_exit(cls_flow_exit
);
715 MODULE_LICENSE("GPL");
716 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
717 MODULE_DESCRIPTION("TC flow classifier");