1/*
  2 * net/sched/act_simple.c	Simple example of an action
  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:	Jamal Hadi Salim (2005-8)
 10 *
 11 */
 12
 13#include <linux/module.h>
 14#include <linux/slab.h>
 15#include <linux/init.h>
 16#include <linux/kernel.h>
 17#include <linux/skbuff.h>
 18#include <linux/rtnetlink.h>
 19#include <net/netlink.h>
 20#include <net/pkt_sched.h>
 21
 22#define TCA_ACT_SIMP 22
 23
 24#include <linux/tc_act/tc_defact.h>
 25#include <net/tc_act/tc_defact.h>
 26
 27#define SIMP_TAB_MASK     7
 28
 29static unsigned int simp_net_id;
 30static struct tc_action_ops act_simp_ops;
 31
 32#define SIMP_MAX_DATA	32
 33static int tcf_simp(struct sk_buff *skb, const struct tc_action *a,
 34		    struct tcf_result *res)
 
 35{
 36	struct tcf_defact *d = to_defact(a);
 37
 38	spin_lock(&d->tcf_lock);
 39	tcf_lastuse_update(&d->tcf_tm);
 40	bstats_update(&d->tcf_bstats, skb);
 41
 42	/* print policy string followed by _ then packet count
 43	 * Example if this was the 3rd packet and the string was "hello"
 44	 * then it would look like "hello_3" (without quotes)
 45	 */
 46	pr_info("simple: %s_%d\n",
 47	       (char *)d->tcfd_defdata, d->tcf_bstats.packets);
 
 48	spin_unlock(&d->tcf_lock);
 49	return d->tcf_action;
 50}
 51
 52static void tcf_simp_release(struct tc_action *a, int bind)
 53{
 54	struct tcf_defact *d = to_defact(a);
 55	kfree(d->tcfd_defdata);
 56}
 57
 58static int alloc_defdata(struct tcf_defact *d, char *defdata)
 59{
 60	d->tcfd_defdata = kzalloc(SIMP_MAX_DATA, GFP_KERNEL);
 61	if (unlikely(!d->tcfd_defdata))
 62		return -ENOMEM;
 63	strlcpy(d->tcfd_defdata, defdata, SIMP_MAX_DATA);
 64	return 0;
 65}
 66
 67static void reset_policy(struct tcf_defact *d, char *defdata,
 68			 struct tc_defact *p)
 
 69{
 
 
 
 
 
 
 
 
 70	spin_lock_bh(&d->tcf_lock);
 71	d->tcf_action = p->action;
 72	memset(d->tcfd_defdata, 0, SIMP_MAX_DATA);
 73	strlcpy(d->tcfd_defdata, defdata, SIMP_MAX_DATA);
 74	spin_unlock_bh(&d->tcf_lock);
 
 
 
 75}
 76
 77static const struct nla_policy simple_policy[TCA_DEF_MAX + 1] = {
 78	[TCA_DEF_PARMS]	= { .len = sizeof(struct tc_defact) },
 79	[TCA_DEF_DATA]	= { .type = NLA_STRING, .len = SIMP_MAX_DATA },
 80};
 81
 82static int tcf_simp_init(struct net *net, struct nlattr *nla,
 83			 struct nlattr *est, struct tc_action **a,
 84			 int ovr, int bind)
 
 85{
 86	struct tc_action_net *tn = net_generic(net, simp_net_id);
 
 87	struct nlattr *tb[TCA_DEF_MAX + 1];
 
 88	struct tc_defact *parm;
 89	struct tcf_defact *d;
 90	bool exists = false;
 91	int ret = 0, err;
 92	char *defdata;
 93
 94	if (nla == NULL)
 95		return -EINVAL;
 96
 97	err = nla_parse_nested(tb, TCA_DEF_MAX, nla, simple_policy);
 
 98	if (err < 0)
 99		return err;
100
101	if (tb[TCA_DEF_PARMS] == NULL)
102		return -EINVAL;
103
104	parm = nla_data(tb[TCA_DEF_PARMS]);
105	exists = tcf_hash_check(tn, parm->index, a, bind);
 
 
 
 
106	if (exists && bind)
107		return 0;
108
109	if (tb[TCA_DEF_DATA] == NULL) {
110		if (exists)
111			tcf_hash_release(*a, bind);
 
 
112		return -EINVAL;
113	}
114
115	defdata = nla_data(tb[TCA_DEF_DATA]);
116
117	if (!exists) {
118		ret = tcf_hash_create(tn, parm->index, est, a,
119				      &act_simp_ops, bind, false);
120		if (ret)
 
121			return ret;
 
122
123		d = to_defact(*a);
124		ret = alloc_defdata(d, defdata);
125		if (ret < 0) {
126			tcf_hash_cleanup(*a, est);
127			return ret;
128		}
129		d->tcf_action = parm->action;
 
 
 
 
130		ret = ACT_P_CREATED;
131	} else {
132		d = to_defact(*a);
133
134		tcf_hash_release(*a, bind);
135		if (!ovr)
136			return -EEXIST;
137
138		reset_policy(d, defdata, parm);
 
 
139	}
140
141	if (ret == ACT_P_CREATED)
142		tcf_hash_insert(tn, *a);
143	return ret;
 
 
 
 
 
 
144}
145
146static int tcf_simp_dump(struct sk_buff *skb, struct tc_action *a,
147			 int bind, int ref)
148{
149	unsigned char *b = skb_tail_pointer(skb);
150	struct tcf_defact *d = to_defact(a);
151	struct tc_defact opt = {
152		.index   = d->tcf_index,
153		.refcnt  = d->tcf_refcnt - ref,
154		.bindcnt = d->tcf_bindcnt - bind,
155		.action  = d->tcf_action,
156	};
157	struct tcf_t t;
158
 
 
159	if (nla_put(skb, TCA_DEF_PARMS, sizeof(opt), &opt) ||
160	    nla_put_string(skb, TCA_DEF_DATA, d->tcfd_defdata))
161		goto nla_put_failure;
162
163	tcf_tm_dump(&t, &d->tcf_tm);
164	if (nla_put_64bit(skb, TCA_DEF_TM, sizeof(t), &t, TCA_DEF_PAD))
165		goto nla_put_failure;
 
 
166	return skb->len;
167
168nla_put_failure:
 
169	nlmsg_trim(skb, b);
170	return -1;
171}
172
173static int tcf_simp_walker(struct net *net, struct sk_buff *skb,
174			   struct netlink_callback *cb, int type,
175			   const struct tc_action_ops *ops)
176{
177	struct tc_action_net *tn = net_generic(net, simp_net_id);
178
179	return tcf_generic_walker(tn, skb, cb, type, ops);
180}
181
182static int tcf_simp_search(struct net *net, struct tc_action **a, u32 index)
183{
184	struct tc_action_net *tn = net_generic(net, simp_net_id);
185
186	return tcf_hash_search(tn, a, index);
187}
188
189static struct tc_action_ops act_simp_ops = {
190	.kind		=	"simple",
191	.type		=	TCA_ACT_SIMP,
192	.owner		=	THIS_MODULE,
193	.act		=	tcf_simp,
194	.dump		=	tcf_simp_dump,
195	.cleanup	=	tcf_simp_release,
196	.init		=	tcf_simp_init,
197	.walk		=	tcf_simp_walker,
198	.lookup		=	tcf_simp_search,
199	.size		=	sizeof(struct tcf_defact),
200};
 
201
202static __net_init int simp_init_net(struct net *net)
203{
204	struct tc_action_net *tn = net_generic(net, simp_net_id);
205
206	return tc_action_net_init(tn, &act_simp_ops, SIMP_TAB_MASK);
207}
208
209static void __net_exit simp_exit_net(struct net *net)
210{
211	struct tc_action_net *tn = net_generic(net, simp_net_id);
212
213	tc_action_net_exit(tn);
214}
215
216static struct pernet_operations simp_net_ops = {
217	.init = simp_init_net,
218	.exit = simp_exit_net,
219	.id   = &simp_net_id,
220	.size = sizeof(struct tc_action_net),
221};
222
223MODULE_AUTHOR("Jamal Hadi Salim(2005)");
224MODULE_DESCRIPTION("Simple example action");
225MODULE_LICENSE("GPL");
226
227static int __init simp_init_module(void)
228{
229	int ret = tcf_register_action(&act_simp_ops, &simp_net_ops);
230	if (!ret)
231		pr_info("Simple TC action Loaded\n");
232	return ret;
233}
234
235static void __exit simp_cleanup_module(void)
236{
237	tcf_unregister_action(&act_simp_ops, &simp_net_ops);
238}
239
240module_init(simp_init_module);
241module_exit(simp_cleanup_module);

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * net/sched/act_simple.c	Simple example of an action
  4 *
 
 
 
 
 
  5 * Authors:	Jamal Hadi Salim (2005-8)
 
  6 */
  7
  8#include <linux/module.h>
  9#include <linux/slab.h>
 10#include <linux/init.h>
 11#include <linux/kernel.h>
 12#include <linux/skbuff.h>
 13#include <linux/rtnetlink.h>
 14#include <net/netlink.h>
 15#include <net/pkt_sched.h>
 16#include <net/pkt_cls.h>
 17#include <net/tc_wrapper.h>
 18
 19#include <linux/tc_act/tc_defact.h>
 20#include <net/tc_act/tc_defact.h>
 21
 
 
 
 22static struct tc_action_ops act_simp_ops;
 23
 24#define SIMP_MAX_DATA	32
 25TC_INDIRECT_SCOPE int tcf_simp_act(struct sk_buff *skb,
 26				   const struct tc_action *a,
 27				   struct tcf_result *res)
 28{
 29	struct tcf_defact *d = to_defact(a);
 30
 31	spin_lock(&d->tcf_lock);
 32	tcf_lastuse_update(&d->tcf_tm);
 33	bstats_update(&d->tcf_bstats, skb);
 34
 35	/* print policy string followed by _ then packet count
 36	 * Example if this was the 3rd packet and the string was "hello"
 37	 * then it would look like "hello_3" (without quotes)
 38	 */
 39	pr_info("simple: %s_%llu\n",
 40		(char *)d->tcfd_defdata,
 41		u64_stats_read(&d->tcf_bstats.packets));
 42	spin_unlock(&d->tcf_lock);
 43	return d->tcf_action;
 44}
 45
 46static void tcf_simp_release(struct tc_action *a)
 47{
 48	struct tcf_defact *d = to_defact(a);
 49	kfree(d->tcfd_defdata);
 50}
 51
 52static int alloc_defdata(struct tcf_defact *d, const struct nlattr *defdata)
 53{
 54	d->tcfd_defdata = kzalloc(SIMP_MAX_DATA, GFP_KERNEL);
 55	if (unlikely(!d->tcfd_defdata))
 56		return -ENOMEM;
 57	nla_strscpy(d->tcfd_defdata, defdata, SIMP_MAX_DATA);
 58	return 0;
 59}
 60
 61static int reset_policy(struct tc_action *a, const struct nlattr *defdata,
 62			struct tc_defact *p, struct tcf_proto *tp,
 63			struct netlink_ext_ack *extack)
 64{
 65	struct tcf_chain *goto_ch = NULL;
 66	struct tcf_defact *d;
 67	int err;
 68
 69	err = tcf_action_check_ctrlact(p->action, tp, &goto_ch, extack);
 70	if (err < 0)
 71		return err;
 72	d = to_defact(a);
 73	spin_lock_bh(&d->tcf_lock);
 74	goto_ch = tcf_action_set_ctrlact(a, p->action, goto_ch);
 75	memset(d->tcfd_defdata, 0, SIMP_MAX_DATA);
 76	nla_strscpy(d->tcfd_defdata, defdata, SIMP_MAX_DATA);
 77	spin_unlock_bh(&d->tcf_lock);
 78	if (goto_ch)
 79		tcf_chain_put_by_act(goto_ch);
 80	return 0;
 81}
 82
 83static const struct nla_policy simple_policy[TCA_DEF_MAX + 1] = {
 84	[TCA_DEF_PARMS]	= { .len = sizeof(struct tc_defact) },
 85	[TCA_DEF_DATA]	= { .type = NLA_STRING, .len = SIMP_MAX_DATA },
 86};
 87
 88static int tcf_simp_init(struct net *net, struct nlattr *nla,
 89			 struct nlattr *est, struct tc_action **a,
 90			 struct tcf_proto *tp, u32 flags,
 91			 struct netlink_ext_ack *extack)
 92{
 93	struct tc_action_net *tn = net_generic(net, act_simp_ops.net_id);
 94	bool bind = flags & TCA_ACT_FLAGS_BIND;
 95	struct nlattr *tb[TCA_DEF_MAX + 1];
 96	struct tcf_chain *goto_ch = NULL;
 97	struct tc_defact *parm;
 98	struct tcf_defact *d;
 99	bool exists = false;
100	int ret = 0, err;
101	u32 index;
102
103	if (nla == NULL)
104		return -EINVAL;
105
106	err = nla_parse_nested_deprecated(tb, TCA_DEF_MAX, nla, simple_policy,
107					  NULL);
108	if (err < 0)
109		return err;
110
111	if (tb[TCA_DEF_PARMS] == NULL)
112		return -EINVAL;
113
114	parm = nla_data(tb[TCA_DEF_PARMS]);
115	index = parm->index;
116	err = tcf_idr_check_alloc(tn, &index, a, bind);
117	if (err < 0)
118		return err;
119	exists = err;
120	if (exists && bind)
121		return ACT_P_BOUND;
122
123	if (tb[TCA_DEF_DATA] == NULL) {
124		if (exists)
125			tcf_idr_release(*a, bind);
126		else
127			tcf_idr_cleanup(tn, index);
128		return -EINVAL;
129	}
130
 
 
131	if (!exists) {
132		ret = tcf_idr_create(tn, index, est, a,
133				     &act_simp_ops, bind, false, flags);
134		if (ret) {
135			tcf_idr_cleanup(tn, index);
136			return ret;
137		}
138
139		d = to_defact(*a);
140		err = tcf_action_check_ctrlact(parm->action, tp, &goto_ch,
141					       extack);
142		if (err < 0)
143			goto release_idr;
144
145		err = alloc_defdata(d, tb[TCA_DEF_DATA]);
146		if (err < 0)
147			goto put_chain;
148
149		tcf_action_set_ctrlact(*a, parm->action, goto_ch);
150		ret = ACT_P_CREATED;
151	} else {
152		if (!(flags & TCA_ACT_FLAGS_REPLACE)) {
153			err = -EEXIST;
154			goto release_idr;
155		}
 
156
157		err = reset_policy(*a, tb[TCA_DEF_DATA], parm, tp, extack);
158		if (err)
159			goto release_idr;
160	}
161
 
 
162	return ret;
163put_chain:
164	if (goto_ch)
165		tcf_chain_put_by_act(goto_ch);
166release_idr:
167	tcf_idr_release(*a, bind);
168	return err;
169}
170
171static int tcf_simp_dump(struct sk_buff *skb, struct tc_action *a,
172			 int bind, int ref)
173{
174	unsigned char *b = skb_tail_pointer(skb);
175	struct tcf_defact *d = to_defact(a);
176	struct tc_defact opt = {
177		.index   = d->tcf_index,
178		.refcnt  = refcount_read(&d->tcf_refcnt) - ref,
179		.bindcnt = atomic_read(&d->tcf_bindcnt) - bind,
 
180	};
181	struct tcf_t t;
182
183	spin_lock_bh(&d->tcf_lock);
184	opt.action = d->tcf_action;
185	if (nla_put(skb, TCA_DEF_PARMS, sizeof(opt), &opt) ||
186	    nla_put_string(skb, TCA_DEF_DATA, d->tcfd_defdata))
187		goto nla_put_failure;
188
189	tcf_tm_dump(&t, &d->tcf_tm);
190	if (nla_put_64bit(skb, TCA_DEF_TM, sizeof(t), &t, TCA_DEF_PAD))
191		goto nla_put_failure;
192	spin_unlock_bh(&d->tcf_lock);
193
194	return skb->len;
195
196nla_put_failure:
197	spin_unlock_bh(&d->tcf_lock);
198	nlmsg_trim(skb, b);
199	return -1;
200}
201
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
202static struct tc_action_ops act_simp_ops = {
203	.kind		=	"simple",
204	.id		=	TCA_ID_SIMP,
205	.owner		=	THIS_MODULE,
206	.act		=	tcf_simp_act,
207	.dump		=	tcf_simp_dump,
208	.cleanup	=	tcf_simp_release,
209	.init		=	tcf_simp_init,
 
 
210	.size		=	sizeof(struct tcf_defact),
211};
212MODULE_ALIAS_NET_ACT("simple");
213
214static __net_init int simp_init_net(struct net *net)
215{
216	struct tc_action_net *tn = net_generic(net, act_simp_ops.net_id);
217
218	return tc_action_net_init(net, tn, &act_simp_ops);
219}
220
221static void __net_exit simp_exit_net(struct list_head *net_list)
222{
223	tc_action_net_exit(net_list, act_simp_ops.net_id);
 
 
224}
225
226static struct pernet_operations simp_net_ops = {
227	.init = simp_init_net,
228	.exit_batch = simp_exit_net,
229	.id   = &act_simp_ops.net_id,
230	.size = sizeof(struct tc_action_net),
231};
232
233MODULE_AUTHOR("Jamal Hadi Salim(2005)");
234MODULE_DESCRIPTION("Simple example action");
235MODULE_LICENSE("GPL");
236
237static int __init simp_init_module(void)
238{
239	int ret = tcf_register_action(&act_simp_ops, &simp_net_ops);
240	if (!ret)
241		pr_info("Simple TC action Loaded\n");
242	return ret;
243}
244
245static void __exit simp_cleanup_module(void)
246{
247	tcf_unregister_action(&act_simp_ops, &simp_net_ops);
248}
249
250module_init(simp_init_module);
251module_exit(simp_cleanup_module);