~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/sched/act_simple.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp