cls_u32.c revision cc7ec456f82da7f89a5b376e613b3ac4311b3e9a 
1/*
2 * net/sched/cls_u32.c	Ugly (or Universal) 32bit key Packet Classifier.
3 *
4 *		This program is free software; you can redistribute it and/or
5 *		modify it under the terms of the GNU General Public License
6 *		as published by the Free Software Foundation; either version
7 *		2 of the License, or (at your option) any later version.
8 *
9 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 *
11 *	The filters are packed to hash tables of key nodes
12 *	with a set of 32bit key/mask pairs at every node.
13 *	Nodes reference next level hash tables etc.
14 *
15 *	This scheme is the best universal classifier I managed to
16 *	invent; it is not super-fast, but it is not slow (provided you
17 *	program it correctly), and general enough.  And its relative
18 *	speed grows as the number of rules becomes larger.
19 *
20 *	It seems that it represents the best middle point between
21 *	speed and manageability both by human and by machine.
22 *
23 *	It is especially useful for link sharing combined with QoS;
24 *	pure RSVP doesn't need such a general approach and can use
25 *	much simpler (and faster) schemes, sort of cls_rsvp.c.
26 *
27 *	JHS: We should remove the CONFIG_NET_CLS_IND from here
28 *	eventually when the meta match extension is made available
29 *
30 *	nfmark match added by Catalin(ux aka Dino) BOIE <catab at umbrella.ro>
31 */
32
33#include <linux/module.h>
34#include <linux/slab.h>
35#include <linux/types.h>
36#include <linux/kernel.h>
37#include <linux/string.h>
38#include <linux/errno.h>
39#include <linux/rtnetlink.h>
40#include <linux/skbuff.h>
41#include <net/netlink.h>
42#include <net/act_api.h>
43#include <net/pkt_cls.h>
44
45struct tc_u_knode {
46	struct tc_u_knode	*next;
47	u32			handle;
48	struct tc_u_hnode	*ht_up;
49	struct tcf_exts		exts;
50#ifdef CONFIG_NET_CLS_IND
51	char                     indev[IFNAMSIZ];
52#endif
53	u8			fshift;
54	struct tcf_result	res;
55	struct tc_u_hnode	*ht_down;
56#ifdef CONFIG_CLS_U32_PERF
57	struct tc_u32_pcnt	*pf;
58#endif
59#ifdef CONFIG_CLS_U32_MARK
60	struct tc_u32_mark	mark;
61#endif
62	struct tc_u32_sel	sel;
63};
64
65struct tc_u_hnode {
66	struct tc_u_hnode	*next;
67	u32			handle;
68	u32			prio;
69	struct tc_u_common	*tp_c;
70	int			refcnt;
71	unsigned int		divisor;
72	struct tc_u_knode	*ht[1];
73};
74
75struct tc_u_common {
76	struct tc_u_hnode	*hlist;
77	struct Qdisc		*q;
78	int			refcnt;
79	u32			hgenerator;
80};
81
82static const struct tcf_ext_map u32_ext_map = {
83	.action = TCA_U32_ACT,
84	.police = TCA_U32_POLICE
85};
86
87static inline unsigned int u32_hash_fold(__be32 key,
88					 const struct tc_u32_sel *sel,
89					 u8 fshift)
90{
91	unsigned int h = ntohl(key & sel->hmask) >> fshift;
92
93	return h;
94}
95
96static int u32_classify(struct sk_buff *skb, struct tcf_proto *tp, struct tcf_result *res)
97{
98	struct {
99		struct tc_u_knode *knode;
100		unsigned int	  off;
101	} stack[TC_U32_MAXDEPTH];
102
103	struct tc_u_hnode *ht = (struct tc_u_hnode *)tp->root;
104	unsigned int off = skb_network_offset(skb);
105	struct tc_u_knode *n;
106	int sdepth = 0;
107	int off2 = 0;
108	int sel = 0;
109#ifdef CONFIG_CLS_U32_PERF
110	int j;
111#endif
112	int i, r;
113
114next_ht:
115	n = ht->ht[sel];
116
117next_knode:
118	if (n) {
119		struct tc_u32_key *key = n->sel.keys;
120
121#ifdef CONFIG_CLS_U32_PERF
122		n->pf->rcnt += 1;
123		j = 0;
124#endif
125
126#ifdef CONFIG_CLS_U32_MARK
127		if ((skb->mark & n->mark.mask) != n->mark.val) {
128			n = n->next;
129			goto next_knode;
130		} else {
131			n->mark.success++;
132		}
133#endif
134
135		for (i = n->sel.nkeys; i > 0; i--, key++) {
136			int toff = off + key->off + (off2 & key->offmask);
137			__be32 *data, _data;
138
139			if (skb_headroom(skb) + toff > INT_MAX)
140				goto out;
141
142			data = skb_header_pointer(skb, toff, 4, &_data);
143			if (!data)
144				goto out;
145			if ((*data ^ key->val) & key->mask) {
146				n = n->next;
147				goto next_knode;
148			}
149#ifdef CONFIG_CLS_U32_PERF
150			n->pf->kcnts[j] += 1;
151			j++;
152#endif
153		}
154		if (n->ht_down == NULL) {
155check_terminal:
156			if (n->sel.flags & TC_U32_TERMINAL) {
157
158				*res = n->res;
159#ifdef CONFIG_NET_CLS_IND
160				if (!tcf_match_indev(skb, n->indev)) {
161					n = n->next;
162					goto next_knode;
163				}
164#endif
165#ifdef CONFIG_CLS_U32_PERF
166				n->pf->rhit += 1;
167#endif
168				r = tcf_exts_exec(skb, &n->exts, res);
169				if (r < 0) {
170					n = n->next;
171					goto next_knode;
172				}
173
174				return r;
175			}
176			n = n->next;
177			goto next_knode;
178		}
179
180		/* PUSH */
181		if (sdepth >= TC_U32_MAXDEPTH)
182			goto deadloop;
183		stack[sdepth].knode = n;
184		stack[sdepth].off = off;
185		sdepth++;
186
187		ht = n->ht_down;
188		sel = 0;
189		if (ht->divisor) {
190			__be32 *data, _data;
191
192			data = skb_header_pointer(skb, off + n->sel.hoff, 4,
193						  &_data);
194			if (!data)
195				goto out;
196			sel = ht->divisor & u32_hash_fold(*data, &n->sel,
197							  n->fshift);
198		}
199		if (!(n->sel.flags & (TC_U32_VAROFFSET | TC_U32_OFFSET | TC_U32_EAT)))
200			goto next_ht;
201
202		if (n->sel.flags & (TC_U32_OFFSET | TC_U32_VAROFFSET)) {
203			off2 = n->sel.off + 3;
204			if (n->sel.flags & TC_U32_VAROFFSET) {
205				__be16 *data, _data;
206
207				data = skb_header_pointer(skb,
208							  off + n->sel.offoff,
209							  2, &_data);
210				if (!data)
211					goto out;
212				off2 += ntohs(n->sel.offmask & *data) >>
213					n->sel.offshift;
214			}
215			off2 &= ~3;
216		}
217		if (n->sel.flags & TC_U32_EAT) {
218			off += off2;
219			off2 = 0;
220		}
221
222		if (off < skb->len)
223			goto next_ht;
224	}
225
226	/* POP */
227	if (sdepth--) {
228		n = stack[sdepth].knode;
229		ht = n->ht_up;
230		off = stack[sdepth].off;
231		goto check_terminal;
232	}
233out:
234	return -1;
235
236deadloop:
237	if (net_ratelimit())
238		pr_warning("cls_u32: dead loop\n");
239	return -1;
240}
241
242static struct tc_u_hnode *
243u32_lookup_ht(struct tc_u_common *tp_c, u32 handle)
244{
245	struct tc_u_hnode *ht;
246
247	for (ht = tp_c->hlist; ht; ht = ht->next)
248		if (ht->handle == handle)
249			break;
250
251	return ht;
252}
253
254static struct tc_u_knode *
255u32_lookup_key(struct tc_u_hnode *ht, u32 handle)
256{
257	unsigned int sel;
258	struct tc_u_knode *n = NULL;
259
260	sel = TC_U32_HASH(handle);
261	if (sel > ht->divisor)
262		goto out;
263
264	for (n = ht->ht[sel]; n; n = n->next)
265		if (n->handle == handle)
266			break;
267out:
268	return n;
269}
270
271
272static unsigned long u32_get(struct tcf_proto *tp, u32 handle)
273{
274	struct tc_u_hnode *ht;
275	struct tc_u_common *tp_c = tp->data;
276
277	if (TC_U32_HTID(handle) == TC_U32_ROOT)
278		ht = tp->root;
279	else
280		ht = u32_lookup_ht(tp_c, TC_U32_HTID(handle));
281
282	if (!ht)
283		return 0;
284
285	if (TC_U32_KEY(handle) == 0)
286		return (unsigned long)ht;
287
288	return (unsigned long)u32_lookup_key(ht, handle);
289}
290
291static void u32_put(struct tcf_proto *tp, unsigned long f)
292{
293}
294
295static u32 gen_new_htid(struct tc_u_common *tp_c)
296{
297	int i = 0x800;
298
299	do {
300		if (++tp_c->hgenerator == 0x7FF)
301			tp_c->hgenerator = 1;
302	} while (--i > 0 && u32_lookup_ht(tp_c, (tp_c->hgenerator|0x800)<<20));
303
304	return i > 0 ? (tp_c->hgenerator|0x800)<<20 : 0;
305}
306
307static int u32_init(struct tcf_proto *tp)
308{
309	struct tc_u_hnode *root_ht;
310	struct tc_u_common *tp_c;
311
312	tp_c = tp->q->u32_node;
313
314	root_ht = kzalloc(sizeof(*root_ht), GFP_KERNEL);
315	if (root_ht == NULL)
316		return -ENOBUFS;
317
318	root_ht->divisor = 0;
319	root_ht->refcnt++;
320	root_ht->handle = tp_c ? gen_new_htid(tp_c) : 0x80000000;
321	root_ht->prio = tp->prio;
322
323	if (tp_c == NULL) {
324		tp_c = kzalloc(sizeof(*tp_c), GFP_KERNEL);
325		if (tp_c == NULL) {
326			kfree(root_ht);
327			return -ENOBUFS;
328		}
329		tp_c->q = tp->q;
330		tp->q->u32_node = tp_c;
331	}
332
333	tp_c->refcnt++;
334	root_ht->next = tp_c->hlist;
335	tp_c->hlist = root_ht;
336	root_ht->tp_c = tp_c;
337
338	tp->root = root_ht;
339	tp->data = tp_c;
340	return 0;
341}
342
343static int u32_destroy_key(struct tcf_proto *tp, struct tc_u_knode *n)
344{
345	tcf_unbind_filter(tp, &n->res);
346	tcf_exts_destroy(tp, &n->exts);
347	if (n->ht_down)
348		n->ht_down->refcnt--;
349#ifdef CONFIG_CLS_U32_PERF
350	kfree(n->pf);
351#endif
352	kfree(n);
353	return 0;
354}
355
356static int u32_delete_key(struct tcf_proto *tp, struct tc_u_knode* key)
357{
358	struct tc_u_knode **kp;
359	struct tc_u_hnode *ht = key->ht_up;
360
361	if (ht) {
362		for (kp = &ht->ht[TC_U32_HASH(key->handle)]; *kp; kp = &(*kp)->next) {
363			if (*kp == key) {
364				tcf_tree_lock(tp);
365				*kp = key->next;
366				tcf_tree_unlock(tp);
367
368				u32_destroy_key(tp, key);
369				return 0;
370			}
371		}
372	}
373	WARN_ON(1);
374	return 0;
375}
376
377static void u32_clear_hnode(struct tcf_proto *tp, struct tc_u_hnode *ht)
378{
379	struct tc_u_knode *n;
380	unsigned int h;
381
382	for (h = 0; h <= ht->divisor; h++) {
383		while ((n = ht->ht[h]) != NULL) {
384			ht->ht[h] = n->next;
385
386			u32_destroy_key(tp, n);
387		}
388	}
389}
390
391static int u32_destroy_hnode(struct tcf_proto *tp, struct tc_u_hnode *ht)
392{
393	struct tc_u_common *tp_c = tp->data;
394	struct tc_u_hnode **hn;
395
396	WARN_ON(ht->refcnt);
397
398	u32_clear_hnode(tp, ht);
399
400	for (hn = &tp_c->hlist; *hn; hn = &(*hn)->next) {
401		if (*hn == ht) {
402			*hn = ht->next;
403			kfree(ht);
404			return 0;
405		}
406	}
407
408	WARN_ON(1);
409	return -ENOENT;
410}
411
412static void u32_destroy(struct tcf_proto *tp)
413{
414	struct tc_u_common *tp_c = tp->data;
415	struct tc_u_hnode *root_ht = tp->root;
416
417	WARN_ON(root_ht == NULL);
418
419	if (root_ht && --root_ht->refcnt == 0)
420		u32_destroy_hnode(tp, root_ht);
421
422	if (--tp_c->refcnt == 0) {
423		struct tc_u_hnode *ht;
424
425		tp->q->u32_node = NULL;
426
427		for (ht = tp_c->hlist; ht; ht = ht->next) {
428			ht->refcnt--;
429			u32_clear_hnode(tp, ht);
430		}
431
432		while ((ht = tp_c->hlist) != NULL) {
433			tp_c->hlist = ht->next;
434
435			WARN_ON(ht->refcnt != 0);
436
437			kfree(ht);
438		}
439
440		kfree(tp_c);
441	}
442
443	tp->data = NULL;
444}
445
446static int u32_delete(struct tcf_proto *tp, unsigned long arg)
447{
448	struct tc_u_hnode *ht = (struct tc_u_hnode *)arg;
449
450	if (ht == NULL)
451		return 0;
452
453	if (TC_U32_KEY(ht->handle))
454		return u32_delete_key(tp, (struct tc_u_knode *)ht);
455
456	if (tp->root == ht)
457		return -EINVAL;
458
459	if (ht->refcnt == 1) {
460		ht->refcnt--;
461		u32_destroy_hnode(tp, ht);
462	} else {
463		return -EBUSY;
464	}
465
466	return 0;
467}
468
469static u32 gen_new_kid(struct tc_u_hnode *ht, u32 handle)
470{
471	struct tc_u_knode *n;
472	unsigned int i = 0x7FF;
473
474	for (n = ht->ht[TC_U32_HASH(handle)]; n; n = n->next)
475		if (i < TC_U32_NODE(n->handle))
476			i = TC_U32_NODE(n->handle);
477	i++;
478
479	return handle | (i > 0xFFF ? 0xFFF : i);
480}
481
482static const struct nla_policy u32_policy[TCA_U32_MAX + 1] = {
483	[TCA_U32_CLASSID]	= { .type = NLA_U32 },
484	[TCA_U32_HASH]		= { .type = NLA_U32 },
485	[TCA_U32_LINK]		= { .type = NLA_U32 },
486	[TCA_U32_DIVISOR]	= { .type = NLA_U32 },
487	[TCA_U32_SEL]		= { .len = sizeof(struct tc_u32_sel) },
488	[TCA_U32_INDEV]		= { .type = NLA_STRING, .len = IFNAMSIZ },
489	[TCA_U32_MARK]		= { .len = sizeof(struct tc_u32_mark) },
490};
491
492static int u32_set_parms(struct tcf_proto *tp, unsigned long base,
493			 struct tc_u_hnode *ht,
494			 struct tc_u_knode *n, struct nlattr **tb,
495			 struct nlattr *est)
496{
497	int err;
498	struct tcf_exts e;
499
500	err = tcf_exts_validate(tp, tb, est, &e, &u32_ext_map);
501	if (err < 0)
502		return err;
503
504	err = -EINVAL;
505	if (tb[TCA_U32_LINK]) {
506		u32 handle = nla_get_u32(tb[TCA_U32_LINK]);
507		struct tc_u_hnode *ht_down = NULL, *ht_old;
508
509		if (TC_U32_KEY(handle))
510			goto errout;
511
512		if (handle) {
513			ht_down = u32_lookup_ht(ht->tp_c, handle);
514
515			if (ht_down == NULL)
516				goto errout;
517			ht_down->refcnt++;
518		}
519
520		tcf_tree_lock(tp);
521		ht_old = n->ht_down;
522		n->ht_down = ht_down;
523		tcf_tree_unlock(tp);
524
525		if (ht_old)
526			ht_old->refcnt--;
527	}
528	if (tb[TCA_U32_CLASSID]) {
529		n->res.classid = nla_get_u32(tb[TCA_U32_CLASSID]);
530		tcf_bind_filter(tp, &n->res, base);
531	}
532
533#ifdef CONFIG_NET_CLS_IND
534	if (tb[TCA_U32_INDEV]) {
535		err = tcf_change_indev(tp, n->indev, tb[TCA_U32_INDEV]);
536		if (err < 0)
537			goto errout;
538	}
539#endif
540	tcf_exts_change(tp, &n->exts, &e);
541
542	return 0;
543errout:
544	tcf_exts_destroy(tp, &e);
545	return err;
546}
547
548static int u32_change(struct tcf_proto *tp, unsigned long base, u32 handle,
549		      struct nlattr **tca,
550		      unsigned long *arg)
551{
552	struct tc_u_common *tp_c = tp->data;
553	struct tc_u_hnode *ht;
554	struct tc_u_knode *n;
555	struct tc_u32_sel *s;
556	struct nlattr *opt = tca[TCA_OPTIONS];
557	struct nlattr *tb[TCA_U32_MAX + 1];
558	u32 htid;
559	int err;
560
561	if (opt == NULL)
562		return handle ? -EINVAL : 0;
563
564	err = nla_parse_nested(tb, TCA_U32_MAX, opt, u32_policy);
565	if (err < 0)
566		return err;
567
568	n = (struct tc_u_knode *)*arg;
569	if (n) {
570		if (TC_U32_KEY(n->handle) == 0)
571			return -EINVAL;
572
573		return u32_set_parms(tp, base, n->ht_up, n, tb, tca[TCA_RATE]);
574	}
575
576	if (tb[TCA_U32_DIVISOR]) {
577		unsigned int divisor = nla_get_u32(tb[TCA_U32_DIVISOR]);
578
579		if (--divisor > 0x100)
580			return -EINVAL;
581		if (TC_U32_KEY(handle))
582			return -EINVAL;
583		if (handle == 0) {
584			handle = gen_new_htid(tp->data);
585			if (handle == 0)
586				return -ENOMEM;
587		}
588		ht = kzalloc(sizeof(*ht) + divisor*sizeof(void *), GFP_KERNEL);
589		if (ht == NULL)
590			return -ENOBUFS;
591		ht->tp_c = tp_c;
592		ht->refcnt = 1;
593		ht->divisor = divisor;
594		ht->handle = handle;
595		ht->prio = tp->prio;
596		ht->next = tp_c->hlist;
597		tp_c->hlist = ht;
598		*arg = (unsigned long)ht;
599		return 0;
600	}
601
602	if (tb[TCA_U32_HASH]) {
603		htid = nla_get_u32(tb[TCA_U32_HASH]);
604		if (TC_U32_HTID(htid) == TC_U32_ROOT) {
605			ht = tp->root;
606			htid = ht->handle;
607		} else {
608			ht = u32_lookup_ht(tp->data, TC_U32_HTID(htid));
609			if (ht == NULL)
610				return -EINVAL;
611		}
612	} else {
613		ht = tp->root;
614		htid = ht->handle;
615	}
616
617	if (ht->divisor < TC_U32_HASH(htid))
618		return -EINVAL;
619
620	if (handle) {
621		if (TC_U32_HTID(handle) && TC_U32_HTID(handle^htid))
622			return -EINVAL;
623		handle = htid | TC_U32_NODE(handle);
624	} else
625		handle = gen_new_kid(ht, htid);
626
627	if (tb[TCA_U32_SEL] == NULL)
628		return -EINVAL;
629
630	s = nla_data(tb[TCA_U32_SEL]);
631
632	n = kzalloc(sizeof(*n) + s->nkeys*sizeof(struct tc_u32_key), GFP_KERNEL);
633	if (n == NULL)
634		return -ENOBUFS;
635
636#ifdef CONFIG_CLS_U32_PERF
637	n->pf = kzalloc(sizeof(struct tc_u32_pcnt) + s->nkeys*sizeof(u64), GFP_KERNEL);
638	if (n->pf == NULL) {
639		kfree(n);
640		return -ENOBUFS;
641	}
642#endif
643
644	memcpy(&n->sel, s, sizeof(*s) + s->nkeys*sizeof(struct tc_u32_key));
645	n->ht_up = ht;
646	n->handle = handle;
647	n->fshift = s->hmask ? ffs(ntohl(s->hmask)) - 1 : 0;
648
649#ifdef CONFIG_CLS_U32_MARK
650	if (tb[TCA_U32_MARK]) {
651		struct tc_u32_mark *mark;
652
653		mark = nla_data(tb[TCA_U32_MARK]);
654		memcpy(&n->mark, mark, sizeof(struct tc_u32_mark));
655		n->mark.success = 0;
656	}
657#endif
658
659	err = u32_set_parms(tp, base, ht, n, tb, tca[TCA_RATE]);
660	if (err == 0) {
661		struct tc_u_knode **ins;
662		for (ins = &ht->ht[TC_U32_HASH(handle)]; *ins; ins = &(*ins)->next)
663			if (TC_U32_NODE(handle) < TC_U32_NODE((*ins)->handle))
664				break;
665
666		n->next = *ins;
667		tcf_tree_lock(tp);
668		*ins = n;
669		tcf_tree_unlock(tp);
670
671		*arg = (unsigned long)n;
672		return 0;
673	}
674#ifdef CONFIG_CLS_U32_PERF
675	kfree(n->pf);
676#endif
677	kfree(n);
678	return err;
679}
680
681static void u32_walk(struct tcf_proto *tp, struct tcf_walker *arg)
682{
683	struct tc_u_common *tp_c = tp->data;
684	struct tc_u_hnode *ht;
685	struct tc_u_knode *n;
686	unsigned int h;
687
688	if (arg->stop)
689		return;
690
691	for (ht = tp_c->hlist; ht; ht = ht->next) {
692		if (ht->prio != tp->prio)
693			continue;
694		if (arg->count >= arg->skip) {
695			if (arg->fn(tp, (unsigned long)ht, arg) < 0) {
696				arg->stop = 1;
697				return;
698			}
699		}
700		arg->count++;
701		for (h = 0; h <= ht->divisor; h++) {
702			for (n = ht->ht[h]; n; n = n->next) {
703				if (arg->count < arg->skip) {
704					arg->count++;
705					continue;
706				}
707				if (arg->fn(tp, (unsigned long)n, arg) < 0) {
708					arg->stop = 1;
709					return;
710				}
711				arg->count++;
712			}
713		}
714	}
715}
716
717static int u32_dump(struct tcf_proto *tp, unsigned long fh,
718		     struct sk_buff *skb, struct tcmsg *t)
719{
720	struct tc_u_knode *n = (struct tc_u_knode *)fh;
721	struct nlattr *nest;
722
723	if (n == NULL)
724		return skb->len;
725
726	t->tcm_handle = n->handle;
727
728	nest = nla_nest_start(skb, TCA_OPTIONS);
729	if (nest == NULL)
730		goto nla_put_failure;
731
732	if (TC_U32_KEY(n->handle) == 0) {
733		struct tc_u_hnode *ht = (struct tc_u_hnode *)fh;
734		u32 divisor = ht->divisor + 1;
735
736		NLA_PUT_U32(skb, TCA_U32_DIVISOR, divisor);
737	} else {
738		NLA_PUT(skb, TCA_U32_SEL,
739			sizeof(n->sel) + n->sel.nkeys*sizeof(struct tc_u32_key),
740			&n->sel);
741		if (n->ht_up) {
742			u32 htid = n->handle & 0xFFFFF000;
743			NLA_PUT_U32(skb, TCA_U32_HASH, htid);
744		}
745		if (n->res.classid)
746			NLA_PUT_U32(skb, TCA_U32_CLASSID, n->res.classid);
747		if (n->ht_down)
748			NLA_PUT_U32(skb, TCA_U32_LINK, n->ht_down->handle);
749
750#ifdef CONFIG_CLS_U32_MARK
751		if (n->mark.val || n->mark.mask)
752			NLA_PUT(skb, TCA_U32_MARK, sizeof(n->mark), &n->mark);
753#endif
754
755		if (tcf_exts_dump(skb, &n->exts, &u32_ext_map) < 0)
756			goto nla_put_failure;
757
758#ifdef CONFIG_NET_CLS_IND
759		if (strlen(n->indev))
760			NLA_PUT_STRING(skb, TCA_U32_INDEV, n->indev);
761#endif
762#ifdef CONFIG_CLS_U32_PERF
763		NLA_PUT(skb, TCA_U32_PCNT,
764		sizeof(struct tc_u32_pcnt) + n->sel.nkeys*sizeof(u64),
765			n->pf);
766#endif
767	}
768
769	nla_nest_end(skb, nest);
770
771	if (TC_U32_KEY(n->handle))
772		if (tcf_exts_dump_stats(skb, &n->exts, &u32_ext_map) < 0)
773			goto nla_put_failure;
774	return skb->len;
775
776nla_put_failure:
777	nla_nest_cancel(skb, nest);
778	return -1;
779}
780
781static struct tcf_proto_ops cls_u32_ops __read_mostly = {
782	.kind		=	"u32",
783	.classify	=	u32_classify,
784	.init		=	u32_init,
785	.destroy	=	u32_destroy,
786	.get		=	u32_get,
787	.put		=	u32_put,
788	.change		=	u32_change,
789	.delete		=	u32_delete,
790	.walk		=	u32_walk,
791	.dump		=	u32_dump,
792	.owner		=	THIS_MODULE,
793};
794
795static int __init init_u32(void)
796{
797	pr_info("u32 classifier\n");
798#ifdef CONFIG_CLS_U32_PERF
799	pr_info("    Performance counters on\n");
800#endif
801#ifdef CONFIG_NET_CLS_IND
802	pr_info("    input device check on\n");
803#endif
804#ifdef CONFIG_NET_CLS_ACT
805	pr_info("    Actions configured\n");
806#endif
807	return register_tcf_proto_ops(&cls_u32_ops);
808}
809
810static void __exit exit_u32(void)
811{
812	unregister_tcf_proto_ops(&cls_u32_ops);
813}
814
815module_init(init_u32)
816module_exit(exit_u32)
817MODULE_LICENSE("GPL");
818