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

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

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ 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 /*
  2  * Copyright (c) 2008, Intel Corporation.
  3  *
  4  * This program is free software; you can redistribute it and/or modify it
  5  * under the terms and conditions of the GNU General Public License,
  6  * version 2, as published by the Free Software Foundation.
  7  *
  8  * This program is distributed in the hope it will be useful, but WITHOUT
  9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 11  * more details.
 12  *
 13  * You should have received a copy of the GNU General Public License along with
 14  * this program; if not, see <http://www.gnu.org/licenses/>.
 15  *
 16  * Author: Alexander Duyck <alexander.h.duyck@intel.com>
 17  */
 18 
 19 #include <linux/module.h>
 20 #include <linux/init.h>
 21 #include <linux/kernel.h>
 22 #include <linux/skbuff.h>
 23 #include <linux/rtnetlink.h>
 24 #include <net/netlink.h>
 25 #include <net/pkt_sched.h>
 26 
 27 #include <linux/tc_act/tc_skbedit.h>
 28 #include <net/tc_act/tc_skbedit.h>
 29 
 30 static unsigned int skbedit_net_id;
 31 static struct tc_action_ops act_skbedit_ops;
 32 
 33 static int tcf_skbedit(struct sk_buff *skb, const struct tc_action *a,
 34                        struct tcf_result *res)
 35 {
 36         struct tcf_skbedit *d = to_skbedit(a);
 37 
 38         spin_lock(&d->tcf_lock);
 39         tcf_lastuse_update(&d->tcf_tm);
 40         bstats_update(&d->tcf_bstats, skb);
 41 
 42         if (d->flags & SKBEDIT_F_PRIORITY)
 43                 skb->priority = d->priority;
 44         if (d->flags & SKBEDIT_F_QUEUE_MAPPING &&
 45             skb->dev->real_num_tx_queues > d->queue_mapping)
 46                 skb_set_queue_mapping(skb, d->queue_mapping);
 47         if (d->flags & SKBEDIT_F_MARK) {
 48                 skb->mark &= ~d->mask;
 49                 skb->mark |= d->mark & d->mask;
 50         }
 51         if (d->flags & SKBEDIT_F_PTYPE)
 52                 skb->pkt_type = d->ptype;
 53 
 54         spin_unlock(&d->tcf_lock);
 55         return d->tcf_action;
 56 }
 57 
 58 static const struct nla_policy skbedit_policy[TCA_SKBEDIT_MAX + 1] = {
 59         [TCA_SKBEDIT_PARMS]             = { .len = sizeof(struct tc_skbedit) },
 60         [TCA_SKBEDIT_PRIORITY]          = { .len = sizeof(u32) },
 61         [TCA_SKBEDIT_QUEUE_MAPPING]     = { .len = sizeof(u16) },
 62         [TCA_SKBEDIT_MARK]              = { .len = sizeof(u32) },
 63         [TCA_SKBEDIT_PTYPE]             = { .len = sizeof(u16) },
 64         [TCA_SKBEDIT_MASK]              = { .len = sizeof(u32) },
 65 };
 66 
 67 static int tcf_skbedit_init(struct net *net, struct nlattr *nla,
 68                             struct nlattr *est, struct tc_action **a,
 69                             int ovr, int bind, struct netlink_ext_ack *extack)
 70 {
 71         struct tc_action_net *tn = net_generic(net, skbedit_net_id);
 72         struct nlattr *tb[TCA_SKBEDIT_MAX + 1];
 73         struct tc_skbedit *parm;
 74         struct tcf_skbedit *d;
 75         u32 flags = 0, *priority = NULL, *mark = NULL, *mask = NULL;
 76         u16 *queue_mapping = NULL, *ptype = NULL;
 77         bool exists = false;
 78         int ret = 0, err;
 79 
 80         if (nla == NULL)
 81                 return -EINVAL;
 82 
 83         err = nla_parse_nested(tb, TCA_SKBEDIT_MAX, nla, skbedit_policy, NULL);
 84         if (err < 0)
 85                 return err;
 86 
 87         if (tb[TCA_SKBEDIT_PARMS] == NULL)
 88                 return -EINVAL;
 89 
 90         if (tb[TCA_SKBEDIT_PRIORITY] != NULL) {
 91                 flags |= SKBEDIT_F_PRIORITY;
 92                 priority = nla_data(tb[TCA_SKBEDIT_PRIORITY]);
 93         }
 94 
 95         if (tb[TCA_SKBEDIT_QUEUE_MAPPING] != NULL) {
 96                 flags |= SKBEDIT_F_QUEUE_MAPPING;
 97                 queue_mapping = nla_data(tb[TCA_SKBEDIT_QUEUE_MAPPING]);
 98         }
 99 
100         if (tb[TCA_SKBEDIT_PTYPE] != NULL) {
101                 ptype = nla_data(tb[TCA_SKBEDIT_PTYPE]);
102                 if (!skb_pkt_type_ok(*ptype))
103                         return -EINVAL;
104                 flags |= SKBEDIT_F_PTYPE;
105         }
106 
107         if (tb[TCA_SKBEDIT_MARK] != NULL) {
108                 flags |= SKBEDIT_F_MARK;
109                 mark = nla_data(tb[TCA_SKBEDIT_MARK]);
110         }
111 
112         if (tb[TCA_SKBEDIT_MASK] != NULL) {
113                 flags |= SKBEDIT_F_MASK;
114                 mask = nla_data(tb[TCA_SKBEDIT_MASK]);
115         }
116 
117         parm = nla_data(tb[TCA_SKBEDIT_PARMS]);
118 
119         exists = tcf_idr_check(tn, parm->index, a, bind);
120         if (exists && bind)
121                 return 0;
122 
123         if (!flags) {
124                 if (exists)
125                         tcf_idr_release(*a, bind);
126                 return -EINVAL;
127         }
128 
129         if (!exists) {
130                 ret = tcf_idr_create(tn, parm->index, est, a,
131                                      &act_skbedit_ops, bind, false);
132                 if (ret)
133                         return ret;
134 
135                 d = to_skbedit(*a);
136                 ret = ACT_P_CREATED;
137         } else {
138                 d = to_skbedit(*a);
139                 tcf_idr_release(*a, bind);
140                 if (!ovr)
141                         return -EEXIST;
142         }
143 
144         spin_lock_bh(&d->tcf_lock);
145 
146         d->flags = flags;
147         if (flags & SKBEDIT_F_PRIORITY)
148                 d->priority = *priority;
149         if (flags & SKBEDIT_F_QUEUE_MAPPING)
150                 d->queue_mapping = *queue_mapping;
151         if (flags & SKBEDIT_F_MARK)
152                 d->mark = *mark;
153         if (flags & SKBEDIT_F_PTYPE)
154                 d->ptype = *ptype;
155         /* default behaviour is to use all the bits */
156         d->mask = 0xffffffff;
157         if (flags & SKBEDIT_F_MASK)
158                 d->mask = *mask;
159 
160         d->tcf_action = parm->action;
161 
162         spin_unlock_bh(&d->tcf_lock);
163 
164         if (ret == ACT_P_CREATED)
165                 tcf_idr_insert(tn, *a);
166         return ret;
167 }
168 
169 static int tcf_skbedit_dump(struct sk_buff *skb, struct tc_action *a,
170                             int bind, int ref)
171 {
172         unsigned char *b = skb_tail_pointer(skb);
173         struct tcf_skbedit *d = to_skbedit(a);
174         struct tc_skbedit opt = {
175                 .index   = d->tcf_index,
176                 .refcnt  = d->tcf_refcnt - ref,
177                 .bindcnt = d->tcf_bindcnt - bind,
178                 .action  = d->tcf_action,
179         };
180         struct tcf_t t;
181 
182         if (nla_put(skb, TCA_SKBEDIT_PARMS, sizeof(opt), &opt))
183                 goto nla_put_failure;
184         if ((d->flags & SKBEDIT_F_PRIORITY) &&
185             nla_put_u32(skb, TCA_SKBEDIT_PRIORITY, d->priority))
186                 goto nla_put_failure;
187         if ((d->flags & SKBEDIT_F_QUEUE_MAPPING) &&
188             nla_put_u16(skb, TCA_SKBEDIT_QUEUE_MAPPING, d->queue_mapping))
189                 goto nla_put_failure;
190         if ((d->flags & SKBEDIT_F_MARK) &&
191             nla_put_u32(skb, TCA_SKBEDIT_MARK, d->mark))
192                 goto nla_put_failure;
193         if ((d->flags & SKBEDIT_F_PTYPE) &&
194             nla_put_u16(skb, TCA_SKBEDIT_PTYPE, d->ptype))
195                 goto nla_put_failure;
196         if ((d->flags & SKBEDIT_F_MASK) &&
197             nla_put_u32(skb, TCA_SKBEDIT_MASK, d->mask))
198                 goto nla_put_failure;
199 
200         tcf_tm_dump(&t, &d->tcf_tm);
201         if (nla_put_64bit(skb, TCA_SKBEDIT_TM, sizeof(t), &t, TCA_SKBEDIT_PAD))
202                 goto nla_put_failure;
203         return skb->len;
204 
205 nla_put_failure:
206         nlmsg_trim(skb, b);
207         return -1;
208 }
209 
210 static int tcf_skbedit_walker(struct net *net, struct sk_buff *skb,
211                               struct netlink_callback *cb, int type,
212                               const struct tc_action_ops *ops,
213                               struct netlink_ext_ack *extack)
214 {
215         struct tc_action_net *tn = net_generic(net, skbedit_net_id);
216 
217         return tcf_generic_walker(tn, skb, cb, type, ops, extack);
218 }
219 
220 static int tcf_skbedit_search(struct net *net, struct tc_action **a, u32 index,
221                               struct netlink_ext_ack *extack)
222 {
223         struct tc_action_net *tn = net_generic(net, skbedit_net_id);
224 
225         return tcf_idr_search(tn, a, index);
226 }
227 
228 static struct tc_action_ops act_skbedit_ops = {
229         .kind           =       "skbedit",
230         .type           =       TCA_ACT_SKBEDIT,
231         .owner          =       THIS_MODULE,
232         .act            =       tcf_skbedit,
233         .dump           =       tcf_skbedit_dump,
234         .init           =       tcf_skbedit_init,
235         .walk           =       tcf_skbedit_walker,
236         .lookup         =       tcf_skbedit_search,
237         .size           =       sizeof(struct tcf_skbedit),
238 };
239 
240 static __net_init int skbedit_init_net(struct net *net)
241 {
242         struct tc_action_net *tn = net_generic(net, skbedit_net_id);
243 
244         return tc_action_net_init(tn, &act_skbedit_ops);
245 }
246 
247 static void __net_exit skbedit_exit_net(struct list_head *net_list)
248 {
249         tc_action_net_exit(net_list, skbedit_net_id);
250 }
251 
252 static struct pernet_operations skbedit_net_ops = {
253         .init = skbedit_init_net,
254         .exit_batch = skbedit_exit_net,
255         .id   = &skbedit_net_id,
256         .size = sizeof(struct tc_action_net),
257 };
258 
259 MODULE_AUTHOR("Alexander Duyck, <alexander.h.duyck@intel.com>");
260 MODULE_DESCRIPTION("SKB Editing");
261 MODULE_LICENSE("GPL");
262 
263 static int __init skbedit_init_module(void)
264 {
265         return tcf_register_action(&act_skbedit_ops, &skbedit_net_ops);
266 }
267 
268 static void __exit skbedit_cleanup_module(void)
269 {
270         tcf_unregister_action(&act_skbedit_ops, &skbedit_net_ops);
271 }
272 
273 module_init(skbedit_init_module);
274 module_exit(skbedit_cleanup_module);
275 

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