File Index
Files and directories
Sign in
FILE

cls_flow.c

File preview with syntax highlighting.

linux-6.19.14/net/sched/cls_flow.c C 
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * net/sched/cls_flow.c		Generic flow classifier
  4 *
  5 * Copyright (c) 2007, 2008 Patrick McHardy <kaber@trash.net>
  6 */
  7
  8#include <linux/kernel.h>
  9#include <linux/init.h>
 10#include <linux/list.h>
 11#include <linux/jhash.h>
 12#include <linux/random.h>
 13#include <linux/pkt_cls.h>
 14#include <linux/skbuff.h>
 15#include <linux/in.h>
 16#include <linux/ip.h>
 17#include <linux/ipv6.h>
 18#include <linux/if_vlan.h>
 19#include <linux/slab.h>
 20#include <linux/module.h>
 21#include <net/inet_sock.h>
 22
 23#include <net/pkt_cls.h>
 24#include <net/ip.h>
 25#include <net/route.h>
 26#include <net/flow_dissector.h>
 27#include <net/tc_wrapper.h>
 28
 29#if IS_ENABLED(CONFIG_NF_CONNTRACK)
 30#include <net/netfilter/nf_conntrack.h>
 31#endif
 32
 33struct flow_head {
 34	struct list_head	filters;
 35	struct rcu_head		rcu;
 36};
 37
 38struct flow_filter {
 39	struct list_head	list;
 40	struct tcf_exts		exts;
 41	struct tcf_ematch_tree	ematches;
 42	struct tcf_proto	*tp;
 43	struct timer_list	perturb_timer;
 44	u32			perturb_period;
 45	u32			handle;
 46
 47	u32			nkeys;
 48	u32			keymask;
 49	u32			mode;
 50	u32			mask;
 51	u32			xor;
 52	u32			rshift;
 53	u32			addend;
 54	u32			divisor;
 55	u32			baseclass;
 56	u32			hashrnd;
 57	struct rcu_work		rwork;
 58};
 59
 60static inline u32 addr_fold(void *addr)
 61{
 62	unsigned long a = (unsigned long)addr;
 63
 64	return (a & 0xFFFFFFFF) ^ (BITS_PER_LONG > 32 ? a >> 32 : 0);
 65}
 66
 67static u32 flow_get_src(const struct sk_buff *skb, const struct flow_keys *flow)
 68{
 69	__be32 src = flow_get_u32_src(flow);
 70
 71	if (src)
 72		return ntohl(src);
 73
 74	return addr_fold(skb->sk);
 75}
 76
 77static u32 flow_get_dst(const struct sk_buff *skb, const struct flow_keys *flow)
 78{
 79	__be32 dst = flow_get_u32_dst(flow);
 80
 81	if (dst)
 82		return ntohl(dst);
 83
 84	return addr_fold(skb_dst(skb)) ^ (__force u16)skb_protocol(skb, true);
 85}
 86
 87static u32 flow_get_proto(const struct sk_buff *skb,
 88			  const struct flow_keys *flow)
 89{
 90	return flow->basic.ip_proto;
 91}
 92
 93static u32 flow_get_proto_src(const struct sk_buff *skb,
 94			      const struct flow_keys *flow)
 95{
 96	if (flow->ports.ports)
 97		return ntohs(flow->ports.src);
 98
 99	return addr_fold(skb->sk);
100}
101
102static u32 flow_get_proto_dst(const struct sk_buff *skb,
103			      const struct flow_keys *flow)
104{
105	if (flow->ports.ports)
106		return ntohs(flow->ports.dst);
107
108	return addr_fold(skb_dst(skb)) ^ (__force u16)skb_protocol(skb, true);
109}
110
111static u32 flow_get_iif(const struct sk_buff *skb)
112{
113	return skb->skb_iif;
114}
115
116static u32 flow_get_priority(const struct sk_buff *skb)
117{
118	return skb->priority;
119}
120
121static u32 flow_get_mark(const struct sk_buff *skb)
122{
123	return skb->mark;
124}
125
126static u32 flow_get_nfct(const struct sk_buff *skb)
127{
128#if IS_ENABLED(CONFIG_NF_CONNTRACK)
129	return addr_fold(skb_nfct(skb));
130#else
131	return 0;
132#endif
133}
134
135#if IS_ENABLED(CONFIG_NF_CONNTRACK)
136#define CTTUPLE(skb, member)						\
137({									\
138	enum ip_conntrack_info ctinfo;					\
139	const struct nf_conn *ct = nf_ct_get(skb, &ctinfo);		\
140	if (ct == NULL)							\
141		goto fallback;						\
142	ct->tuplehash[CTINFO2DIR(ctinfo)].tuple.member;			\
143})
144#else
145#define CTTUPLE(skb, member)						\
146({									\
147	goto fallback;							\
148	0;								\
149})
150#endif
151
152static u32 flow_get_nfct_src(const struct sk_buff *skb,
153			     const struct flow_keys *flow)
154{
155	switch (skb_protocol(skb, true)) {
156	case htons(ETH_P_IP):
157		return ntohl(CTTUPLE(skb, src.u3.ip));
158	case htons(ETH_P_IPV6):
159		return ntohl(CTTUPLE(skb, src.u3.ip6[3]));
160	}
161fallback:
162	return flow_get_src(skb, flow);
163}
164
165static u32 flow_get_nfct_dst(const struct sk_buff *skb,
166			     const struct flow_keys *flow)
167{
168	switch (skb_protocol(skb, true)) {
169	case htons(ETH_P_IP):
170		return ntohl(CTTUPLE(skb, dst.u3.ip));
171	case htons(ETH_P_IPV6):
172		return ntohl(CTTUPLE(skb, dst.u3.ip6[3]));
173	}
174fallback:
175	return flow_get_dst(skb, flow);
176}
177
178static u32 flow_get_nfct_proto_src(const struct sk_buff *skb,
179				   const struct flow_keys *flow)
180{
181	return ntohs(CTTUPLE(skb, src.u.all));
182fallback:
183	return flow_get_proto_src(skb, flow);
184}
185
186static u32 flow_get_nfct_proto_dst(const struct sk_buff *skb,
187				   const struct flow_keys *flow)
188{
189	return ntohs(CTTUPLE(skb, dst.u.all));
190fallback:
191	return flow_get_proto_dst(skb, flow);
192}
193
194static u32 flow_get_rtclassid(const struct sk_buff *skb)
195{
196#ifdef CONFIG_IP_ROUTE_CLASSID
197	if (skb_dst(skb))
198		return skb_dst(skb)->tclassid;
199#endif
200	return 0;
201}
202
203static u32 flow_get_skuid(const struct sk_buff *skb)
204{
205	struct sock *sk = skb_to_full_sk(skb);
206
207	if (sk && sk->sk_socket && sk->sk_socket->file) {
208		kuid_t skuid = sk->sk_socket->file->f_cred->fsuid;
209
210		return from_kuid(&init_user_ns, skuid);
211	}
212	return 0;
213}
214
215static u32 flow_get_skgid(const struct sk_buff *skb)
216{
217	struct sock *sk = skb_to_full_sk(skb);
218
219	if (sk && sk->sk_socket && sk->sk_socket->file) {
220		kgid_t skgid = sk->sk_socket->file->f_cred->fsgid;
221
222		return from_kgid(&init_user_ns, skgid);
223	}
224	return 0;
225}
226
227static u32 flow_get_vlan_tag(const struct sk_buff *skb)
228{
229	u16 tag;
230
231	if (vlan_get_tag(skb, &tag) < 0)
232		return 0;
233	return tag & VLAN_VID_MASK;
234}
235
236static u32 flow_get_rxhash(struct sk_buff *skb)
237{
238	return skb_get_hash(skb);
239}
240
241static u32 flow_key_get(struct sk_buff *skb, int key, struct flow_keys *flow)
242{
243	switch (key) {
244	case FLOW_KEY_SRC:
245		return flow_get_src(skb, flow);
246	case FLOW_KEY_DST:
247		return flow_get_dst(skb, flow);
248	case FLOW_KEY_PROTO:
249		return flow_get_proto(skb, flow);
250	case FLOW_KEY_PROTO_SRC:
251		return flow_get_proto_src(skb, flow);
252	case FLOW_KEY_PROTO_DST:
253		return flow_get_proto_dst(skb, flow);
254	case FLOW_KEY_IIF:
255		return flow_get_iif(skb);
256	case FLOW_KEY_PRIORITY:
257		return flow_get_priority(skb);
258	case FLOW_KEY_MARK:
259		return flow_get_mark(skb);
260	case FLOW_KEY_NFCT:
261		return flow_get_nfct(skb);
262	case FLOW_KEY_NFCT_SRC:
263		return flow_get_nfct_src(skb, flow);
264	case FLOW_KEY_NFCT_DST:
265		return flow_get_nfct_dst(skb, flow);
266	case FLOW_KEY_NFCT_PROTO_SRC:
267		return flow_get_nfct_proto_src(skb, flow);
268	case FLOW_KEY_NFCT_PROTO_DST:
269		return flow_get_nfct_proto_dst(skb, flow);
270	case FLOW_KEY_RTCLASSID:
271		return flow_get_rtclassid(skb);
272	case FLOW_KEY_SKUID:
273		return flow_get_skuid(skb);
274	case FLOW_KEY_SKGID:
275		return flow_get_skgid(skb);
276	case FLOW_KEY_VLAN_TAG:
277		return flow_get_vlan_tag(skb);
278	case FLOW_KEY_RXHASH:
279		return flow_get_rxhash(skb);
280	default:
281		WARN_ON(1);
282		return 0;
283	}
284}
285
286#define FLOW_KEYS_NEEDED ((1 << FLOW_KEY_SRC) | 		\
287			  (1 << FLOW_KEY_DST) |			\
288			  (1 << FLOW_KEY_PROTO) |		\
289			  (1 << FLOW_KEY_PROTO_SRC) |		\
290			  (1 << FLOW_KEY_PROTO_DST) | 		\
291			  (1 << FLOW_KEY_NFCT_SRC) |		\
292			  (1 << FLOW_KEY_NFCT_DST) |		\
293			  (1 << FLOW_KEY_NFCT_PROTO_SRC) |	\
294			  (1 << FLOW_KEY_NFCT_PROTO_DST))
295
296TC_INDIRECT_SCOPE int flow_classify(struct sk_buff *skb,
297				    const struct tcf_proto *tp,
298				    struct tcf_result *res)
299{
300	struct flow_head *head = rcu_dereference_bh(tp->root);
301	struct flow_filter *f;
302	u32 keymask;
303	u32 classid;
304	unsigned int n, key;
305	int r;
306
307	list_for_each_entry_rcu(f, &head->filters, list) {
308		u32 keys[FLOW_KEY_MAX + 1];
309		struct flow_keys flow_keys;
310
311		if (!tcf_em_tree_match(skb, &f->ematches, NULL))
312			continue;
313
314		keymask = f->keymask;
315		if (keymask & FLOW_KEYS_NEEDED)
316			skb_flow_dissect_flow_keys(skb, &flow_keys, 0);
317
318		for (n = 0; n < f->nkeys; n++) {
319			key = ffs(keymask) - 1;
320			keymask &= ~(1 << key);
321			keys[n] = flow_key_get(skb, key, &flow_keys);
322		}
323
324		if (f->mode == FLOW_MODE_HASH)
325			classid = jhash2(keys, f->nkeys, f->hashrnd);
326		else {
327			classid = keys[0];
328			classid = (classid & f->mask) ^ f->xor;
329			classid = (classid >> f->rshift) + f->addend;
330		}
331
332		if (f->divisor)
333			classid %= f->divisor;
334
335		res->class   = 0;
336		res->classid = TC_H_MAKE(f->baseclass, f->baseclass + classid);
337
338		r = tcf_exts_exec(skb, &f->exts, res);
339		if (r < 0)
340			continue;
341		return r;
342	}
343	return -1;
344}
345
346static void flow_perturbation(struct timer_list *t)
347{
348	struct flow_filter *f = timer_container_of(f, t, perturb_timer);
349
350	get_random_bytes(&f->hashrnd, 4);
351	if (f->perturb_period)
352		mod_timer(&f->perturb_timer, jiffies + f->perturb_period);
353}
354
355static const struct nla_policy flow_policy[TCA_FLOW_MAX + 1] = {
356	[TCA_FLOW_KEYS]		= { .type = NLA_U32 },
357	[TCA_FLOW_MODE]		= { .type = NLA_U32 },
358	[TCA_FLOW_BASECLASS]	= { .type = NLA_U32 },
359	[TCA_FLOW_RSHIFT]	= NLA_POLICY_MAX(NLA_U32,
360						 31 /* BITS_PER_U32 - 1 */),
361	[TCA_FLOW_ADDEND]	= { .type = NLA_U32 },
362	[TCA_FLOW_MASK]		= { .type = NLA_U32 },
363	[TCA_FLOW_XOR]		= { .type = NLA_U32 },
364	[TCA_FLOW_DIVISOR]	= { .type = NLA_U32 },
365	[TCA_FLOW_ACT]		= { .type = NLA_NESTED },
366	[TCA_FLOW_POLICE]	= { .type = NLA_NESTED },
367	[TCA_FLOW_EMATCHES]	= { .type = NLA_NESTED },
368	[TCA_FLOW_PERTURB]	= { .type = NLA_U32 },
369};
370
371static void __flow_destroy_filter(struct flow_filter *f)
372{
373	timer_shutdown_sync(&f->perturb_timer);
374	tcf_exts_destroy(&f->exts);
375	tcf_em_tree_destroy(&f->ematches);
376	tcf_exts_put_net(&f->exts);
377	kfree(f);
378}
379
380static void flow_destroy_filter_work(struct work_struct *work)
381{
382	struct flow_filter *f = container_of(to_rcu_work(work),
383					     struct flow_filter,
384					     rwork);
385	rtnl_lock();
386	__flow_destroy_filter(f);
387	rtnl_unlock();
388}
389
390static int flow_change(struct net *net, struct sk_buff *in_skb,
391		       struct tcf_proto *tp, unsigned long base,
392		       u32 handle, struct nlattr **tca,
393		       void **arg, u32 flags,
394		       struct netlink_ext_ack *extack)
395{
396	struct flow_head *head = rtnl_dereference(tp->root);
397	struct flow_filter *fold, *fnew;
398	struct nlattr *opt = tca[TCA_OPTIONS];
399	struct nlattr *tb[TCA_FLOW_MAX + 1];
400	unsigned int nkeys = 0;
401	unsigned int perturb_period = 0;
402	u32 baseclass = 0;
403	u32 keymask = 0;
404	u32 mode;
405	int err;
406
407	if (opt == NULL)
408		return -EINVAL;
409
410	err = nla_parse_nested_deprecated(tb, TCA_FLOW_MAX, opt, flow_policy,
411					  NULL);
412	if (err < 0)
413		return err;
414
415	if (tb[TCA_FLOW_BASECLASS]) {
416		baseclass = nla_get_u32(tb[TCA_FLOW_BASECLASS]);
417		if (TC_H_MIN(baseclass) == 0)
418			return -EINVAL;
419	}
420
421	if (tb[TCA_FLOW_KEYS]) {
422		keymask = nla_get_u32(tb[TCA_FLOW_KEYS]);
423
424		nkeys = hweight32(keymask);
425		if (nkeys == 0)
426			return -EINVAL;
427
428		if (fls(keymask) - 1 > FLOW_KEY_MAX)
429			return -EOPNOTSUPP;
430
431		if ((keymask & (FLOW_KEY_SKUID|FLOW_KEY_SKGID)) &&
432		    sk_user_ns(NETLINK_CB(in_skb).sk) != &init_user_ns)
433			return -EOPNOTSUPP;
434	}
435
436	fnew = kzalloc(sizeof(*fnew), GFP_KERNEL);
437	if (!fnew)
438		return -ENOBUFS;
439
440	err = tcf_em_tree_validate(tp, tb[TCA_FLOW_EMATCHES], &fnew->ematches);
441	if (err < 0)
442		goto err1;
443
444	err = tcf_exts_init(&fnew->exts, net, TCA_FLOW_ACT, TCA_FLOW_POLICE);
445	if (err < 0)
446		goto err2;
447
448	err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &fnew->exts, flags,
449				extack);
450	if (err < 0)
451		goto err2;
452
453	fold = *arg;
454	if (fold) {
455		err = -EINVAL;
456		if (fold->handle != handle && handle)
457			goto err2;
458
459		/* Copy fold into fnew */
460		fnew->tp = fold->tp;
461		fnew->handle = fold->handle;
462		fnew->nkeys = fold->nkeys;
463		fnew->keymask = fold->keymask;
464		fnew->mode = fold->mode;
465		fnew->mask = fold->mask;
466		fnew->xor = fold->xor;
467		fnew->rshift = fold->rshift;
468		fnew->addend = fold->addend;
469		fnew->divisor = fold->divisor;
470		fnew->baseclass = fold->baseclass;
471		fnew->hashrnd = fold->hashrnd;
472
473		mode = fold->mode;
474		if (tb[TCA_FLOW_MODE])
475			mode = nla_get_u32(tb[TCA_FLOW_MODE]);
476		if (mode != FLOW_MODE_HASH && nkeys > 1)
477			goto err2;
478
479		if (mode == FLOW_MODE_HASH)
480			perturb_period = fold->perturb_period;
481		if (tb[TCA_FLOW_PERTURB]) {
482			if (mode != FLOW_MODE_HASH)
483				goto err2;
484			perturb_period = nla_get_u32(tb[TCA_FLOW_PERTURB]) * HZ;
485		}
486	} else {
487		err = -EINVAL;
488		if (!handle)
489			goto err2;
490		if (!tb[TCA_FLOW_KEYS])
491			goto err2;
492
493		mode = FLOW_MODE_MAP;
494		if (tb[TCA_FLOW_MODE])
495			mode = nla_get_u32(tb[TCA_FLOW_MODE]);
496		if (mode != FLOW_MODE_HASH && nkeys > 1)
497			goto err2;
498
499		if (tb[TCA_FLOW_PERTURB]) {
500			if (mode != FLOW_MODE_HASH)
501				goto err2;
502			perturb_period = nla_get_u32(tb[TCA_FLOW_PERTURB]) * HZ;
503		}
504
505		if (TC_H_MAJ(baseclass) == 0) {
506			struct tcf_block *block = tp->chain->block;
507			struct Qdisc *q;
508
509			if (tcf_block_shared(block)) {
510				NL_SET_ERR_MSG(extack,
511					       "Must specify baseclass when attaching flow filter to block");
512				goto err2;
513			}
514
515			q = tcf_block_q(block);
516			baseclass = TC_H_MAKE(q->handle, baseclass);
517		}
518		if (TC_H_MIN(baseclass) == 0)
519			baseclass = TC_H_MAKE(baseclass, 1);
520
521		fnew->handle = handle;
522		fnew->mask  = ~0U;
523		fnew->tp = tp;
524		get_random_bytes(&fnew->hashrnd, 4);
525	}
526
527	timer_setup(&fnew->perturb_timer, flow_perturbation, TIMER_DEFERRABLE);
528
529	tcf_block_netif_keep_dst(tp->chain->block);
530
531	if (tb[TCA_FLOW_KEYS]) {
532		fnew->keymask = keymask;
533		fnew->nkeys   = nkeys;
534	}
535
536	fnew->mode = mode;
537
538	if (tb[TCA_FLOW_MASK])
539		fnew->mask = nla_get_u32(tb[TCA_FLOW_MASK]);
540	if (tb[TCA_FLOW_XOR])
541		fnew->xor = nla_get_u32(tb[TCA_FLOW_XOR]);
542	if (tb[TCA_FLOW_RSHIFT])
543		fnew->rshift = nla_get_u32(tb[TCA_FLOW_RSHIFT]);
544	if (tb[TCA_FLOW_ADDEND])
545		fnew->addend = nla_get_u32(tb[TCA_FLOW_ADDEND]);
546
547	if (tb[TCA_FLOW_DIVISOR])
548		fnew->divisor = nla_get_u32(tb[TCA_FLOW_DIVISOR]);
549	if (baseclass)
550		fnew->baseclass = baseclass;
551
552	fnew->perturb_period = perturb_period;
553	if (perturb_period)
554		mod_timer(&fnew->perturb_timer, jiffies + perturb_period);
555
556	if (!*arg)
557		list_add_tail_rcu(&fnew->list, &head->filters);
558	else
559		list_replace_rcu(&fold->list, &fnew->list);
560
561	*arg = fnew;
562
563	if (fold) {
564		tcf_exts_get_net(&fold->exts);
565		tcf_queue_work(&fold->rwork, flow_destroy_filter_work);
566	}
567	return 0;
568
569err2:
570	tcf_exts_destroy(&fnew->exts);
571	tcf_em_tree_destroy(&fnew->ematches);
572err1:
573	kfree(fnew);
574	return err;
575}
576
577static int flow_delete(struct tcf_proto *tp, void *arg, bool *last,
578		       bool rtnl_held, struct netlink_ext_ack *extack)
579{
580	struct flow_head *head = rtnl_dereference(tp->root);
581	struct flow_filter *f = arg;
582
583	list_del_rcu(&f->list);
584	tcf_exts_get_net(&f->exts);
585	tcf_queue_work(&f->rwork, flow_destroy_filter_work);
586	*last = list_empty(&head->filters);
587	return 0;
588}
589
590static int flow_init(struct tcf_proto *tp)
591{
592	struct flow_head *head;
593
594	head = kzalloc(sizeof(*head), GFP_KERNEL);
595	if (head == NULL)
596		return -ENOBUFS;
597	INIT_LIST_HEAD(&head->filters);
598	rcu_assign_pointer(tp->root, head);
599	return 0;
600}
601
602static void flow_destroy(struct tcf_proto *tp, bool rtnl_held,
603			 struct netlink_ext_ack *extack)
604{
605	struct flow_head *head = rtnl_dereference(tp->root);
606	struct flow_filter *f, *next;
607
608	list_for_each_entry_safe(f, next, &head->filters, list) {
609		list_del_rcu(&f->list);
610		if (tcf_exts_get_net(&f->exts))
611			tcf_queue_work(&f->rwork, flow_destroy_filter_work);
612		else
613			__flow_destroy_filter(f);
614	}
615	kfree_rcu(head, rcu);
616}
617
618static void *flow_get(struct tcf_proto *tp, u32 handle)
619{
620	struct flow_head *head = rtnl_dereference(tp->root);
621	struct flow_filter *f;
622
623	list_for_each_entry(f, &head->filters, list)
624		if (f->handle == handle)
625			return f;
626	return NULL;
627}
628
629static int flow_dump(struct net *net, struct tcf_proto *tp, void *fh,
630		     struct sk_buff *skb, struct tcmsg *t, bool rtnl_held)
631{
632	struct flow_filter *f = fh;
633	struct nlattr *nest;
634
635	if (f == NULL)
636		return skb->len;
637
638	t->tcm_handle = f->handle;
639
640	nest = nla_nest_start_noflag(skb, TCA_OPTIONS);
641	if (nest == NULL)
642		goto nla_put_failure;
643
644	if (nla_put_u32(skb, TCA_FLOW_KEYS, f->keymask) ||
645	    nla_put_u32(skb, TCA_FLOW_MODE, f->mode))
646		goto nla_put_failure;
647
648	if (f->mask != ~0 || f->xor != 0) {
649		if (nla_put_u32(skb, TCA_FLOW_MASK, f->mask) ||
650		    nla_put_u32(skb, TCA_FLOW_XOR, f->xor))
651			goto nla_put_failure;
652	}
653	if (f->rshift &&
654	    nla_put_u32(skb, TCA_FLOW_RSHIFT, f->rshift))
655		goto nla_put_failure;
656	if (f->addend &&
657	    nla_put_u32(skb, TCA_FLOW_ADDEND, f->addend))
658		goto nla_put_failure;
659
660	if (f->divisor &&
661	    nla_put_u32(skb, TCA_FLOW_DIVISOR, f->divisor))
662		goto nla_put_failure;
663	if (f->baseclass &&
664	    nla_put_u32(skb, TCA_FLOW_BASECLASS, f->baseclass))
665		goto nla_put_failure;
666
667	if (f->perturb_period &&
668	    nla_put_u32(skb, TCA_FLOW_PERTURB, f->perturb_period / HZ))
669		goto nla_put_failure;
670
671	if (tcf_exts_dump(skb, &f->exts) < 0)
672		goto nla_put_failure;
673#ifdef CONFIG_NET_EMATCH
674	if (f->ematches.hdr.nmatches &&
675	    tcf_em_tree_dump(skb, &f->ematches, TCA_FLOW_EMATCHES) < 0)
676		goto nla_put_failure;
677#endif
678	nla_nest_end(skb, nest);
679
680	if (tcf_exts_dump_stats(skb, &f->exts) < 0)
681		goto nla_put_failure;
682
683	return skb->len;
684
685nla_put_failure:
686	nla_nest_cancel(skb, nest);
687	return -1;
688}
689
690static void flow_walk(struct tcf_proto *tp, struct tcf_walker *arg,
691		      bool rtnl_held)
692{
693	struct flow_head *head = rtnl_dereference(tp->root);
694	struct flow_filter *f;
695
696	list_for_each_entry(f, &head->filters, list) {
697		if (!tc_cls_stats_dump(tp, arg, f))
698			break;
699	}
700}
701
702static struct tcf_proto_ops cls_flow_ops __read_mostly = {
703	.kind		= "flow",
704	.classify	= flow_classify,
705	.init		= flow_init,
706	.destroy	= flow_destroy,
707	.change		= flow_change,
708	.delete		= flow_delete,
709	.get		= flow_get,
710	.dump		= flow_dump,
711	.walk		= flow_walk,
712	.owner		= THIS_MODULE,
713};
714MODULE_ALIAS_NET_CLS("flow");
715
716static int __init cls_flow_init(void)
717{
718	return register_tcf_proto_ops(&cls_flow_ops);
719}
720
721static void __exit cls_flow_exit(void)
722{
723	unregister_tcf_proto_ops(&cls_flow_ops);
724}
725
726module_init(cls_flow_init);
727module_exit(cls_flow_exit);
728
729MODULE_LICENSE("GPL");
730MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
731MODULE_DESCRIPTION("TC flow classifier");
~/ Read-only file preview.