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

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

Version: ~ [ linux-5.4 ] ~ [ linux-5.3.13 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.86 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.156 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.203 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.202 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 /*
  2  * net/sched/act_skbmod.c  skb data modifier
  3  *
  4  * Copyright (c) 2016 Jamal Hadi Salim <jhs@mojatatu.com>
  5  *
  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.
 10 */
 11 
 12 #include <linux/module.h>
 13 #include <linux/init.h>
 14 #include <linux/kernel.h>
 15 #include <linux/skbuff.h>
 16 #include <linux/rtnetlink.h>
 17 #include <net/netlink.h>
 18 #include <net/pkt_sched.h>
 19 
 20 #include <linux/tc_act/tc_skbmod.h>
 21 #include <net/tc_act/tc_skbmod.h>
 22 
 23 #define SKBMOD_TAB_MASK     15
 24 
 25 static unsigned int skbmod_net_id;
 26 static struct tc_action_ops act_skbmod_ops;
 27 
 28 #define MAX_EDIT_LEN ETH_HLEN
 29 static int tcf_skbmod_run(struct sk_buff *skb, const struct tc_action *a,
 30                           struct tcf_result *res)
 31 {
 32         struct tcf_skbmod *d = to_skbmod(a);
 33         int action;
 34         struct tcf_skbmod_params *p;
 35         u64 flags;
 36         int err;
 37 
 38         tcf_lastuse_update(&d->tcf_tm);
 39         bstats_cpu_update(this_cpu_ptr(d->common.cpu_bstats), skb);
 40 
 41         /* XXX: if you are going to edit more fields beyond ethernet header
 42          * (example when you add IP header replacement or vlan swap)
 43          * then MAX_EDIT_LEN needs to change appropriately
 44         */
 45         err = skb_ensure_writable(skb, MAX_EDIT_LEN);
 46         if (unlikely(err)) { /* best policy is to drop on the floor */
 47                 qstats_overlimit_inc(this_cpu_ptr(d->common.cpu_qstats));
 48                 return TC_ACT_SHOT;
 49         }
 50 
 51         rcu_read_lock();
 52         action = READ_ONCE(d->tcf_action);
 53         if (unlikely(action == TC_ACT_SHOT)) {
 54                 qstats_overlimit_inc(this_cpu_ptr(d->common.cpu_qstats));
 55                 rcu_read_unlock();
 56                 return action;
 57         }
 58 
 59         p = rcu_dereference(d->skbmod_p);
 60         flags = p->flags;
 61         if (flags & SKBMOD_F_DMAC)
 62                 ether_addr_copy(eth_hdr(skb)->h_dest, p->eth_dst);
 63         if (flags & SKBMOD_F_SMAC)
 64                 ether_addr_copy(eth_hdr(skb)->h_source, p->eth_src);
 65         if (flags & SKBMOD_F_ETYPE)
 66                 eth_hdr(skb)->h_proto = p->eth_type;
 67         rcu_read_unlock();
 68 
 69         if (flags & SKBMOD_F_SWAPMAC) {
 70                 u16 tmpaddr[ETH_ALEN / 2]; /* ether_addr_copy() requirement */
 71                 /*XXX: I am sure we can come up with more efficient swapping*/
 72                 ether_addr_copy((u8 *)tmpaddr, eth_hdr(skb)->h_dest);
 73                 ether_addr_copy(eth_hdr(skb)->h_dest, eth_hdr(skb)->h_source);
 74                 ether_addr_copy(eth_hdr(skb)->h_source, (u8 *)tmpaddr);
 75         }
 76 
 77         return action;
 78 }
 79 
 80 static const struct nla_policy skbmod_policy[TCA_SKBMOD_MAX + 1] = {
 81         [TCA_SKBMOD_PARMS]              = { .len = sizeof(struct tc_skbmod) },
 82         [TCA_SKBMOD_DMAC]               = { .len = ETH_ALEN },
 83         [TCA_SKBMOD_SMAC]               = { .len = ETH_ALEN },
 84         [TCA_SKBMOD_ETYPE]              = { .type = NLA_U16 },
 85 };
 86 
 87 static int tcf_skbmod_init(struct net *net, struct nlattr *nla,
 88                            struct nlattr *est, struct tc_action **a,
 89                            int ovr, int bind)
 90 {
 91         struct tc_action_net *tn = net_generic(net, skbmod_net_id);
 92         struct nlattr *tb[TCA_SKBMOD_MAX + 1];
 93         struct tcf_skbmod_params *p, *p_old;
 94         struct tc_skbmod *parm;
 95         struct tcf_skbmod *d;
 96         bool exists = false;
 97         u8 *daddr = NULL;
 98         u8 *saddr = NULL;
 99         u16 eth_type = 0;
100         u32 lflags = 0;
101         int ret = 0, err;
102 
103         if (!nla)
104                 return -EINVAL;
105 
106         err = nla_parse_nested(tb, TCA_SKBMOD_MAX, nla, skbmod_policy, NULL);
107         if (err < 0)
108                 return err;
109 
110         if (!tb[TCA_SKBMOD_PARMS])
111                 return -EINVAL;
112 
113         if (tb[TCA_SKBMOD_DMAC]) {
114                 daddr = nla_data(tb[TCA_SKBMOD_DMAC]);
115                 lflags |= SKBMOD_F_DMAC;
116         }
117 
118         if (tb[TCA_SKBMOD_SMAC]) {
119                 saddr = nla_data(tb[TCA_SKBMOD_SMAC]);
120                 lflags |= SKBMOD_F_SMAC;
121         }
122 
123         if (tb[TCA_SKBMOD_ETYPE]) {
124                 eth_type = nla_get_u16(tb[TCA_SKBMOD_ETYPE]);
125                 lflags |= SKBMOD_F_ETYPE;
126         }
127 
128         parm = nla_data(tb[TCA_SKBMOD_PARMS]);
129         if (parm->flags & SKBMOD_F_SWAPMAC)
130                 lflags = SKBMOD_F_SWAPMAC;
131 
132         exists = tcf_hash_check(tn, parm->index, a, bind);
133         if (exists && bind)
134                 return 0;
135 
136         if (!lflags)
137                 return -EINVAL;
138 
139         if (!exists) {
140                 ret = tcf_hash_create(tn, parm->index, est, a,
141                                       &act_skbmod_ops, bind, true);
142                 if (ret)
143                         return ret;
144 
145                 ret = ACT_P_CREATED;
146         } else {
147                 tcf_hash_release(*a, bind);
148                 if (!ovr)
149                         return -EEXIST;
150         }
151 
152         d = to_skbmod(*a);
153 
154         ASSERT_RTNL();
155         p = kzalloc(sizeof(struct tcf_skbmod_params), GFP_KERNEL);
156         if (unlikely(!p)) {
157                 if (ovr)
158                         tcf_hash_release(*a, bind);
159                 return -ENOMEM;
160         }
161 
162         p->flags = lflags;
163         d->tcf_action = parm->action;
164 
165         p_old = rtnl_dereference(d->skbmod_p);
166 
167         if (ovr)
168                 spin_lock_bh(&d->tcf_lock);
169 
170         if (lflags & SKBMOD_F_DMAC)
171                 ether_addr_copy(p->eth_dst, daddr);
172         if (lflags & SKBMOD_F_SMAC)
173                 ether_addr_copy(p->eth_src, saddr);
174         if (lflags & SKBMOD_F_ETYPE)
175                 p->eth_type = htons(eth_type);
176 
177         rcu_assign_pointer(d->skbmod_p, p);
178         if (ovr)
179                 spin_unlock_bh(&d->tcf_lock);
180 
181         if (p_old)
182                 kfree_rcu(p_old, rcu);
183 
184         if (ret == ACT_P_CREATED)
185                 tcf_hash_insert(tn, *a);
186         return ret;
187 }
188 
189 static void tcf_skbmod_cleanup(struct tc_action *a, int bind)
190 {
191         struct tcf_skbmod *d = to_skbmod(a);
192         struct tcf_skbmod_params  *p;
193 
194         p = rcu_dereference_protected(d->skbmod_p, 1);
195         kfree_rcu(p, rcu);
196 }
197 
198 static int tcf_skbmod_dump(struct sk_buff *skb, struct tc_action *a,
199                            int bind, int ref)
200 {
201         struct tcf_skbmod *d = to_skbmod(a);
202         unsigned char *b = skb_tail_pointer(skb);
203         struct tcf_skbmod_params  *p = rtnl_dereference(d->skbmod_p);
204         struct tc_skbmod opt = {
205                 .index   = d->tcf_index,
206                 .refcnt  = d->tcf_refcnt - ref,
207                 .bindcnt = d->tcf_bindcnt - bind,
208                 .action  = d->tcf_action,
209         };
210         struct tcf_t t;
211 
212         opt.flags  = p->flags;
213         if (nla_put(skb, TCA_SKBMOD_PARMS, sizeof(opt), &opt))
214                 goto nla_put_failure;
215         if ((p->flags & SKBMOD_F_DMAC) &&
216             nla_put(skb, TCA_SKBMOD_DMAC, ETH_ALEN, p->eth_dst))
217                 goto nla_put_failure;
218         if ((p->flags & SKBMOD_F_SMAC) &&
219             nla_put(skb, TCA_SKBMOD_SMAC, ETH_ALEN, p->eth_src))
220                 goto nla_put_failure;
221         if ((p->flags & SKBMOD_F_ETYPE) &&
222             nla_put_u16(skb, TCA_SKBMOD_ETYPE, ntohs(p->eth_type)))
223                 goto nla_put_failure;
224 
225         tcf_tm_dump(&t, &d->tcf_tm);
226         if (nla_put_64bit(skb, TCA_SKBMOD_TM, sizeof(t), &t, TCA_SKBMOD_PAD))
227                 goto nla_put_failure;
228 
229         return skb->len;
230 nla_put_failure:
231         nlmsg_trim(skb, b);
232         return -1;
233 }
234 
235 static int tcf_skbmod_walker(struct net *net, struct sk_buff *skb,
236                              struct netlink_callback *cb, int type,
237                              const struct tc_action_ops *ops)
238 {
239         struct tc_action_net *tn = net_generic(net, skbmod_net_id);
240 
241         return tcf_generic_walker(tn, skb, cb, type, ops);
242 }
243 
244 static int tcf_skbmod_search(struct net *net, struct tc_action **a, u32 index)
245 {
246         struct tc_action_net *tn = net_generic(net, skbmod_net_id);
247 
248         return tcf_hash_search(tn, a, index);
249 }
250 
251 static struct tc_action_ops act_skbmod_ops = {
252         .kind           =       "skbmod",
253         .type           =       TCA_ACT_SKBMOD,
254         .owner          =       THIS_MODULE,
255         .act            =       tcf_skbmod_run,
256         .dump           =       tcf_skbmod_dump,
257         .init           =       tcf_skbmod_init,
258         .cleanup        =       tcf_skbmod_cleanup,
259         .walk           =       tcf_skbmod_walker,
260         .lookup         =       tcf_skbmod_search,
261         .size           =       sizeof(struct tcf_skbmod),
262 };
263 
264 static __net_init int skbmod_init_net(struct net *net)
265 {
266         struct tc_action_net *tn = net_generic(net, skbmod_net_id);
267 
268         return tc_action_net_init(tn, &act_skbmod_ops, SKBMOD_TAB_MASK);
269 }
270 
271 static void __net_exit skbmod_exit_net(struct net *net)
272 {
273         struct tc_action_net *tn = net_generic(net, skbmod_net_id);
274 
275         tc_action_net_exit(tn);
276 }
277 
278 static struct pernet_operations skbmod_net_ops = {
279         .init = skbmod_init_net,
280         .exit = skbmod_exit_net,
281         .id   = &skbmod_net_id,
282         .size = sizeof(struct tc_action_net),
283 };
284 
285 MODULE_AUTHOR("Jamal Hadi Salim, <jhs@mojatatu.com>");
286 MODULE_DESCRIPTION("SKB data mod-ing");
287 MODULE_LICENSE("GPL");
288 
289 static int __init skbmod_init_module(void)
290 {
291         return tcf_register_action(&act_skbmod_ops, &skbmod_net_ops);
292 }
293 
294 static void __exit skbmod_cleanup_module(void)
295 {
296         tcf_unregister_action(&act_skbmod_ops, &skbmod_net_ops);
297 }
298 
299 module_init(skbmod_init_module);
300 module_exit(skbmod_cleanup_module);
301 

~ [ 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