1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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#define SKBEDIT_TAB_MASK 15
31
32static int skbedit_net_id;
33static struct tc_action_ops act_skbedit_ops;
34
35static int tcf_skbedit(struct sk_buff *skb, const struct tc_action *a,
36 struct tcf_result *res)
37{
38 struct tcf_skbedit *d = to_skbedit(a);
39
40 spin_lock(&d->tcf_lock);
41 tcf_lastuse_update(&d->tcf_tm);
42 bstats_update(&d->tcf_bstats, skb);
43
44 if (d->flags & SKBEDIT_F_PRIORITY)
45 skb->priority = d->priority;
46 if (d->flags & SKBEDIT_F_QUEUE_MAPPING &&
47 skb->dev->real_num_tx_queues > d->queue_mapping)
48 skb_set_queue_mapping(skb, d->queue_mapping);
49 if (d->flags & SKBEDIT_F_MARK)
50 skb->mark = d->mark;
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
58static 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};
65
66static int tcf_skbedit_init(struct net *net, struct nlattr *nla,
67 struct nlattr *est, struct tc_action **a,
68 int ovr, int bind)
69{
70 struct tc_action_net *tn = net_generic(net, skbedit_net_id);
71 struct nlattr *tb[TCA_SKBEDIT_MAX + 1];
72 struct tc_skbedit *parm;
73 struct tcf_skbedit *d;
74 u32 flags = 0, *priority = NULL, *mark = NULL;
75 u16 *queue_mapping = NULL, *ptype = NULL;
76 bool exists = false;
77 int ret = 0, err;
78
79 if (nla == NULL)
80 return -EINVAL;
81
82 err = nla_parse_nested(tb, TCA_SKBEDIT_MAX, nla, skbedit_policy);
83 if (err < 0)
84 return err;
85
86 if (tb[TCA_SKBEDIT_PARMS] == NULL)
87 return -EINVAL;
88
89 if (tb[TCA_SKBEDIT_PRIORITY] != NULL) {
90 flags |= SKBEDIT_F_PRIORITY;
91 priority = nla_data(tb[TCA_SKBEDIT_PRIORITY]);
92 }
93
94 if (tb[TCA_SKBEDIT_QUEUE_MAPPING] != NULL) {
95 flags |= SKBEDIT_F_QUEUE_MAPPING;
96 queue_mapping = nla_data(tb[TCA_SKBEDIT_QUEUE_MAPPING]);
97 }
98
99 if (tb[TCA_SKBEDIT_PTYPE] != NULL) {
100 ptype = nla_data(tb[TCA_SKBEDIT_PTYPE]);
101 if (!skb_pkt_type_ok(*ptype))
102 return -EINVAL;
103 flags |= SKBEDIT_F_PTYPE;
104 }
105
106 if (tb[TCA_SKBEDIT_MARK] != NULL) {
107 flags |= SKBEDIT_F_MARK;
108 mark = nla_data(tb[TCA_SKBEDIT_MARK]);
109 }
110
111 parm = nla_data(tb[TCA_SKBEDIT_PARMS]);
112
113 exists = tcf_hash_check(tn, parm->index, a, bind);
114 if (exists && bind)
115 return 0;
116
117 if (!flags) {
118 tcf_hash_release(*a, bind);
119 return -EINVAL;
120 }
121
122 if (!exists) {
123 ret = tcf_hash_create(tn, parm->index, est, a,
124 &act_skbedit_ops, bind, false);
125 if (ret)
126 return ret;
127
128 d = to_skbedit(*a);
129 ret = ACT_P_CREATED;
130 } else {
131 d = to_skbedit(*a);
132 tcf_hash_release(*a, bind);
133 if (!ovr)
134 return -EEXIST;
135 }
136
137 spin_lock_bh(&d->tcf_lock);
138
139 d->flags = flags;
140 if (flags & SKBEDIT_F_PRIORITY)
141 d->priority = *priority;
142 if (flags & SKBEDIT_F_QUEUE_MAPPING)
143 d->queue_mapping = *queue_mapping;
144 if (flags & SKBEDIT_F_MARK)
145 d->mark = *mark;
146 if (flags & SKBEDIT_F_PTYPE)
147 d->ptype = *ptype;
148
149 d->tcf_action = parm->action;
150
151 spin_unlock_bh(&d->tcf_lock);
152
153 if (ret == ACT_P_CREATED)
154 tcf_hash_insert(tn, *a);
155 return ret;
156}
157
158static int tcf_skbedit_dump(struct sk_buff *skb, struct tc_action *a,
159 int bind, int ref)
160{
161 unsigned char *b = skb_tail_pointer(skb);
162 struct tcf_skbedit *d = to_skbedit(a);
163 struct tc_skbedit opt = {
164 .index = d->tcf_index,
165 .refcnt = d->tcf_refcnt - ref,
166 .bindcnt = d->tcf_bindcnt - bind,
167 .action = d->tcf_action,
168 };
169 struct tcf_t t;
170
171 if (nla_put(skb, TCA_SKBEDIT_PARMS, sizeof(opt), &opt))
172 goto nla_put_failure;
173 if ((d->flags & SKBEDIT_F_PRIORITY) &&
174 nla_put_u32(skb, TCA_SKBEDIT_PRIORITY, d->priority))
175 goto nla_put_failure;
176 if ((d->flags & SKBEDIT_F_QUEUE_MAPPING) &&
177 nla_put_u16(skb, TCA_SKBEDIT_QUEUE_MAPPING, d->queue_mapping))
178 goto nla_put_failure;
179 if ((d->flags & SKBEDIT_F_MARK) &&
180 nla_put_u32(skb, TCA_SKBEDIT_MARK, d->mark))
181 goto nla_put_failure;
182 if ((d->flags & SKBEDIT_F_PTYPE) &&
183 nla_put_u16(skb, TCA_SKBEDIT_PTYPE, d->ptype))
184 goto nla_put_failure;
185
186 tcf_tm_dump(&t, &d->tcf_tm);
187 if (nla_put_64bit(skb, TCA_SKBEDIT_TM, sizeof(t), &t, TCA_SKBEDIT_PAD))
188 goto nla_put_failure;
189 return skb->len;
190
191nla_put_failure:
192 nlmsg_trim(skb, b);
193 return -1;
194}
195
196static int tcf_skbedit_walker(struct net *net, struct sk_buff *skb,
197 struct netlink_callback *cb, int type,
198 const struct tc_action_ops *ops)
199{
200 struct tc_action_net *tn = net_generic(net, skbedit_net_id);
201
202 return tcf_generic_walker(tn, skb, cb, type, ops);
203}
204
205static int tcf_skbedit_search(struct net *net, struct tc_action **a, u32 index)
206{
207 struct tc_action_net *tn = net_generic(net, skbedit_net_id);
208
209 return tcf_hash_search(tn, a, index);
210}
211
212static struct tc_action_ops act_skbedit_ops = {
213 .kind = "skbedit",
214 .type = TCA_ACT_SKBEDIT,
215 .owner = THIS_MODULE,
216 .act = tcf_skbedit,
217 .dump = tcf_skbedit_dump,
218 .init = tcf_skbedit_init,
219 .walk = tcf_skbedit_walker,
220 .lookup = tcf_skbedit_search,
221 .size = sizeof(struct tcf_skbedit),
222};
223
224static __net_init int skbedit_init_net(struct net *net)
225{
226 struct tc_action_net *tn = net_generic(net, skbedit_net_id);
227
228 return tc_action_net_init(tn, &act_skbedit_ops, SKBEDIT_TAB_MASK);
229}
230
231static void __net_exit skbedit_exit_net(struct net *net)
232{
233 struct tc_action_net *tn = net_generic(net, skbedit_net_id);
234
235 tc_action_net_exit(tn);
236}
237
238static struct pernet_operations skbedit_net_ops = {
239 .init = skbedit_init_net,
240 .exit = skbedit_exit_net,
241 .id = &skbedit_net_id,
242 .size = sizeof(struct tc_action_net),
243};
244
245MODULE_AUTHOR("Alexander Duyck, <alexander.h.duyck@intel.com>");
246MODULE_DESCRIPTION("SKB Editing");
247MODULE_LICENSE("GPL");
248
249static int __init skbedit_init_module(void)
250{
251 return tcf_register_action(&act_skbedit_ops, &skbedit_net_ops);
252}
253
254static void __exit skbedit_cleanup_module(void)
255{
256 tcf_unregister_action(&act_skbedit_ops, &skbedit_net_ops);
257}
258
259module_init(skbedit_init_module);
260module_exit(skbedit_cleanup_module);
261
