2 * net/sched/cls_flower.c Flower classifier
4 * Copyright (c) 2015 Jiri Pirko <jiri@resnulli.us>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
12 #include <linux/kernel.h>
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/rhashtable.h>
16 #include <linux/workqueue.h>
18 #include <linux/if_ether.h>
19 #include <linux/in6.h>
21 #include <linux/mpls.h>
23 #include <net/sch_generic.h>
24 #include <net/pkt_cls.h>
26 #include <net/flow_dissector.h>
29 #include <net/dst_metadata.h>
33 struct flow_dissector_key_control control
;
34 struct flow_dissector_key_control enc_control
;
35 struct flow_dissector_key_basic basic
;
36 struct flow_dissector_key_eth_addrs eth
;
37 struct flow_dissector_key_vlan vlan
;
38 struct flow_dissector_key_vlan cvlan
;
40 struct flow_dissector_key_ipv4_addrs ipv4
;
41 struct flow_dissector_key_ipv6_addrs ipv6
;
43 struct flow_dissector_key_ports tp
;
44 struct flow_dissector_key_icmp icmp
;
45 struct flow_dissector_key_arp arp
;
46 struct flow_dissector_key_keyid enc_key_id
;
48 struct flow_dissector_key_ipv4_addrs enc_ipv4
;
49 struct flow_dissector_key_ipv6_addrs enc_ipv6
;
51 struct flow_dissector_key_ports enc_tp
;
52 struct flow_dissector_key_mpls mpls
;
53 struct flow_dissector_key_tcp tcp
;
54 struct flow_dissector_key_ip ip
;
55 struct flow_dissector_key_ip enc_ip
;
56 } __aligned(BITS_PER_LONG
/ 8); /* Ensure that we can do comparisons as longs. */
58 struct fl_flow_mask_range
{
59 unsigned short int start
;
60 unsigned short int end
;
64 struct fl_flow_key key
;
65 struct fl_flow_mask_range range
;
66 struct rhash_head ht_node
;
68 struct rhashtable_params filter_ht_params
;
69 struct flow_dissector dissector
;
70 struct list_head filters
;
71 struct rcu_work rwork
;
72 struct list_head list
;
77 struct list_head masks
;
78 struct rcu_work rwork
;
79 struct idr handle_idr
;
82 struct cls_fl_filter
{
83 struct fl_flow_mask
*mask
;
84 struct rhash_head ht_node
;
85 struct fl_flow_key mkey
;
87 struct tcf_result res
;
88 struct fl_flow_key key
;
89 struct list_head list
;
92 unsigned int in_hw_count
;
93 struct rcu_work rwork
;
94 struct net_device
*hw_dev
;
97 static const struct rhashtable_params mask_ht_params
= {
98 .key_offset
= offsetof(struct fl_flow_mask
, key
),
99 .key_len
= sizeof(struct fl_flow_key
),
100 .head_offset
= offsetof(struct fl_flow_mask
, ht_node
),
101 .automatic_shrinking
= true,
104 static unsigned short int fl_mask_range(const struct fl_flow_mask
*mask
)
106 return mask
->range
.end
- mask
->range
.start
;
109 static void fl_mask_update_range(struct fl_flow_mask
*mask
)
111 const u8
*bytes
= (const u8
*) &mask
->key
;
112 size_t size
= sizeof(mask
->key
);
113 size_t i
, first
= 0, last
;
115 for (i
= 0; i
< size
; i
++) {
122 for (i
= size
- 1; i
!= first
; i
--) {
128 mask
->range
.start
= rounddown(first
, sizeof(long));
129 mask
->range
.end
= roundup(last
+ 1, sizeof(long));
132 static void *fl_key_get_start(struct fl_flow_key
*key
,
133 const struct fl_flow_mask
*mask
)
135 return (u8
*) key
+ mask
->range
.start
;
138 static void fl_set_masked_key(struct fl_flow_key
*mkey
, struct fl_flow_key
*key
,
139 struct fl_flow_mask
*mask
)
141 const long *lkey
= fl_key_get_start(key
, mask
);
142 const long *lmask
= fl_key_get_start(&mask
->key
, mask
);
143 long *lmkey
= fl_key_get_start(mkey
, mask
);
146 for (i
= 0; i
< fl_mask_range(mask
); i
+= sizeof(long))
147 *lmkey
++ = *lkey
++ & *lmask
++;
150 static void fl_clear_masked_range(struct fl_flow_key
*key
,
151 struct fl_flow_mask
*mask
)
153 memset(fl_key_get_start(key
, mask
), 0, fl_mask_range(mask
));
156 static struct cls_fl_filter
*fl_lookup(struct fl_flow_mask
*mask
,
157 struct fl_flow_key
*mkey
)
159 return rhashtable_lookup_fast(&mask
->ht
, fl_key_get_start(mkey
, mask
),
160 mask
->filter_ht_params
);
163 static int fl_classify(struct sk_buff
*skb
, const struct tcf_proto
*tp
,
164 struct tcf_result
*res
)
166 struct cls_fl_head
*head
= rcu_dereference_bh(tp
->root
);
167 struct cls_fl_filter
*f
;
168 struct fl_flow_mask
*mask
;
169 struct fl_flow_key skb_key
;
170 struct fl_flow_key skb_mkey
;
172 list_for_each_entry_rcu(mask
, &head
->masks
, list
) {
173 fl_clear_masked_range(&skb_key
, mask
);
175 skb_key
.indev_ifindex
= skb
->skb_iif
;
176 /* skb_flow_dissect() does not set n_proto in case an unknown
177 * protocol, so do it rather here.
179 skb_key
.basic
.n_proto
= skb
->protocol
;
180 skb_flow_dissect_tunnel_info(skb
, &mask
->dissector
, &skb_key
);
181 skb_flow_dissect(skb
, &mask
->dissector
, &skb_key
, 0);
183 fl_set_masked_key(&skb_mkey
, &skb_key
, mask
);
185 f
= fl_lookup(mask
, &skb_mkey
);
186 if (f
&& !tc_skip_sw(f
->flags
)) {
188 return tcf_exts_exec(skb
, &f
->exts
, res
);
194 static int fl_init(struct tcf_proto
*tp
)
196 struct cls_fl_head
*head
;
198 head
= kzalloc(sizeof(*head
), GFP_KERNEL
);
202 INIT_LIST_HEAD_RCU(&head
->masks
);
203 rcu_assign_pointer(tp
->root
, head
);
204 idr_init(&head
->handle_idr
);
206 return rhashtable_init(&head
->ht
, &mask_ht_params
);
209 static void fl_mask_free(struct fl_flow_mask
*mask
)
211 rhashtable_destroy(&mask
->ht
);
215 static void fl_mask_free_work(struct work_struct
*work
)
217 struct fl_flow_mask
*mask
= container_of(to_rcu_work(work
),
218 struct fl_flow_mask
, rwork
);
223 static bool fl_mask_put(struct cls_fl_head
*head
, struct fl_flow_mask
*mask
,
226 if (!list_empty(&mask
->filters
))
229 rhashtable_remove_fast(&head
->ht
, &mask
->ht_node
, mask_ht_params
);
230 list_del_rcu(&mask
->list
);
232 tcf_queue_work(&mask
->rwork
, fl_mask_free_work
);
239 static void __fl_destroy_filter(struct cls_fl_filter
*f
)
241 tcf_exts_destroy(&f
->exts
);
242 tcf_exts_put_net(&f
->exts
);
246 static void fl_destroy_filter_work(struct work_struct
*work
)
248 struct cls_fl_filter
*f
= container_of(to_rcu_work(work
),
249 struct cls_fl_filter
, rwork
);
252 __fl_destroy_filter(f
);
256 static void fl_hw_destroy_filter(struct tcf_proto
*tp
, struct cls_fl_filter
*f
,
257 struct netlink_ext_ack
*extack
)
259 struct tc_cls_flower_offload cls_flower
= {};
260 struct tcf_block
*block
= tp
->chain
->block
;
262 tc_cls_common_offload_init(&cls_flower
.common
, tp
, f
->flags
, extack
);
263 cls_flower
.command
= TC_CLSFLOWER_DESTROY
;
264 cls_flower
.cookie
= (unsigned long) f
;
266 tc_setup_cb_call(block
, &f
->exts
, TC_SETUP_CLSFLOWER
,
268 tcf_block_offload_dec(block
, &f
->flags
);
271 static int fl_hw_replace_filter(struct tcf_proto
*tp
,
272 struct cls_fl_filter
*f
,
273 struct netlink_ext_ack
*extack
)
275 struct tc_cls_flower_offload cls_flower
= {};
276 struct tcf_block
*block
= tp
->chain
->block
;
277 bool skip_sw
= tc_skip_sw(f
->flags
);
280 tc_cls_common_offload_init(&cls_flower
.common
, tp
, f
->flags
, extack
);
281 cls_flower
.command
= TC_CLSFLOWER_REPLACE
;
282 cls_flower
.cookie
= (unsigned long) f
;
283 cls_flower
.dissector
= &f
->mask
->dissector
;
284 cls_flower
.mask
= &f
->mask
->key
;
285 cls_flower
.key
= &f
->mkey
;
286 cls_flower
.exts
= &f
->exts
;
287 cls_flower
.classid
= f
->res
.classid
;
289 err
= tc_setup_cb_call(block
, &f
->exts
, TC_SETUP_CLSFLOWER
,
290 &cls_flower
, skip_sw
);
292 fl_hw_destroy_filter(tp
, f
, NULL
);
294 } else if (err
> 0) {
295 f
->in_hw_count
= err
;
296 tcf_block_offload_inc(block
, &f
->flags
);
299 if (skip_sw
&& !(f
->flags
& TCA_CLS_FLAGS_IN_HW
))
305 static void fl_hw_update_stats(struct tcf_proto
*tp
, struct cls_fl_filter
*f
)
307 struct tc_cls_flower_offload cls_flower
= {};
308 struct tcf_block
*block
= tp
->chain
->block
;
310 tc_cls_common_offload_init(&cls_flower
.common
, tp
, f
->flags
, NULL
);
311 cls_flower
.command
= TC_CLSFLOWER_STATS
;
312 cls_flower
.cookie
= (unsigned long) f
;
313 cls_flower
.exts
= &f
->exts
;
314 cls_flower
.classid
= f
->res
.classid
;
316 tc_setup_cb_call(block
, &f
->exts
, TC_SETUP_CLSFLOWER
,
320 static bool __fl_delete(struct tcf_proto
*tp
, struct cls_fl_filter
*f
,
321 struct netlink_ext_ack
*extack
)
323 struct cls_fl_head
*head
= rtnl_dereference(tp
->root
);
324 bool async
= tcf_exts_get_net(&f
->exts
);
327 idr_remove(&head
->handle_idr
, f
->handle
);
328 list_del_rcu(&f
->list
);
329 last
= fl_mask_put(head
, f
->mask
, async
);
330 if (!tc_skip_hw(f
->flags
))
331 fl_hw_destroy_filter(tp
, f
, extack
);
332 tcf_unbind_filter(tp
, &f
->res
);
334 tcf_queue_work(&f
->rwork
, fl_destroy_filter_work
);
336 __fl_destroy_filter(f
);
341 static void fl_destroy_sleepable(struct work_struct
*work
)
343 struct cls_fl_head
*head
= container_of(to_rcu_work(work
),
347 rhashtable_destroy(&head
->ht
);
349 module_put(THIS_MODULE
);
352 static void fl_destroy(struct tcf_proto
*tp
, struct netlink_ext_ack
*extack
)
354 struct cls_fl_head
*head
= rtnl_dereference(tp
->root
);
355 struct fl_flow_mask
*mask
, *next_mask
;
356 struct cls_fl_filter
*f
, *next
;
358 list_for_each_entry_safe(mask
, next_mask
, &head
->masks
, list
) {
359 list_for_each_entry_safe(f
, next
, &mask
->filters
, list
) {
360 if (__fl_delete(tp
, f
, extack
))
364 idr_destroy(&head
->handle_idr
);
366 __module_get(THIS_MODULE
);
367 tcf_queue_work(&head
->rwork
, fl_destroy_sleepable
);
370 static void *fl_get(struct tcf_proto
*tp
, u32 handle
)
372 struct cls_fl_head
*head
= rtnl_dereference(tp
->root
);
374 return idr_find(&head
->handle_idr
, handle
);
377 static const struct nla_policy fl_policy
[TCA_FLOWER_MAX
+ 1] = {
378 [TCA_FLOWER_UNSPEC
] = { .type
= NLA_UNSPEC
},
379 [TCA_FLOWER_CLASSID
] = { .type
= NLA_U32
},
380 [TCA_FLOWER_INDEV
] = { .type
= NLA_STRING
,
382 [TCA_FLOWER_KEY_ETH_DST
] = { .len
= ETH_ALEN
},
383 [TCA_FLOWER_KEY_ETH_DST_MASK
] = { .len
= ETH_ALEN
},
384 [TCA_FLOWER_KEY_ETH_SRC
] = { .len
= ETH_ALEN
},
385 [TCA_FLOWER_KEY_ETH_SRC_MASK
] = { .len
= ETH_ALEN
},
386 [TCA_FLOWER_KEY_ETH_TYPE
] = { .type
= NLA_U16
},
387 [TCA_FLOWER_KEY_IP_PROTO
] = { .type
= NLA_U8
},
388 [TCA_FLOWER_KEY_IPV4_SRC
] = { .type
= NLA_U32
},
389 [TCA_FLOWER_KEY_IPV4_SRC_MASK
] = { .type
= NLA_U32
},
390 [TCA_FLOWER_KEY_IPV4_DST
] = { .type
= NLA_U32
},
391 [TCA_FLOWER_KEY_IPV4_DST_MASK
] = { .type
= NLA_U32
},
392 [TCA_FLOWER_KEY_IPV6_SRC
] = { .len
= sizeof(struct in6_addr
) },
393 [TCA_FLOWER_KEY_IPV6_SRC_MASK
] = { .len
= sizeof(struct in6_addr
) },
394 [TCA_FLOWER_KEY_IPV6_DST
] = { .len
= sizeof(struct in6_addr
) },
395 [TCA_FLOWER_KEY_IPV6_DST_MASK
] = { .len
= sizeof(struct in6_addr
) },
396 [TCA_FLOWER_KEY_TCP_SRC
] = { .type
= NLA_U16
},
397 [TCA_FLOWER_KEY_TCP_DST
] = { .type
= NLA_U16
},
398 [TCA_FLOWER_KEY_UDP_SRC
] = { .type
= NLA_U16
},
399 [TCA_FLOWER_KEY_UDP_DST
] = { .type
= NLA_U16
},
400 [TCA_FLOWER_KEY_VLAN_ID
] = { .type
= NLA_U16
},
401 [TCA_FLOWER_KEY_VLAN_PRIO
] = { .type
= NLA_U8
},
402 [TCA_FLOWER_KEY_VLAN_ETH_TYPE
] = { .type
= NLA_U16
},
403 [TCA_FLOWER_KEY_ENC_KEY_ID
] = { .type
= NLA_U32
},
404 [TCA_FLOWER_KEY_ENC_IPV4_SRC
] = { .type
= NLA_U32
},
405 [TCA_FLOWER_KEY_ENC_IPV4_SRC_MASK
] = { .type
= NLA_U32
},
406 [TCA_FLOWER_KEY_ENC_IPV4_DST
] = { .type
= NLA_U32
},
407 [TCA_FLOWER_KEY_ENC_IPV4_DST_MASK
] = { .type
= NLA_U32
},
408 [TCA_FLOWER_KEY_ENC_IPV6_SRC
] = { .len
= sizeof(struct in6_addr
) },
409 [TCA_FLOWER_KEY_ENC_IPV6_SRC_MASK
] = { .len
= sizeof(struct in6_addr
) },
410 [TCA_FLOWER_KEY_ENC_IPV6_DST
] = { .len
= sizeof(struct in6_addr
) },
411 [TCA_FLOWER_KEY_ENC_IPV6_DST_MASK
] = { .len
= sizeof(struct in6_addr
) },
412 [TCA_FLOWER_KEY_TCP_SRC_MASK
] = { .type
= NLA_U16
},
413 [TCA_FLOWER_KEY_TCP_DST_MASK
] = { .type
= NLA_U16
},
414 [TCA_FLOWER_KEY_UDP_SRC_MASK
] = { .type
= NLA_U16
},
415 [TCA_FLOWER_KEY_UDP_DST_MASK
] = { .type
= NLA_U16
},
416 [TCA_FLOWER_KEY_SCTP_SRC_MASK
] = { .type
= NLA_U16
},
417 [TCA_FLOWER_KEY_SCTP_DST_MASK
] = { .type
= NLA_U16
},
418 [TCA_FLOWER_KEY_SCTP_SRC
] = { .type
= NLA_U16
},
419 [TCA_FLOWER_KEY_SCTP_DST
] = { .type
= NLA_U16
},
420 [TCA_FLOWER_KEY_ENC_UDP_SRC_PORT
] = { .type
= NLA_U16
},
421 [TCA_FLOWER_KEY_ENC_UDP_SRC_PORT_MASK
] = { .type
= NLA_U16
},
422 [TCA_FLOWER_KEY_ENC_UDP_DST_PORT
] = { .type
= NLA_U16
},
423 [TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK
] = { .type
= NLA_U16
},
424 [TCA_FLOWER_KEY_FLAGS
] = { .type
= NLA_U32
},
425 [TCA_FLOWER_KEY_FLAGS_MASK
] = { .type
= NLA_U32
},
426 [TCA_FLOWER_KEY_ICMPV4_TYPE
] = { .type
= NLA_U8
},
427 [TCA_FLOWER_KEY_ICMPV4_TYPE_MASK
] = { .type
= NLA_U8
},
428 [TCA_FLOWER_KEY_ICMPV4_CODE
] = { .type
= NLA_U8
},
429 [TCA_FLOWER_KEY_ICMPV4_CODE_MASK
] = { .type
= NLA_U8
},
430 [TCA_FLOWER_KEY_ICMPV6_TYPE
] = { .type
= NLA_U8
},
431 [TCA_FLOWER_KEY_ICMPV6_TYPE_MASK
] = { .type
= NLA_U8
},
432 [TCA_FLOWER_KEY_ICMPV6_CODE
] = { .type
= NLA_U8
},
433 [TCA_FLOWER_KEY_ICMPV6_CODE_MASK
] = { .type
= NLA_U8
},
434 [TCA_FLOWER_KEY_ARP_SIP
] = { .type
= NLA_U32
},
435 [TCA_FLOWER_KEY_ARP_SIP_MASK
] = { .type
= NLA_U32
},
436 [TCA_FLOWER_KEY_ARP_TIP
] = { .type
= NLA_U32
},
437 [TCA_FLOWER_KEY_ARP_TIP_MASK
] = { .type
= NLA_U32
},
438 [TCA_FLOWER_KEY_ARP_OP
] = { .type
= NLA_U8
},
439 [TCA_FLOWER_KEY_ARP_OP_MASK
] = { .type
= NLA_U8
},
440 [TCA_FLOWER_KEY_ARP_SHA
] = { .len
= ETH_ALEN
},
441 [TCA_FLOWER_KEY_ARP_SHA_MASK
] = { .len
= ETH_ALEN
},
442 [TCA_FLOWER_KEY_ARP_THA
] = { .len
= ETH_ALEN
},
443 [TCA_FLOWER_KEY_ARP_THA_MASK
] = { .len
= ETH_ALEN
},
444 [TCA_FLOWER_KEY_MPLS_TTL
] = { .type
= NLA_U8
},
445 [TCA_FLOWER_KEY_MPLS_BOS
] = { .type
= NLA_U8
},
446 [TCA_FLOWER_KEY_MPLS_TC
] = { .type
= NLA_U8
},
447 [TCA_FLOWER_KEY_MPLS_LABEL
] = { .type
= NLA_U32
},
448 [TCA_FLOWER_KEY_TCP_FLAGS
] = { .type
= NLA_U16
},
449 [TCA_FLOWER_KEY_TCP_FLAGS_MASK
] = { .type
= NLA_U16
},
450 [TCA_FLOWER_KEY_IP_TOS
] = { .type
= NLA_U8
},
451 [TCA_FLOWER_KEY_IP_TOS_MASK
] = { .type
= NLA_U8
},
452 [TCA_FLOWER_KEY_IP_TTL
] = { .type
= NLA_U8
},
453 [TCA_FLOWER_KEY_IP_TTL_MASK
] = { .type
= NLA_U8
},
454 [TCA_FLOWER_KEY_CVLAN_ID
] = { .type
= NLA_U16
},
455 [TCA_FLOWER_KEY_CVLAN_PRIO
] = { .type
= NLA_U8
},
456 [TCA_FLOWER_KEY_CVLAN_ETH_TYPE
] = { .type
= NLA_U16
},
457 [TCA_FLOWER_KEY_ENC_IP_TOS
] = { .type
= NLA_U8
},
458 [TCA_FLOWER_KEY_ENC_IP_TOS_MASK
] = { .type
= NLA_U8
},
459 [TCA_FLOWER_KEY_ENC_IP_TTL
] = { .type
= NLA_U8
},
460 [TCA_FLOWER_KEY_ENC_IP_TTL_MASK
] = { .type
= NLA_U8
},
463 static void fl_set_key_val(struct nlattr
**tb
,
464 void *val
, int val_type
,
465 void *mask
, int mask_type
, int len
)
469 memcpy(val
, nla_data(tb
[val_type
]), len
);
470 if (mask_type
== TCA_FLOWER_UNSPEC
|| !tb
[mask_type
])
471 memset(mask
, 0xff, len
);
473 memcpy(mask
, nla_data(tb
[mask_type
]), len
);
476 static int fl_set_key_mpls(struct nlattr
**tb
,
477 struct flow_dissector_key_mpls
*key_val
,
478 struct flow_dissector_key_mpls
*key_mask
)
480 if (tb
[TCA_FLOWER_KEY_MPLS_TTL
]) {
481 key_val
->mpls_ttl
= nla_get_u8(tb
[TCA_FLOWER_KEY_MPLS_TTL
]);
482 key_mask
->mpls_ttl
= MPLS_TTL_MASK
;
484 if (tb
[TCA_FLOWER_KEY_MPLS_BOS
]) {
485 u8 bos
= nla_get_u8(tb
[TCA_FLOWER_KEY_MPLS_BOS
]);
487 if (bos
& ~MPLS_BOS_MASK
)
489 key_val
->mpls_bos
= bos
;
490 key_mask
->mpls_bos
= MPLS_BOS_MASK
;
492 if (tb
[TCA_FLOWER_KEY_MPLS_TC
]) {
493 u8 tc
= nla_get_u8(tb
[TCA_FLOWER_KEY_MPLS_TC
]);
495 if (tc
& ~MPLS_TC_MASK
)
497 key_val
->mpls_tc
= tc
;
498 key_mask
->mpls_tc
= MPLS_TC_MASK
;
500 if (tb
[TCA_FLOWER_KEY_MPLS_LABEL
]) {
501 u32 label
= nla_get_u32(tb
[TCA_FLOWER_KEY_MPLS_LABEL
]);
503 if (label
& ~MPLS_LABEL_MASK
)
505 key_val
->mpls_label
= label
;
506 key_mask
->mpls_label
= MPLS_LABEL_MASK
;
511 static void fl_set_key_vlan(struct nlattr
**tb
,
513 int vlan_id_key
, int vlan_prio_key
,
514 struct flow_dissector_key_vlan
*key_val
,
515 struct flow_dissector_key_vlan
*key_mask
)
517 #define VLAN_PRIORITY_MASK 0x7
519 if (tb
[vlan_id_key
]) {
521 nla_get_u16(tb
[vlan_id_key
]) & VLAN_VID_MASK
;
522 key_mask
->vlan_id
= VLAN_VID_MASK
;
524 if (tb
[vlan_prio_key
]) {
525 key_val
->vlan_priority
=
526 nla_get_u8(tb
[vlan_prio_key
]) &
528 key_mask
->vlan_priority
= VLAN_PRIORITY_MASK
;
530 key_val
->vlan_tpid
= ethertype
;
531 key_mask
->vlan_tpid
= cpu_to_be16(~0);
534 static void fl_set_key_flag(u32 flower_key
, u32 flower_mask
,
535 u32
*dissector_key
, u32
*dissector_mask
,
536 u32 flower_flag_bit
, u32 dissector_flag_bit
)
538 if (flower_mask
& flower_flag_bit
) {
539 *dissector_mask
|= dissector_flag_bit
;
540 if (flower_key
& flower_flag_bit
)
541 *dissector_key
|= dissector_flag_bit
;
545 static int fl_set_key_flags(struct nlattr
**tb
,
546 u32
*flags_key
, u32
*flags_mask
)
550 /* mask is mandatory for flags */
551 if (!tb
[TCA_FLOWER_KEY_FLAGS_MASK
])
554 key
= be32_to_cpu(nla_get_u32(tb
[TCA_FLOWER_KEY_FLAGS
]));
555 mask
= be32_to_cpu(nla_get_u32(tb
[TCA_FLOWER_KEY_FLAGS_MASK
]));
560 fl_set_key_flag(key
, mask
, flags_key
, flags_mask
,
561 TCA_FLOWER_KEY_FLAGS_IS_FRAGMENT
, FLOW_DIS_IS_FRAGMENT
);
562 fl_set_key_flag(key
, mask
, flags_key
, flags_mask
,
563 TCA_FLOWER_KEY_FLAGS_FRAG_IS_FIRST
,
564 FLOW_DIS_FIRST_FRAG
);
569 static void fl_set_key_ip(struct nlattr
**tb
, bool encap
,
570 struct flow_dissector_key_ip
*key
,
571 struct flow_dissector_key_ip
*mask
)
573 int tos_key
= encap
? TCA_FLOWER_KEY_ENC_IP_TOS
: TCA_FLOWER_KEY_IP_TOS
;
574 int ttl_key
= encap
? TCA_FLOWER_KEY_ENC_IP_TTL
: TCA_FLOWER_KEY_IP_TTL
;
575 int tos_mask
= encap
? TCA_FLOWER_KEY_ENC_IP_TOS_MASK
: TCA_FLOWER_KEY_IP_TOS_MASK
;
576 int ttl_mask
= encap
? TCA_FLOWER_KEY_ENC_IP_TTL_MASK
: TCA_FLOWER_KEY_IP_TTL_MASK
;
578 fl_set_key_val(tb
, &key
->tos
, tos_key
, &mask
->tos
, tos_mask
, sizeof(key
->tos
));
579 fl_set_key_val(tb
, &key
->ttl
, ttl_key
, &mask
->ttl
, ttl_mask
, sizeof(key
->ttl
));
582 static int fl_set_key(struct net
*net
, struct nlattr
**tb
,
583 struct fl_flow_key
*key
, struct fl_flow_key
*mask
,
584 struct netlink_ext_ack
*extack
)
588 #ifdef CONFIG_NET_CLS_IND
589 if (tb
[TCA_FLOWER_INDEV
]) {
590 int err
= tcf_change_indev(net
, tb
[TCA_FLOWER_INDEV
], extack
);
593 key
->indev_ifindex
= err
;
594 mask
->indev_ifindex
= 0xffffffff;
598 fl_set_key_val(tb
, key
->eth
.dst
, TCA_FLOWER_KEY_ETH_DST
,
599 mask
->eth
.dst
, TCA_FLOWER_KEY_ETH_DST_MASK
,
600 sizeof(key
->eth
.dst
));
601 fl_set_key_val(tb
, key
->eth
.src
, TCA_FLOWER_KEY_ETH_SRC
,
602 mask
->eth
.src
, TCA_FLOWER_KEY_ETH_SRC_MASK
,
603 sizeof(key
->eth
.src
));
605 if (tb
[TCA_FLOWER_KEY_ETH_TYPE
]) {
606 ethertype
= nla_get_be16(tb
[TCA_FLOWER_KEY_ETH_TYPE
]);
608 if (eth_type_vlan(ethertype
)) {
609 fl_set_key_vlan(tb
, ethertype
, TCA_FLOWER_KEY_VLAN_ID
,
610 TCA_FLOWER_KEY_VLAN_PRIO
, &key
->vlan
,
613 if (tb
[TCA_FLOWER_KEY_VLAN_ETH_TYPE
]) {
614 ethertype
= nla_get_be16(tb
[TCA_FLOWER_KEY_VLAN_ETH_TYPE
]);
615 if (eth_type_vlan(ethertype
)) {
616 fl_set_key_vlan(tb
, ethertype
,
617 TCA_FLOWER_KEY_CVLAN_ID
,
618 TCA_FLOWER_KEY_CVLAN_PRIO
,
619 &key
->cvlan
, &mask
->cvlan
);
620 fl_set_key_val(tb
, &key
->basic
.n_proto
,
621 TCA_FLOWER_KEY_CVLAN_ETH_TYPE
,
622 &mask
->basic
.n_proto
,
624 sizeof(key
->basic
.n_proto
));
626 key
->basic
.n_proto
= ethertype
;
627 mask
->basic
.n_proto
= cpu_to_be16(~0);
631 key
->basic
.n_proto
= ethertype
;
632 mask
->basic
.n_proto
= cpu_to_be16(~0);
636 if (key
->basic
.n_proto
== htons(ETH_P_IP
) ||
637 key
->basic
.n_proto
== htons(ETH_P_IPV6
)) {
638 fl_set_key_val(tb
, &key
->basic
.ip_proto
, TCA_FLOWER_KEY_IP_PROTO
,
639 &mask
->basic
.ip_proto
, TCA_FLOWER_UNSPEC
,
640 sizeof(key
->basic
.ip_proto
));
641 fl_set_key_ip(tb
, false, &key
->ip
, &mask
->ip
);
644 if (tb
[TCA_FLOWER_KEY_IPV4_SRC
] || tb
[TCA_FLOWER_KEY_IPV4_DST
]) {
645 key
->control
.addr_type
= FLOW_DISSECTOR_KEY_IPV4_ADDRS
;
646 mask
->control
.addr_type
= ~0;
647 fl_set_key_val(tb
, &key
->ipv4
.src
, TCA_FLOWER_KEY_IPV4_SRC
,
648 &mask
->ipv4
.src
, TCA_FLOWER_KEY_IPV4_SRC_MASK
,
649 sizeof(key
->ipv4
.src
));
650 fl_set_key_val(tb
, &key
->ipv4
.dst
, TCA_FLOWER_KEY_IPV4_DST
,
651 &mask
->ipv4
.dst
, TCA_FLOWER_KEY_IPV4_DST_MASK
,
652 sizeof(key
->ipv4
.dst
));
653 } else if (tb
[TCA_FLOWER_KEY_IPV6_SRC
] || tb
[TCA_FLOWER_KEY_IPV6_DST
]) {
654 key
->control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
655 mask
->control
.addr_type
= ~0;
656 fl_set_key_val(tb
, &key
->ipv6
.src
, TCA_FLOWER_KEY_IPV6_SRC
,
657 &mask
->ipv6
.src
, TCA_FLOWER_KEY_IPV6_SRC_MASK
,
658 sizeof(key
->ipv6
.src
));
659 fl_set_key_val(tb
, &key
->ipv6
.dst
, TCA_FLOWER_KEY_IPV6_DST
,
660 &mask
->ipv6
.dst
, TCA_FLOWER_KEY_IPV6_DST_MASK
,
661 sizeof(key
->ipv6
.dst
));
664 if (key
->basic
.ip_proto
== IPPROTO_TCP
) {
665 fl_set_key_val(tb
, &key
->tp
.src
, TCA_FLOWER_KEY_TCP_SRC
,
666 &mask
->tp
.src
, TCA_FLOWER_KEY_TCP_SRC_MASK
,
667 sizeof(key
->tp
.src
));
668 fl_set_key_val(tb
, &key
->tp
.dst
, TCA_FLOWER_KEY_TCP_DST
,
669 &mask
->tp
.dst
, TCA_FLOWER_KEY_TCP_DST_MASK
,
670 sizeof(key
->tp
.dst
));
671 fl_set_key_val(tb
, &key
->tcp
.flags
, TCA_FLOWER_KEY_TCP_FLAGS
,
672 &mask
->tcp
.flags
, TCA_FLOWER_KEY_TCP_FLAGS_MASK
,
673 sizeof(key
->tcp
.flags
));
674 } else if (key
->basic
.ip_proto
== IPPROTO_UDP
) {
675 fl_set_key_val(tb
, &key
->tp
.src
, TCA_FLOWER_KEY_UDP_SRC
,
676 &mask
->tp
.src
, TCA_FLOWER_KEY_UDP_SRC_MASK
,
677 sizeof(key
->tp
.src
));
678 fl_set_key_val(tb
, &key
->tp
.dst
, TCA_FLOWER_KEY_UDP_DST
,
679 &mask
->tp
.dst
, TCA_FLOWER_KEY_UDP_DST_MASK
,
680 sizeof(key
->tp
.dst
));
681 } else if (key
->basic
.ip_proto
== IPPROTO_SCTP
) {
682 fl_set_key_val(tb
, &key
->tp
.src
, TCA_FLOWER_KEY_SCTP_SRC
,
683 &mask
->tp
.src
, TCA_FLOWER_KEY_SCTP_SRC_MASK
,
684 sizeof(key
->tp
.src
));
685 fl_set_key_val(tb
, &key
->tp
.dst
, TCA_FLOWER_KEY_SCTP_DST
,
686 &mask
->tp
.dst
, TCA_FLOWER_KEY_SCTP_DST_MASK
,
687 sizeof(key
->tp
.dst
));
688 } else if (key
->basic
.n_proto
== htons(ETH_P_IP
) &&
689 key
->basic
.ip_proto
== IPPROTO_ICMP
) {
690 fl_set_key_val(tb
, &key
->icmp
.type
, TCA_FLOWER_KEY_ICMPV4_TYPE
,
692 TCA_FLOWER_KEY_ICMPV4_TYPE_MASK
,
693 sizeof(key
->icmp
.type
));
694 fl_set_key_val(tb
, &key
->icmp
.code
, TCA_FLOWER_KEY_ICMPV4_CODE
,
696 TCA_FLOWER_KEY_ICMPV4_CODE_MASK
,
697 sizeof(key
->icmp
.code
));
698 } else if (key
->basic
.n_proto
== htons(ETH_P_IPV6
) &&
699 key
->basic
.ip_proto
== IPPROTO_ICMPV6
) {
700 fl_set_key_val(tb
, &key
->icmp
.type
, TCA_FLOWER_KEY_ICMPV6_TYPE
,
702 TCA_FLOWER_KEY_ICMPV6_TYPE_MASK
,
703 sizeof(key
->icmp
.type
));
704 fl_set_key_val(tb
, &key
->icmp
.code
, TCA_FLOWER_KEY_ICMPV6_CODE
,
706 TCA_FLOWER_KEY_ICMPV6_CODE_MASK
,
707 sizeof(key
->icmp
.code
));
708 } else if (key
->basic
.n_proto
== htons(ETH_P_MPLS_UC
) ||
709 key
->basic
.n_proto
== htons(ETH_P_MPLS_MC
)) {
710 ret
= fl_set_key_mpls(tb
, &key
->mpls
, &mask
->mpls
);
713 } else if (key
->basic
.n_proto
== htons(ETH_P_ARP
) ||
714 key
->basic
.n_proto
== htons(ETH_P_RARP
)) {
715 fl_set_key_val(tb
, &key
->arp
.sip
, TCA_FLOWER_KEY_ARP_SIP
,
716 &mask
->arp
.sip
, TCA_FLOWER_KEY_ARP_SIP_MASK
,
717 sizeof(key
->arp
.sip
));
718 fl_set_key_val(tb
, &key
->arp
.tip
, TCA_FLOWER_KEY_ARP_TIP
,
719 &mask
->arp
.tip
, TCA_FLOWER_KEY_ARP_TIP_MASK
,
720 sizeof(key
->arp
.tip
));
721 fl_set_key_val(tb
, &key
->arp
.op
, TCA_FLOWER_KEY_ARP_OP
,
722 &mask
->arp
.op
, TCA_FLOWER_KEY_ARP_OP_MASK
,
723 sizeof(key
->arp
.op
));
724 fl_set_key_val(tb
, key
->arp
.sha
, TCA_FLOWER_KEY_ARP_SHA
,
725 mask
->arp
.sha
, TCA_FLOWER_KEY_ARP_SHA_MASK
,
726 sizeof(key
->arp
.sha
));
727 fl_set_key_val(tb
, key
->arp
.tha
, TCA_FLOWER_KEY_ARP_THA
,
728 mask
->arp
.tha
, TCA_FLOWER_KEY_ARP_THA_MASK
,
729 sizeof(key
->arp
.tha
));
732 if (tb
[TCA_FLOWER_KEY_ENC_IPV4_SRC
] ||
733 tb
[TCA_FLOWER_KEY_ENC_IPV4_DST
]) {
734 key
->enc_control
.addr_type
= FLOW_DISSECTOR_KEY_IPV4_ADDRS
;
735 mask
->enc_control
.addr_type
= ~0;
736 fl_set_key_val(tb
, &key
->enc_ipv4
.src
,
737 TCA_FLOWER_KEY_ENC_IPV4_SRC
,
739 TCA_FLOWER_KEY_ENC_IPV4_SRC_MASK
,
740 sizeof(key
->enc_ipv4
.src
));
741 fl_set_key_val(tb
, &key
->enc_ipv4
.dst
,
742 TCA_FLOWER_KEY_ENC_IPV4_DST
,
744 TCA_FLOWER_KEY_ENC_IPV4_DST_MASK
,
745 sizeof(key
->enc_ipv4
.dst
));
748 if (tb
[TCA_FLOWER_KEY_ENC_IPV6_SRC
] ||
749 tb
[TCA_FLOWER_KEY_ENC_IPV6_DST
]) {
750 key
->enc_control
.addr_type
= FLOW_DISSECTOR_KEY_IPV6_ADDRS
;
751 mask
->enc_control
.addr_type
= ~0;
752 fl_set_key_val(tb
, &key
->enc_ipv6
.src
,
753 TCA_FLOWER_KEY_ENC_IPV6_SRC
,
755 TCA_FLOWER_KEY_ENC_IPV6_SRC_MASK
,
756 sizeof(key
->enc_ipv6
.src
));
757 fl_set_key_val(tb
, &key
->enc_ipv6
.dst
,
758 TCA_FLOWER_KEY_ENC_IPV6_DST
,
760 TCA_FLOWER_KEY_ENC_IPV6_DST_MASK
,
761 sizeof(key
->enc_ipv6
.dst
));
764 fl_set_key_val(tb
, &key
->enc_key_id
.keyid
, TCA_FLOWER_KEY_ENC_KEY_ID
,
765 &mask
->enc_key_id
.keyid
, TCA_FLOWER_UNSPEC
,
766 sizeof(key
->enc_key_id
.keyid
));
768 fl_set_key_val(tb
, &key
->enc_tp
.src
, TCA_FLOWER_KEY_ENC_UDP_SRC_PORT
,
769 &mask
->enc_tp
.src
, TCA_FLOWER_KEY_ENC_UDP_SRC_PORT_MASK
,
770 sizeof(key
->enc_tp
.src
));
772 fl_set_key_val(tb
, &key
->enc_tp
.dst
, TCA_FLOWER_KEY_ENC_UDP_DST_PORT
,
773 &mask
->enc_tp
.dst
, TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK
,
774 sizeof(key
->enc_tp
.dst
));
776 fl_set_key_ip(tb
, true, &key
->enc_ip
, &mask
->enc_ip
);
778 if (tb
[TCA_FLOWER_KEY_FLAGS
])
779 ret
= fl_set_key_flags(tb
, &key
->control
.flags
, &mask
->control
.flags
);
784 static void fl_mask_copy(struct fl_flow_mask
*dst
,
785 struct fl_flow_mask
*src
)
787 const void *psrc
= fl_key_get_start(&src
->key
, src
);
788 void *pdst
= fl_key_get_start(&dst
->key
, src
);
790 memcpy(pdst
, psrc
, fl_mask_range(src
));
791 dst
->range
= src
->range
;
794 static const struct rhashtable_params fl_ht_params
= {
795 .key_offset
= offsetof(struct cls_fl_filter
, mkey
), /* base offset */
796 .head_offset
= offsetof(struct cls_fl_filter
, ht_node
),
797 .automatic_shrinking
= true,
800 static int fl_init_mask_hashtable(struct fl_flow_mask
*mask
)
802 mask
->filter_ht_params
= fl_ht_params
;
803 mask
->filter_ht_params
.key_len
= fl_mask_range(mask
);
804 mask
->filter_ht_params
.key_offset
+= mask
->range
.start
;
806 return rhashtable_init(&mask
->ht
, &mask
->filter_ht_params
);
809 #define FL_KEY_MEMBER_OFFSET(member) offsetof(struct fl_flow_key, member)
810 #define FL_KEY_MEMBER_SIZE(member) (sizeof(((struct fl_flow_key *) 0)->member))
812 #define FL_KEY_IS_MASKED(mask, member) \
813 memchr_inv(((char *)mask) + FL_KEY_MEMBER_OFFSET(member), \
814 0, FL_KEY_MEMBER_SIZE(member)) \
816 #define FL_KEY_SET(keys, cnt, id, member) \
818 keys[cnt].key_id = id; \
819 keys[cnt].offset = FL_KEY_MEMBER_OFFSET(member); \
823 #define FL_KEY_SET_IF_MASKED(mask, keys, cnt, id, member) \
825 if (FL_KEY_IS_MASKED(mask, member)) \
826 FL_KEY_SET(keys, cnt, id, member); \
829 static void fl_init_dissector(struct fl_flow_mask
*mask
)
831 struct flow_dissector_key keys
[FLOW_DISSECTOR_KEY_MAX
];
834 FL_KEY_SET(keys
, cnt
, FLOW_DISSECTOR_KEY_CONTROL
, control
);
835 FL_KEY_SET(keys
, cnt
, FLOW_DISSECTOR_KEY_BASIC
, basic
);
836 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
837 FLOW_DISSECTOR_KEY_ETH_ADDRS
, eth
);
838 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
839 FLOW_DISSECTOR_KEY_IPV4_ADDRS
, ipv4
);
840 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
841 FLOW_DISSECTOR_KEY_IPV6_ADDRS
, ipv6
);
842 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
843 FLOW_DISSECTOR_KEY_PORTS
, tp
);
844 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
845 FLOW_DISSECTOR_KEY_IP
, ip
);
846 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
847 FLOW_DISSECTOR_KEY_TCP
, tcp
);
848 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
849 FLOW_DISSECTOR_KEY_ICMP
, icmp
);
850 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
851 FLOW_DISSECTOR_KEY_ARP
, arp
);
852 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
853 FLOW_DISSECTOR_KEY_MPLS
, mpls
);
854 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
855 FLOW_DISSECTOR_KEY_VLAN
, vlan
);
856 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
857 FLOW_DISSECTOR_KEY_CVLAN
, cvlan
);
858 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
859 FLOW_DISSECTOR_KEY_ENC_KEYID
, enc_key_id
);
860 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
861 FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS
, enc_ipv4
);
862 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
863 FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS
, enc_ipv6
);
864 if (FL_KEY_IS_MASKED(&mask
->key
, enc_ipv4
) ||
865 FL_KEY_IS_MASKED(&mask
->key
, enc_ipv6
))
866 FL_KEY_SET(keys
, cnt
, FLOW_DISSECTOR_KEY_ENC_CONTROL
,
868 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
869 FLOW_DISSECTOR_KEY_ENC_PORTS
, enc_tp
);
870 FL_KEY_SET_IF_MASKED(&mask
->key
, keys
, cnt
,
871 FLOW_DISSECTOR_KEY_ENC_IP
, enc_ip
);
873 skb_flow_dissector_init(&mask
->dissector
, keys
, cnt
);
876 static struct fl_flow_mask
*fl_create_new_mask(struct cls_fl_head
*head
,
877 struct fl_flow_mask
*mask
)
879 struct fl_flow_mask
*newmask
;
882 newmask
= kzalloc(sizeof(*newmask
), GFP_KERNEL
);
884 return ERR_PTR(-ENOMEM
);
886 fl_mask_copy(newmask
, mask
);
888 err
= fl_init_mask_hashtable(newmask
);
892 fl_init_dissector(newmask
);
894 INIT_LIST_HEAD_RCU(&newmask
->filters
);
896 err
= rhashtable_insert_fast(&head
->ht
, &newmask
->ht_node
,
901 list_add_tail_rcu(&newmask
->list
, &head
->masks
);
906 rhashtable_destroy(&newmask
->ht
);
913 static int fl_check_assign_mask(struct cls_fl_head
*head
,
914 struct cls_fl_filter
*fnew
,
915 struct cls_fl_filter
*fold
,
916 struct fl_flow_mask
*mask
)
918 struct fl_flow_mask
*newmask
;
920 fnew
->mask
= rhashtable_lookup_fast(&head
->ht
, mask
, mask_ht_params
);
925 newmask
= fl_create_new_mask(head
, mask
);
927 return PTR_ERR(newmask
);
929 fnew
->mask
= newmask
;
930 } else if (fold
&& fold
->mask
!= fnew
->mask
) {
937 static int fl_set_parms(struct net
*net
, struct tcf_proto
*tp
,
938 struct cls_fl_filter
*f
, struct fl_flow_mask
*mask
,
939 unsigned long base
, struct nlattr
**tb
,
940 struct nlattr
*est
, bool ovr
,
941 struct netlink_ext_ack
*extack
)
945 err
= tcf_exts_validate(net
, tp
, tb
, est
, &f
->exts
, ovr
, extack
);
949 if (tb
[TCA_FLOWER_CLASSID
]) {
950 f
->res
.classid
= nla_get_u32(tb
[TCA_FLOWER_CLASSID
]);
951 tcf_bind_filter(tp
, &f
->res
, base
);
954 err
= fl_set_key(net
, tb
, &f
->key
, &mask
->key
, extack
);
958 fl_mask_update_range(mask
);
959 fl_set_masked_key(&f
->mkey
, &f
->key
, mask
);
964 static int fl_change(struct net
*net
, struct sk_buff
*in_skb
,
965 struct tcf_proto
*tp
, unsigned long base
,
966 u32 handle
, struct nlattr
**tca
,
967 void **arg
, bool ovr
, struct netlink_ext_ack
*extack
)
969 struct cls_fl_head
*head
= rtnl_dereference(tp
->root
);
970 struct cls_fl_filter
*fold
= *arg
;
971 struct cls_fl_filter
*fnew
;
973 struct fl_flow_mask mask
= {};
976 if (!tca
[TCA_OPTIONS
])
979 tb
= kcalloc(TCA_FLOWER_MAX
+ 1, sizeof(struct nlattr
*), GFP_KERNEL
);
983 err
= nla_parse_nested(tb
, TCA_FLOWER_MAX
, tca
[TCA_OPTIONS
],
988 if (fold
&& handle
&& fold
->handle
!= handle
) {
993 fnew
= kzalloc(sizeof(*fnew
), GFP_KERNEL
);
999 err
= tcf_exts_init(&fnew
->exts
, TCA_FLOWER_ACT
, 0);
1005 err
= idr_alloc_u32(&head
->handle_idr
, fnew
, &handle
,
1006 INT_MAX
, GFP_KERNEL
);
1008 /* user specifies a handle and it doesn't exist */
1009 err
= idr_alloc_u32(&head
->handle_idr
, fnew
, &handle
,
1010 handle
, GFP_KERNEL
);
1014 fnew
->handle
= handle
;
1016 if (tb
[TCA_FLOWER_FLAGS
]) {
1017 fnew
->flags
= nla_get_u32(tb
[TCA_FLOWER_FLAGS
]);
1019 if (!tc_flags_valid(fnew
->flags
)) {
1025 err
= fl_set_parms(net
, tp
, fnew
, &mask
, base
, tb
, tca
[TCA_RATE
], ovr
,
1030 err
= fl_check_assign_mask(head
, fnew
, fold
, &mask
);
1034 if (!tc_skip_sw(fnew
->flags
)) {
1035 if (!fold
&& fl_lookup(fnew
->mask
, &fnew
->mkey
)) {
1040 err
= rhashtable_insert_fast(&fnew
->mask
->ht
, &fnew
->ht_node
,
1041 fnew
->mask
->filter_ht_params
);
1046 if (!tc_skip_hw(fnew
->flags
)) {
1047 err
= fl_hw_replace_filter(tp
, fnew
, extack
);
1052 if (!tc_in_hw(fnew
->flags
))
1053 fnew
->flags
|= TCA_CLS_FLAGS_NOT_IN_HW
;
1056 if (!tc_skip_sw(fold
->flags
))
1057 rhashtable_remove_fast(&fold
->mask
->ht
,
1059 fold
->mask
->filter_ht_params
);
1060 if (!tc_skip_hw(fold
->flags
))
1061 fl_hw_destroy_filter(tp
, fold
, NULL
);
1067 idr_replace(&head
->handle_idr
, fnew
, fnew
->handle
);
1068 list_replace_rcu(&fold
->list
, &fnew
->list
);
1069 tcf_unbind_filter(tp
, &fold
->res
);
1070 tcf_exts_get_net(&fold
->exts
);
1071 tcf_queue_work(&fold
->rwork
, fl_destroy_filter_work
);
1073 list_add_tail_rcu(&fnew
->list
, &fnew
->mask
->filters
);
1080 fl_mask_put(head
, fnew
->mask
, false);
1084 idr_remove(&head
->handle_idr
, fnew
->handle
);
1086 tcf_exts_destroy(&fnew
->exts
);
1093 static int fl_delete(struct tcf_proto
*tp
, void *arg
, bool *last
,
1094 struct netlink_ext_ack
*extack
)
1096 struct cls_fl_head
*head
= rtnl_dereference(tp
->root
);
1097 struct cls_fl_filter
*f
= arg
;
1099 if (!tc_skip_sw(f
->flags
))
1100 rhashtable_remove_fast(&f
->mask
->ht
, &f
->ht_node
,
1101 f
->mask
->filter_ht_params
);
1102 __fl_delete(tp
, f
, extack
);
1103 *last
= list_empty(&head
->masks
);
1107 static void fl_walk(struct tcf_proto
*tp
, struct tcf_walker
*arg
)
1109 struct cls_fl_head
*head
= rtnl_dereference(tp
->root
);
1110 struct cls_fl_filter
*f
;
1112 arg
->count
= arg
->skip
;
1114 while ((f
= idr_get_next_ul(&head
->handle_idr
,
1115 &arg
->cookie
)) != NULL
) {
1116 if (arg
->fn(tp
, f
, arg
) < 0) {
1120 arg
->cookie
= f
->handle
+ 1;
1125 static int fl_reoffload(struct tcf_proto
*tp
, bool add
, tc_setup_cb_t
*cb
,
1126 void *cb_priv
, struct netlink_ext_ack
*extack
)
1128 struct cls_fl_head
*head
= rtnl_dereference(tp
->root
);
1129 struct tc_cls_flower_offload cls_flower
= {};
1130 struct tcf_block
*block
= tp
->chain
->block
;
1131 struct fl_flow_mask
*mask
;
1132 struct cls_fl_filter
*f
;
1135 list_for_each_entry(mask
, &head
->masks
, list
) {
1136 list_for_each_entry(f
, &mask
->filters
, list
) {
1137 if (tc_skip_hw(f
->flags
))
1140 tc_cls_common_offload_init(&cls_flower
.common
, tp
,
1142 cls_flower
.command
= add
?
1143 TC_CLSFLOWER_REPLACE
: TC_CLSFLOWER_DESTROY
;
1144 cls_flower
.cookie
= (unsigned long)f
;
1145 cls_flower
.dissector
= &mask
->dissector
;
1146 cls_flower
.mask
= &f
->mkey
;
1147 cls_flower
.key
= &f
->key
;
1148 cls_flower
.exts
= &f
->exts
;
1149 cls_flower
.classid
= f
->res
.classid
;
1151 err
= cb(TC_SETUP_CLSFLOWER
, &cls_flower
, cb_priv
);
1153 if (add
&& tc_skip_sw(f
->flags
))
1158 tc_cls_offload_cnt_update(block
, &f
->in_hw_count
,
1166 static int fl_dump_key_val(struct sk_buff
*skb
,
1167 void *val
, int val_type
,
1168 void *mask
, int mask_type
, int len
)
1172 if (!memchr_inv(mask
, 0, len
))
1174 err
= nla_put(skb
, val_type
, len
, val
);
1177 if (mask_type
!= TCA_FLOWER_UNSPEC
) {
1178 err
= nla_put(skb
, mask_type
, len
, mask
);
1185 static int fl_dump_key_mpls(struct sk_buff
*skb
,
1186 struct flow_dissector_key_mpls
*mpls_key
,
1187 struct flow_dissector_key_mpls
*mpls_mask
)
1191 if (!memchr_inv(mpls_mask
, 0, sizeof(*mpls_mask
)))
1193 if (mpls_mask
->mpls_ttl
) {
1194 err
= nla_put_u8(skb
, TCA_FLOWER_KEY_MPLS_TTL
,
1195 mpls_key
->mpls_ttl
);
1199 if (mpls_mask
->mpls_tc
) {
1200 err
= nla_put_u8(skb
, TCA_FLOWER_KEY_MPLS_TC
,
1205 if (mpls_mask
->mpls_label
) {
1206 err
= nla_put_u32(skb
, TCA_FLOWER_KEY_MPLS_LABEL
,
1207 mpls_key
->mpls_label
);
1211 if (mpls_mask
->mpls_bos
) {
1212 err
= nla_put_u8(skb
, TCA_FLOWER_KEY_MPLS_BOS
,
1213 mpls_key
->mpls_bos
);
1220 static int fl_dump_key_ip(struct sk_buff
*skb
, bool encap
,
1221 struct flow_dissector_key_ip
*key
,
1222 struct flow_dissector_key_ip
*mask
)
1224 int tos_key
= encap
? TCA_FLOWER_KEY_ENC_IP_TOS
: TCA_FLOWER_KEY_IP_TOS
;
1225 int ttl_key
= encap
? TCA_FLOWER_KEY_ENC_IP_TTL
: TCA_FLOWER_KEY_IP_TTL
;
1226 int tos_mask
= encap
? TCA_FLOWER_KEY_ENC_IP_TOS_MASK
: TCA_FLOWER_KEY_IP_TOS_MASK
;
1227 int ttl_mask
= encap
? TCA_FLOWER_KEY_ENC_IP_TTL_MASK
: TCA_FLOWER_KEY_IP_TTL_MASK
;
1229 if (fl_dump_key_val(skb
, &key
->tos
, tos_key
, &mask
->tos
, tos_mask
, sizeof(key
->tos
)) ||
1230 fl_dump_key_val(skb
, &key
->ttl
, ttl_key
, &mask
->ttl
, ttl_mask
, sizeof(key
->ttl
)))
1236 static int fl_dump_key_vlan(struct sk_buff
*skb
,
1237 int vlan_id_key
, int vlan_prio_key
,
1238 struct flow_dissector_key_vlan
*vlan_key
,
1239 struct flow_dissector_key_vlan
*vlan_mask
)
1243 if (!memchr_inv(vlan_mask
, 0, sizeof(*vlan_mask
)))
1245 if (vlan_mask
->vlan_id
) {
1246 err
= nla_put_u16(skb
, vlan_id_key
,
1251 if (vlan_mask
->vlan_priority
) {
1252 err
= nla_put_u8(skb
, vlan_prio_key
,
1253 vlan_key
->vlan_priority
);
1260 static void fl_get_key_flag(u32 dissector_key
, u32 dissector_mask
,
1261 u32
*flower_key
, u32
*flower_mask
,
1262 u32 flower_flag_bit
, u32 dissector_flag_bit
)
1264 if (dissector_mask
& dissector_flag_bit
) {
1265 *flower_mask
|= flower_flag_bit
;
1266 if (dissector_key
& dissector_flag_bit
)
1267 *flower_key
|= flower_flag_bit
;
1271 static int fl_dump_key_flags(struct sk_buff
*skb
, u32 flags_key
, u32 flags_mask
)
1277 if (!memchr_inv(&flags_mask
, 0, sizeof(flags_mask
)))
1283 fl_get_key_flag(flags_key
, flags_mask
, &key
, &mask
,
1284 TCA_FLOWER_KEY_FLAGS_IS_FRAGMENT
, FLOW_DIS_IS_FRAGMENT
);
1285 fl_get_key_flag(flags_key
, flags_mask
, &key
, &mask
,
1286 TCA_FLOWER_KEY_FLAGS_FRAG_IS_FIRST
,
1287 FLOW_DIS_FIRST_FRAG
);
1289 _key
= cpu_to_be32(key
);
1290 _mask
= cpu_to_be32(mask
);
1292 err
= nla_put(skb
, TCA_FLOWER_KEY_FLAGS
, 4, &_key
);
1296 return nla_put(skb
, TCA_FLOWER_KEY_FLAGS_MASK
, 4, &_mask
);
1299 static int fl_dump(struct net
*net
, struct tcf_proto
*tp
, void *fh
,
1300 struct sk_buff
*skb
, struct tcmsg
*t
)
1302 struct cls_fl_filter
*f
= fh
;
1303 struct nlattr
*nest
;
1304 struct fl_flow_key
*key
, *mask
;
1309 t
->tcm_handle
= f
->handle
;
1311 nest
= nla_nest_start(skb
, TCA_OPTIONS
);
1313 goto nla_put_failure
;
1315 if (f
->res
.classid
&&
1316 nla_put_u32(skb
, TCA_FLOWER_CLASSID
, f
->res
.classid
))
1317 goto nla_put_failure
;
1320 mask
= &f
->mask
->key
;
1322 if (mask
->indev_ifindex
) {
1323 struct net_device
*dev
;
1325 dev
= __dev_get_by_index(net
, key
->indev_ifindex
);
1326 if (dev
&& nla_put_string(skb
, TCA_FLOWER_INDEV
, dev
->name
))
1327 goto nla_put_failure
;
1330 if (!tc_skip_hw(f
->flags
))
1331 fl_hw_update_stats(tp
, f
);
1333 if (fl_dump_key_val(skb
, key
->eth
.dst
, TCA_FLOWER_KEY_ETH_DST
,
1334 mask
->eth
.dst
, TCA_FLOWER_KEY_ETH_DST_MASK
,
1335 sizeof(key
->eth
.dst
)) ||
1336 fl_dump_key_val(skb
, key
->eth
.src
, TCA_FLOWER_KEY_ETH_SRC
,
1337 mask
->eth
.src
, TCA_FLOWER_KEY_ETH_SRC_MASK
,
1338 sizeof(key
->eth
.src
)) ||
1339 fl_dump_key_val(skb
, &key
->basic
.n_proto
, TCA_FLOWER_KEY_ETH_TYPE
,
1340 &mask
->basic
.n_proto
, TCA_FLOWER_UNSPEC
,
1341 sizeof(key
->basic
.n_proto
)))
1342 goto nla_put_failure
;
1344 if (fl_dump_key_mpls(skb
, &key
->mpls
, &mask
->mpls
))
1345 goto nla_put_failure
;
1347 if (fl_dump_key_vlan(skb
, TCA_FLOWER_KEY_VLAN_ID
,
1348 TCA_FLOWER_KEY_VLAN_PRIO
, &key
->vlan
, &mask
->vlan
))
1349 goto nla_put_failure
;
1351 if (fl_dump_key_vlan(skb
, TCA_FLOWER_KEY_CVLAN_ID
,
1352 TCA_FLOWER_KEY_CVLAN_PRIO
,
1353 &key
->cvlan
, &mask
->cvlan
) ||
1354 (mask
->cvlan
.vlan_tpid
&&
1355 nla_put_u16(skb
, TCA_FLOWER_KEY_VLAN_ETH_TYPE
,
1356 key
->cvlan
.vlan_tpid
)))
1357 goto nla_put_failure
;
1359 if (mask
->basic
.n_proto
) {
1360 if (mask
->cvlan
.vlan_tpid
) {
1361 if (nla_put_be16(skb
, TCA_FLOWER_KEY_CVLAN_ETH_TYPE
,
1362 key
->basic
.n_proto
))
1363 goto nla_put_failure
;
1364 } else if (mask
->vlan
.vlan_tpid
) {
1365 if (nla_put_be16(skb
, TCA_FLOWER_KEY_VLAN_ETH_TYPE
,
1366 key
->basic
.n_proto
))
1367 goto nla_put_failure
;
1371 if ((key
->basic
.n_proto
== htons(ETH_P_IP
) ||
1372 key
->basic
.n_proto
== htons(ETH_P_IPV6
)) &&
1373 (fl_dump_key_val(skb
, &key
->basic
.ip_proto
, TCA_FLOWER_KEY_IP_PROTO
,
1374 &mask
->basic
.ip_proto
, TCA_FLOWER_UNSPEC
,
1375 sizeof(key
->basic
.ip_proto
)) ||
1376 fl_dump_key_ip(skb
, false, &key
->ip
, &mask
->ip
)))
1377 goto nla_put_failure
;
1379 if (key
->control
.addr_type
== FLOW_DISSECTOR_KEY_IPV4_ADDRS
&&
1380 (fl_dump_key_val(skb
, &key
->ipv4
.src
, TCA_FLOWER_KEY_IPV4_SRC
,
1381 &mask
->ipv4
.src
, TCA_FLOWER_KEY_IPV4_SRC_MASK
,
1382 sizeof(key
->ipv4
.src
)) ||
1383 fl_dump_key_val(skb
, &key
->ipv4
.dst
, TCA_FLOWER_KEY_IPV4_DST
,
1384 &mask
->ipv4
.dst
, TCA_FLOWER_KEY_IPV4_DST_MASK
,
1385 sizeof(key
->ipv4
.dst
))))
1386 goto nla_put_failure
;
1387 else if (key
->control
.addr_type
== FLOW_DISSECTOR_KEY_IPV6_ADDRS
&&
1388 (fl_dump_key_val(skb
, &key
->ipv6
.src
, TCA_FLOWER_KEY_IPV6_SRC
,
1389 &mask
->ipv6
.src
, TCA_FLOWER_KEY_IPV6_SRC_MASK
,
1390 sizeof(key
->ipv6
.src
)) ||
1391 fl_dump_key_val(skb
, &key
->ipv6
.dst
, TCA_FLOWER_KEY_IPV6_DST
,
1392 &mask
->ipv6
.dst
, TCA_FLOWER_KEY_IPV6_DST_MASK
,
1393 sizeof(key
->ipv6
.dst
))))
1394 goto nla_put_failure
;
1396 if (key
->basic
.ip_proto
== IPPROTO_TCP
&&
1397 (fl_dump_key_val(skb
, &key
->tp
.src
, TCA_FLOWER_KEY_TCP_SRC
,
1398 &mask
->tp
.src
, TCA_FLOWER_KEY_TCP_SRC_MASK
,
1399 sizeof(key
->tp
.src
)) ||
1400 fl_dump_key_val(skb
, &key
->tp
.dst
, TCA_FLOWER_KEY_TCP_DST
,
1401 &mask
->tp
.dst
, TCA_FLOWER_KEY_TCP_DST_MASK
,
1402 sizeof(key
->tp
.dst
)) ||
1403 fl_dump_key_val(skb
, &key
->tcp
.flags
, TCA_FLOWER_KEY_TCP_FLAGS
,
1404 &mask
->tcp
.flags
, TCA_FLOWER_KEY_TCP_FLAGS_MASK
,
1405 sizeof(key
->tcp
.flags
))))
1406 goto nla_put_failure
;
1407 else if (key
->basic
.ip_proto
== IPPROTO_UDP
&&
1408 (fl_dump_key_val(skb
, &key
->tp
.src
, TCA_FLOWER_KEY_UDP_SRC
,
1409 &mask
->tp
.src
, TCA_FLOWER_KEY_UDP_SRC_MASK
,
1410 sizeof(key
->tp
.src
)) ||
1411 fl_dump_key_val(skb
, &key
->tp
.dst
, TCA_FLOWER_KEY_UDP_DST
,
1412 &mask
->tp
.dst
, TCA_FLOWER_KEY_UDP_DST_MASK
,
1413 sizeof(key
->tp
.dst
))))
1414 goto nla_put_failure
;
1415 else if (key
->basic
.ip_proto
== IPPROTO_SCTP
&&
1416 (fl_dump_key_val(skb
, &key
->tp
.src
, TCA_FLOWER_KEY_SCTP_SRC
,
1417 &mask
->tp
.src
, TCA_FLOWER_KEY_SCTP_SRC_MASK
,
1418 sizeof(key
->tp
.src
)) ||
1419 fl_dump_key_val(skb
, &key
->tp
.dst
, TCA_FLOWER_KEY_SCTP_DST
,
1420 &mask
->tp
.dst
, TCA_FLOWER_KEY_SCTP_DST_MASK
,
1421 sizeof(key
->tp
.dst
))))
1422 goto nla_put_failure
;
1423 else if (key
->basic
.n_proto
== htons(ETH_P_IP
) &&
1424 key
->basic
.ip_proto
== IPPROTO_ICMP
&&
1425 (fl_dump_key_val(skb
, &key
->icmp
.type
,
1426 TCA_FLOWER_KEY_ICMPV4_TYPE
, &mask
->icmp
.type
,
1427 TCA_FLOWER_KEY_ICMPV4_TYPE_MASK
,
1428 sizeof(key
->icmp
.type
)) ||
1429 fl_dump_key_val(skb
, &key
->icmp
.code
,
1430 TCA_FLOWER_KEY_ICMPV4_CODE
, &mask
->icmp
.code
,
1431 TCA_FLOWER_KEY_ICMPV4_CODE_MASK
,
1432 sizeof(key
->icmp
.code
))))
1433 goto nla_put_failure
;
1434 else if (key
->basic
.n_proto
== htons(ETH_P_IPV6
) &&
1435 key
->basic
.ip_proto
== IPPROTO_ICMPV6
&&
1436 (fl_dump_key_val(skb
, &key
->icmp
.type
,
1437 TCA_FLOWER_KEY_ICMPV6_TYPE
, &mask
->icmp
.type
,
1438 TCA_FLOWER_KEY_ICMPV6_TYPE_MASK
,
1439 sizeof(key
->icmp
.type
)) ||
1440 fl_dump_key_val(skb
, &key
->icmp
.code
,
1441 TCA_FLOWER_KEY_ICMPV6_CODE
, &mask
->icmp
.code
,
1442 TCA_FLOWER_KEY_ICMPV6_CODE_MASK
,
1443 sizeof(key
->icmp
.code
))))
1444 goto nla_put_failure
;
1445 else if ((key
->basic
.n_proto
== htons(ETH_P_ARP
) ||
1446 key
->basic
.n_proto
== htons(ETH_P_RARP
)) &&
1447 (fl_dump_key_val(skb
, &key
->arp
.sip
,
1448 TCA_FLOWER_KEY_ARP_SIP
, &mask
->arp
.sip
,
1449 TCA_FLOWER_KEY_ARP_SIP_MASK
,
1450 sizeof(key
->arp
.sip
)) ||
1451 fl_dump_key_val(skb
, &key
->arp
.tip
,
1452 TCA_FLOWER_KEY_ARP_TIP
, &mask
->arp
.tip
,
1453 TCA_FLOWER_KEY_ARP_TIP_MASK
,
1454 sizeof(key
->arp
.tip
)) ||
1455 fl_dump_key_val(skb
, &key
->arp
.op
,
1456 TCA_FLOWER_KEY_ARP_OP
, &mask
->arp
.op
,
1457 TCA_FLOWER_KEY_ARP_OP_MASK
,
1458 sizeof(key
->arp
.op
)) ||
1459 fl_dump_key_val(skb
, key
->arp
.sha
, TCA_FLOWER_KEY_ARP_SHA
,
1460 mask
->arp
.sha
, TCA_FLOWER_KEY_ARP_SHA_MASK
,
1461 sizeof(key
->arp
.sha
)) ||
1462 fl_dump_key_val(skb
, key
->arp
.tha
, TCA_FLOWER_KEY_ARP_THA
,
1463 mask
->arp
.tha
, TCA_FLOWER_KEY_ARP_THA_MASK
,
1464 sizeof(key
->arp
.tha
))))
1465 goto nla_put_failure
;
1467 if (key
->enc_control
.addr_type
== FLOW_DISSECTOR_KEY_IPV4_ADDRS
&&
1468 (fl_dump_key_val(skb
, &key
->enc_ipv4
.src
,
1469 TCA_FLOWER_KEY_ENC_IPV4_SRC
, &mask
->enc_ipv4
.src
,
1470 TCA_FLOWER_KEY_ENC_IPV4_SRC_MASK
,
1471 sizeof(key
->enc_ipv4
.src
)) ||
1472 fl_dump_key_val(skb
, &key
->enc_ipv4
.dst
,
1473 TCA_FLOWER_KEY_ENC_IPV4_DST
, &mask
->enc_ipv4
.dst
,
1474 TCA_FLOWER_KEY_ENC_IPV4_DST_MASK
,
1475 sizeof(key
->enc_ipv4
.dst
))))
1476 goto nla_put_failure
;
1477 else if (key
->enc_control
.addr_type
== FLOW_DISSECTOR_KEY_IPV6_ADDRS
&&
1478 (fl_dump_key_val(skb
, &key
->enc_ipv6
.src
,
1479 TCA_FLOWER_KEY_ENC_IPV6_SRC
, &mask
->enc_ipv6
.src
,
1480 TCA_FLOWER_KEY_ENC_IPV6_SRC_MASK
,
1481 sizeof(key
->enc_ipv6
.src
)) ||
1482 fl_dump_key_val(skb
, &key
->enc_ipv6
.dst
,
1483 TCA_FLOWER_KEY_ENC_IPV6_DST
,
1484 &mask
->enc_ipv6
.dst
,
1485 TCA_FLOWER_KEY_ENC_IPV6_DST_MASK
,
1486 sizeof(key
->enc_ipv6
.dst
))))
1487 goto nla_put_failure
;
1489 if (fl_dump_key_val(skb
, &key
->enc_key_id
, TCA_FLOWER_KEY_ENC_KEY_ID
,
1490 &mask
->enc_key_id
, TCA_FLOWER_UNSPEC
,
1491 sizeof(key
->enc_key_id
)) ||
1492 fl_dump_key_val(skb
, &key
->enc_tp
.src
,
1493 TCA_FLOWER_KEY_ENC_UDP_SRC_PORT
,
1495 TCA_FLOWER_KEY_ENC_UDP_SRC_PORT_MASK
,
1496 sizeof(key
->enc_tp
.src
)) ||
1497 fl_dump_key_val(skb
, &key
->enc_tp
.dst
,
1498 TCA_FLOWER_KEY_ENC_UDP_DST_PORT
,
1500 TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK
,
1501 sizeof(key
->enc_tp
.dst
)) ||
1502 fl_dump_key_ip(skb
, true, &key
->enc_ip
, &mask
->enc_ip
))
1503 goto nla_put_failure
;
1505 if (fl_dump_key_flags(skb
, key
->control
.flags
, mask
->control
.flags
))
1506 goto nla_put_failure
;
1508 if (f
->flags
&& nla_put_u32(skb
, TCA_FLOWER_FLAGS
, f
->flags
))
1509 goto nla_put_failure
;
1511 if (tcf_exts_dump(skb
, &f
->exts
))
1512 goto nla_put_failure
;
1514 nla_nest_end(skb
, nest
);
1516 if (tcf_exts_dump_stats(skb
, &f
->exts
) < 0)
1517 goto nla_put_failure
;
1522 nla_nest_cancel(skb
, nest
);
1526 static void fl_bind_class(void *fh
, u32 classid
, unsigned long cl
)
1528 struct cls_fl_filter
*f
= fh
;
1530 if (f
&& f
->res
.classid
== classid
)
1534 static struct tcf_proto_ops cls_fl_ops __read_mostly
= {
1536 .classify
= fl_classify
,
1538 .destroy
= fl_destroy
,
1540 .change
= fl_change
,
1541 .delete = fl_delete
,
1543 .reoffload
= fl_reoffload
,
1545 .bind_class
= fl_bind_class
,
1546 .owner
= THIS_MODULE
,
1549 static int __init
cls_fl_init(void)
1551 return register_tcf_proto_ops(&cls_fl_ops
);
1554 static void __exit
cls_fl_exit(void)
1556 unregister_tcf_proto_ops(&cls_fl_ops
);
1559 module_init(cls_fl_init
);
1560 module_exit(cls_fl_exit
);
1562 MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
1563 MODULE_DESCRIPTION("Flower classifier");
1564 MODULE_LICENSE("GPL v2");