2 * Copyright (c) 2008, Intel Corporation.
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.
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
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/>.
16 * Author: Alexander Duyck <alexander.h.duyck@intel.com>
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>
28 #include <net/dsfield.h>
29 #include <net/pkt_cls.h>
31 #include <linux/tc_act/tc_skbedit.h>
32 #include <net/tc_act/tc_skbedit.h>
34 static unsigned int skbedit_net_id
;
35 static struct tc_action_ops act_skbedit_ops
;
37 static int tcf_skbedit_act(struct sk_buff
*skb
, const struct tc_action
*a
,
38 struct tcf_result
*res
)
40 struct tcf_skbedit
*d
= to_skbedit(a
);
41 struct tcf_skbedit_params
*params
;
44 tcf_lastuse_update(&d
->tcf_tm
);
45 bstats_cpu_update(this_cpu_ptr(d
->common
.cpu_bstats
), skb
);
47 params
= rcu_dereference_bh(d
->params
);
48 action
= READ_ONCE(d
->tcf_action
);
50 if (params
->flags
& SKBEDIT_F_PRIORITY
)
51 skb
->priority
= params
->priority
;
52 if (params
->flags
& SKBEDIT_F_INHERITDSFIELD
) {
53 int wlen
= skb_network_offset(skb
);
55 switch (tc_skb_protocol(skb
)) {
57 wlen
+= sizeof(struct iphdr
);
58 if (!pskb_may_pull(skb
, wlen
))
60 skb
->priority
= ipv4_get_dsfield(ip_hdr(skb
)) >> 2;
63 case htons(ETH_P_IPV6
):
64 wlen
+= sizeof(struct ipv6hdr
);
65 if (!pskb_may_pull(skb
, wlen
))
67 skb
->priority
= ipv6_get_dsfield(ipv6_hdr(skb
)) >> 2;
71 if (params
->flags
& SKBEDIT_F_QUEUE_MAPPING
&&
72 skb
->dev
->real_num_tx_queues
> params
->queue_mapping
)
73 skb_set_queue_mapping(skb
, params
->queue_mapping
);
74 if (params
->flags
& SKBEDIT_F_MARK
) {
75 skb
->mark
&= ~params
->mask
;
76 skb
->mark
|= params
->mark
& params
->mask
;
78 if (params
->flags
& SKBEDIT_F_PTYPE
)
79 skb
->pkt_type
= params
->ptype
;
83 qstats_drop_inc(this_cpu_ptr(d
->common
.cpu_qstats
));
87 static const struct nla_policy skbedit_policy
[TCA_SKBEDIT_MAX
+ 1] = {
88 [TCA_SKBEDIT_PARMS
] = { .len
= sizeof(struct tc_skbedit
) },
89 [TCA_SKBEDIT_PRIORITY
] = { .len
= sizeof(u32
) },
90 [TCA_SKBEDIT_QUEUE_MAPPING
] = { .len
= sizeof(u16
) },
91 [TCA_SKBEDIT_MARK
] = { .len
= sizeof(u32
) },
92 [TCA_SKBEDIT_PTYPE
] = { .len
= sizeof(u16
) },
93 [TCA_SKBEDIT_MASK
] = { .len
= sizeof(u32
) },
94 [TCA_SKBEDIT_FLAGS
] = { .len
= sizeof(u64
) },
97 static int tcf_skbedit_init(struct net
*net
, struct nlattr
*nla
,
98 struct nlattr
*est
, struct tc_action
**a
,
99 int ovr
, int bind
, bool rtnl_held
,
100 struct tcf_proto
*tp
,
101 struct netlink_ext_ack
*extack
)
103 struct tc_action_net
*tn
= net_generic(net
, skbedit_net_id
);
104 struct tcf_skbedit_params
*params_new
;
105 struct nlattr
*tb
[TCA_SKBEDIT_MAX
+ 1];
106 struct tcf_chain
*goto_ch
= NULL
;
107 struct tc_skbedit
*parm
;
108 struct tcf_skbedit
*d
;
109 u32 flags
= 0, *priority
= NULL
, *mark
= NULL
, *mask
= NULL
;
110 u16
*queue_mapping
= NULL
, *ptype
= NULL
;
117 err
= nla_parse_nested_deprecated(tb
, TCA_SKBEDIT_MAX
, nla
,
118 skbedit_policy
, NULL
);
122 if (tb
[TCA_SKBEDIT_PARMS
] == NULL
)
125 if (tb
[TCA_SKBEDIT_PRIORITY
] != NULL
) {
126 flags
|= SKBEDIT_F_PRIORITY
;
127 priority
= nla_data(tb
[TCA_SKBEDIT_PRIORITY
]);
130 if (tb
[TCA_SKBEDIT_QUEUE_MAPPING
] != NULL
) {
131 flags
|= SKBEDIT_F_QUEUE_MAPPING
;
132 queue_mapping
= nla_data(tb
[TCA_SKBEDIT_QUEUE_MAPPING
]);
135 if (tb
[TCA_SKBEDIT_PTYPE
] != NULL
) {
136 ptype
= nla_data(tb
[TCA_SKBEDIT_PTYPE
]);
137 if (!skb_pkt_type_ok(*ptype
))
139 flags
|= SKBEDIT_F_PTYPE
;
142 if (tb
[TCA_SKBEDIT_MARK
] != NULL
) {
143 flags
|= SKBEDIT_F_MARK
;
144 mark
= nla_data(tb
[TCA_SKBEDIT_MARK
]);
147 if (tb
[TCA_SKBEDIT_MASK
] != NULL
) {
148 flags
|= SKBEDIT_F_MASK
;
149 mask
= nla_data(tb
[TCA_SKBEDIT_MASK
]);
152 if (tb
[TCA_SKBEDIT_FLAGS
] != NULL
) {
153 u64
*pure_flags
= nla_data(tb
[TCA_SKBEDIT_FLAGS
]);
155 if (*pure_flags
& SKBEDIT_F_INHERITDSFIELD
)
156 flags
|= SKBEDIT_F_INHERITDSFIELD
;
159 parm
= nla_data(tb
[TCA_SKBEDIT_PARMS
]);
161 err
= tcf_idr_check_alloc(tn
, &parm
->index
, a
, bind
);
170 tcf_idr_release(*a
, bind
);
172 tcf_idr_cleanup(tn
, parm
->index
);
177 ret
= tcf_idr_create(tn
, parm
->index
, est
, a
,
178 &act_skbedit_ops
, bind
, true);
180 tcf_idr_cleanup(tn
, parm
->index
);
189 tcf_idr_release(*a
, bind
);
193 err
= tcf_action_check_ctrlact(parm
->action
, tp
, &goto_ch
, extack
);
197 params_new
= kzalloc(sizeof(*params_new
), GFP_KERNEL
);
198 if (unlikely(!params_new
)) {
203 params_new
->flags
= flags
;
204 if (flags
& SKBEDIT_F_PRIORITY
)
205 params_new
->priority
= *priority
;
206 if (flags
& SKBEDIT_F_QUEUE_MAPPING
)
207 params_new
->queue_mapping
= *queue_mapping
;
208 if (flags
& SKBEDIT_F_MARK
)
209 params_new
->mark
= *mark
;
210 if (flags
& SKBEDIT_F_PTYPE
)
211 params_new
->ptype
= *ptype
;
212 /* default behaviour is to use all the bits */
213 params_new
->mask
= 0xffffffff;
214 if (flags
& SKBEDIT_F_MASK
)
215 params_new
->mask
= *mask
;
217 spin_lock_bh(&d
->tcf_lock
);
218 goto_ch
= tcf_action_set_ctrlact(*a
, parm
->action
, goto_ch
);
219 rcu_swap_protected(d
->params
, params_new
,
220 lockdep_is_held(&d
->tcf_lock
));
221 spin_unlock_bh(&d
->tcf_lock
);
223 kfree_rcu(params_new
, rcu
);
225 tcf_chain_put_by_act(goto_ch
);
227 if (ret
== ACT_P_CREATED
)
228 tcf_idr_insert(tn
, *a
);
232 tcf_chain_put_by_act(goto_ch
);
234 tcf_idr_release(*a
, bind
);
238 static int tcf_skbedit_dump(struct sk_buff
*skb
, struct tc_action
*a
,
241 unsigned char *b
= skb_tail_pointer(skb
);
242 struct tcf_skbedit
*d
= to_skbedit(a
);
243 struct tcf_skbedit_params
*params
;
244 struct tc_skbedit opt
= {
245 .index
= d
->tcf_index
,
246 .refcnt
= refcount_read(&d
->tcf_refcnt
) - ref
,
247 .bindcnt
= atomic_read(&d
->tcf_bindcnt
) - bind
,
252 spin_lock_bh(&d
->tcf_lock
);
253 params
= rcu_dereference_protected(d
->params
,
254 lockdep_is_held(&d
->tcf_lock
));
255 opt
.action
= d
->tcf_action
;
257 if (nla_put(skb
, TCA_SKBEDIT_PARMS
, sizeof(opt
), &opt
))
258 goto nla_put_failure
;
259 if ((params
->flags
& SKBEDIT_F_PRIORITY
) &&
260 nla_put_u32(skb
, TCA_SKBEDIT_PRIORITY
, params
->priority
))
261 goto nla_put_failure
;
262 if ((params
->flags
& SKBEDIT_F_QUEUE_MAPPING
) &&
263 nla_put_u16(skb
, TCA_SKBEDIT_QUEUE_MAPPING
, params
->queue_mapping
))
264 goto nla_put_failure
;
265 if ((params
->flags
& SKBEDIT_F_MARK
) &&
266 nla_put_u32(skb
, TCA_SKBEDIT_MARK
, params
->mark
))
267 goto nla_put_failure
;
268 if ((params
->flags
& SKBEDIT_F_PTYPE
) &&
269 nla_put_u16(skb
, TCA_SKBEDIT_PTYPE
, params
->ptype
))
270 goto nla_put_failure
;
271 if ((params
->flags
& SKBEDIT_F_MASK
) &&
272 nla_put_u32(skb
, TCA_SKBEDIT_MASK
, params
->mask
))
273 goto nla_put_failure
;
274 if (params
->flags
& SKBEDIT_F_INHERITDSFIELD
)
275 pure_flags
|= SKBEDIT_F_INHERITDSFIELD
;
276 if (pure_flags
!= 0 &&
277 nla_put(skb
, TCA_SKBEDIT_FLAGS
, sizeof(pure_flags
), &pure_flags
))
278 goto nla_put_failure
;
280 tcf_tm_dump(&t
, &d
->tcf_tm
);
281 if (nla_put_64bit(skb
, TCA_SKBEDIT_TM
, sizeof(t
), &t
, TCA_SKBEDIT_PAD
))
282 goto nla_put_failure
;
283 spin_unlock_bh(&d
->tcf_lock
);
288 spin_unlock_bh(&d
->tcf_lock
);
293 static void tcf_skbedit_cleanup(struct tc_action
*a
)
295 struct tcf_skbedit
*d
= to_skbedit(a
);
296 struct tcf_skbedit_params
*params
;
298 params
= rcu_dereference_protected(d
->params
, 1);
300 kfree_rcu(params
, rcu
);
303 static int tcf_skbedit_walker(struct net
*net
, struct sk_buff
*skb
,
304 struct netlink_callback
*cb
, int type
,
305 const struct tc_action_ops
*ops
,
306 struct netlink_ext_ack
*extack
)
308 struct tc_action_net
*tn
= net_generic(net
, skbedit_net_id
);
310 return tcf_generic_walker(tn
, skb
, cb
, type
, ops
, extack
);
313 static int tcf_skbedit_search(struct net
*net
, struct tc_action
**a
, u32 index
)
315 struct tc_action_net
*tn
= net_generic(net
, skbedit_net_id
);
317 return tcf_idr_search(tn
, a
, index
);
320 static struct tc_action_ops act_skbedit_ops
= {
322 .id
= TCA_ID_SKBEDIT
,
323 .owner
= THIS_MODULE
,
324 .act
= tcf_skbedit_act
,
325 .dump
= tcf_skbedit_dump
,
326 .init
= tcf_skbedit_init
,
327 .cleanup
= tcf_skbedit_cleanup
,
328 .walk
= tcf_skbedit_walker
,
329 .lookup
= tcf_skbedit_search
,
330 .size
= sizeof(struct tcf_skbedit
),
333 static __net_init
int skbedit_init_net(struct net
*net
)
335 struct tc_action_net
*tn
= net_generic(net
, skbedit_net_id
);
337 return tc_action_net_init(tn
, &act_skbedit_ops
);
340 static void __net_exit
skbedit_exit_net(struct list_head
*net_list
)
342 tc_action_net_exit(net_list
, skbedit_net_id
);
345 static struct pernet_operations skbedit_net_ops
= {
346 .init
= skbedit_init_net
,
347 .exit_batch
= skbedit_exit_net
,
348 .id
= &skbedit_net_id
,
349 .size
= sizeof(struct tc_action_net
),
352 MODULE_AUTHOR("Alexander Duyck, <alexander.h.duyck@intel.com>");
353 MODULE_DESCRIPTION("SKB Editing");
354 MODULE_LICENSE("GPL");
356 static int __init
skbedit_init_module(void)
358 return tcf_register_action(&act_skbedit_ops
, &skbedit_net_ops
);
361 static void __exit
skbedit_cleanup_module(void)
363 tcf_unregister_action(&act_skbedit_ops
, &skbedit_net_ops
);
366 module_init(skbedit_init_module
);
367 module_exit(skbedit_cleanup_module
);