1
2
3
4
5
6#include <linux/module.h>
7#include <linux/init.h>
8#include <linux/kernel.h>
9#include <linux/skbuff.h>
10#include <linux/rtnetlink.h>
11#include <linux/filter.h>
12#include <linux/bpf.h>
13
14#include <net/netlink.h>
15#include <net/sock.h>
16#include <net/pkt_sched.h>
17#include <net/pkt_cls.h>
18
19#include <linux/tc_act/tc_bpf.h>
20#include <net/tc_act/tc_bpf.h>
21
22#define ACT_BPF_NAME_LEN 256
23
24struct tcf_bpf_cfg {
25 struct bpf_prog *filter;
26 struct sock_filter *bpf_ops;
27 const char *bpf_name;
28 u16 bpf_num_ops;
29 bool is_ebpf;
30};
31
32static unsigned int bpf_net_id;
33static struct tc_action_ops act_bpf_ops;
34
35static int tcf_bpf_act(struct sk_buff *skb, const struct tc_action *act,
36 struct tcf_result *res)
37{
38 bool at_ingress = skb_at_tc_ingress(skb);
39 struct tcf_bpf *prog = to_bpf(act);
40 struct bpf_prog *filter;
41 int action, filter_res;
42
43 tcf_lastuse_update(&prog->tcf_tm);
44 bstats_cpu_update(this_cpu_ptr(prog->common.cpu_bstats), skb);
45
46 filter = rcu_dereference(prog->filter);
47 if (at_ingress) {
48 __skb_push(skb, skb->mac_len);
49 bpf_compute_data_pointers(skb);
50 filter_res = bpf_prog_run(filter, skb);
51 __skb_pull(skb, skb->mac_len);
52 } else {
53 bpf_compute_data_pointers(skb);
54 filter_res = bpf_prog_run(filter, skb);
55 }
56 if (skb_sk_is_prefetched(skb) && filter_res != TC_ACT_OK)
57 skb_orphan(skb);
58
59
60
61
62
63
64
65
66
67
68
69 switch (filter_res) {
70 case TC_ACT_PIPE:
71 case TC_ACT_RECLASSIFY:
72 case TC_ACT_OK:
73 case TC_ACT_REDIRECT:
74 action = filter_res;
75 break;
76 case TC_ACT_SHOT:
77 action = filter_res;
78 qstats_drop_inc(this_cpu_ptr(prog->common.cpu_qstats));
79 break;
80 case TC_ACT_UNSPEC:
81 action = prog->tcf_action;
82 break;
83 default:
84 action = TC_ACT_UNSPEC;
85 break;
86 }
87
88 return action;
89}
90
91static bool tcf_bpf_is_ebpf(const struct tcf_bpf *prog)
92{
93 return !prog->bpf_ops;
94}
95
96static int tcf_bpf_dump_bpf_info(const struct tcf_bpf *prog,
97 struct sk_buff *skb)
98{
99 struct nlattr *nla;
100
101 if (nla_put_u16(skb, TCA_ACT_BPF_OPS_LEN, prog->bpf_num_ops))
102 return -EMSGSIZE;
103
104 nla = nla_reserve(skb, TCA_ACT_BPF_OPS, prog->bpf_num_ops *
105 sizeof(struct sock_filter));
106 if (nla == NULL)
107 return -EMSGSIZE;
108
109 memcpy(nla_data(nla), prog->bpf_ops, nla_len(nla));
110
111 return 0;
112}
113
114static int tcf_bpf_dump_ebpf_info(const struct tcf_bpf *prog,
115 struct sk_buff *skb)
116{
117 struct nlattr *nla;
118
119 if (prog->bpf_name &&
120 nla_put_string(skb, TCA_ACT_BPF_NAME, prog->bpf_name))
121 return -EMSGSIZE;
122
123 if (nla_put_u32(skb, TCA_ACT_BPF_ID, prog->filter->aux->id))
124 return -EMSGSIZE;
125
126 nla = nla_reserve(skb, TCA_ACT_BPF_TAG, sizeof(prog->filter->tag));
127 if (nla == NULL)
128 return -EMSGSIZE;
129
130 memcpy(nla_data(nla), prog->filter->tag, nla_len(nla));
131
132 return 0;
133}
134
135static int tcf_bpf_dump(struct sk_buff *skb, struct tc_action *act,
136 int bind, int ref)
137{
138 unsigned char *tp = skb_tail_pointer(skb);
139 struct tcf_bpf *prog = to_bpf(act);
140 struct tc_act_bpf opt = {
141 .index = prog->tcf_index,
142 .refcnt = refcount_read(&prog->tcf_refcnt) - ref,
143 .bindcnt = atomic_read(&prog->tcf_bindcnt) - bind,
144 };
145 struct tcf_t tm;
146 int ret;
147
148 spin_lock_bh(&prog->tcf_lock);
149 opt.action = prog->tcf_action;
150 if (nla_put(skb, TCA_ACT_BPF_PARMS, sizeof(opt), &opt))
151 goto nla_put_failure;
152
153 if (tcf_bpf_is_ebpf(prog))
154 ret = tcf_bpf_dump_ebpf_info(prog, skb);
155 else
156 ret = tcf_bpf_dump_bpf_info(prog, skb);
157 if (ret)
158 goto nla_put_failure;
159
160 tcf_tm_dump(&tm, &prog->tcf_tm);
161 if (nla_put_64bit(skb, TCA_ACT_BPF_TM, sizeof(tm), &tm,
162 TCA_ACT_BPF_PAD))
163 goto nla_put_failure;
164
165 spin_unlock_bh(&prog->tcf_lock);
166 return skb->len;
167
168nla_put_failure:
169 spin_unlock_bh(&prog->tcf_lock);
170 nlmsg_trim(skb, tp);
171 return -1;
172}
173
174static const struct nla_policy act_bpf_policy[TCA_ACT_BPF_MAX + 1] = {
175 [TCA_ACT_BPF_PARMS] = { .len = sizeof(struct tc_act_bpf) },
176 [TCA_ACT_BPF_FD] = { .type = NLA_U32 },
177 [TCA_ACT_BPF_NAME] = { .type = NLA_NUL_STRING,
178 .len = ACT_BPF_NAME_LEN },
179 [TCA_ACT_BPF_OPS_LEN] = { .type = NLA_U16 },
180 [TCA_ACT_BPF_OPS] = { .type = NLA_BINARY,
181 .len = sizeof(struct sock_filter) * BPF_MAXINSNS },
182};
183
184static int tcf_bpf_init_from_ops(struct nlattr **tb, struct tcf_bpf_cfg *cfg)
185{
186 struct sock_filter *bpf_ops;
187 struct sock_fprog_kern fprog_tmp;
188 struct bpf_prog *fp;
189 u16 bpf_size, bpf_num_ops;
190 int ret;
191
192 bpf_num_ops = nla_get_u16(tb[TCA_ACT_BPF_OPS_LEN]);
193 if (bpf_num_ops > BPF_MAXINSNS || bpf_num_ops == 0)
194 return -EINVAL;
195
196 bpf_size = bpf_num_ops * sizeof(*bpf_ops);
197 if (bpf_size != nla_len(tb[TCA_ACT_BPF_OPS]))
198 return -EINVAL;
199
200 bpf_ops = kmemdup(nla_data(tb[TCA_ACT_BPF_OPS]), bpf_size, GFP_KERNEL);
201 if (bpf_ops == NULL)
202 return -ENOMEM;
203
204 fprog_tmp.len = bpf_num_ops;
205 fprog_tmp.filter = bpf_ops;
206
207 ret = bpf_prog_create(&fp, &fprog_tmp);
208 if (ret < 0) {
209 kfree(bpf_ops);
210 return ret;
211 }
212
213 cfg->bpf_ops = bpf_ops;
214 cfg->bpf_num_ops = bpf_num_ops;
215 cfg->filter = fp;
216 cfg->is_ebpf = false;
217
218 return 0;
219}
220
221static int tcf_bpf_init_from_efd(struct nlattr **tb, struct tcf_bpf_cfg *cfg)
222{
223 struct bpf_prog *fp;
224 char *name = NULL;
225 u32 bpf_fd;
226
227 bpf_fd = nla_get_u32(tb[TCA_ACT_BPF_FD]);
228
229 fp = bpf_prog_get_type(bpf_fd, BPF_PROG_TYPE_SCHED_ACT);
230 if (IS_ERR(fp))
231 return PTR_ERR(fp);
232
233 if (tb[TCA_ACT_BPF_NAME]) {
234 name = nla_memdup(tb[TCA_ACT_BPF_NAME], GFP_KERNEL);
235 if (!name) {
236 bpf_prog_put(fp);
237 return -ENOMEM;
238 }
239 }
240
241 cfg->bpf_name = name;
242 cfg->filter = fp;
243 cfg->is_ebpf = true;
244
245 return 0;
246}
247
248static void tcf_bpf_cfg_cleanup(const struct tcf_bpf_cfg *cfg)
249{
250 struct bpf_prog *filter = cfg->filter;
251
252 if (filter) {
253 if (cfg->is_ebpf)
254 bpf_prog_put(filter);
255 else
256 bpf_prog_destroy(filter);
257 }
258
259 kfree(cfg->bpf_ops);
260 kfree(cfg->bpf_name);
261}
262
263static void tcf_bpf_prog_fill_cfg(const struct tcf_bpf *prog,
264 struct tcf_bpf_cfg *cfg)
265{
266 cfg->is_ebpf = tcf_bpf_is_ebpf(prog);
267
268
269
270 cfg->filter = rcu_dereference_protected(prog->filter, 1);
271
272 cfg->bpf_ops = prog->bpf_ops;
273 cfg->bpf_name = prog->bpf_name;
274}
275
276static int tcf_bpf_init(struct net *net, struct nlattr *nla,
277 struct nlattr *est, struct tc_action **act,
278 struct tcf_proto *tp, u32 flags,
279 struct netlink_ext_ack *extack)
280{
281 struct tc_action_net *tn = net_generic(net, bpf_net_id);
282 bool bind = flags & TCA_ACT_FLAGS_BIND;
283 struct nlattr *tb[TCA_ACT_BPF_MAX + 1];
284 struct tcf_chain *goto_ch = NULL;
285 struct tcf_bpf_cfg cfg, old;
286 struct tc_act_bpf *parm;
287 struct tcf_bpf *prog;
288 bool is_bpf, is_ebpf;
289 int ret, res = 0;
290 u32 index;
291
292 if (!nla)
293 return -EINVAL;
294
295 ret = nla_parse_nested_deprecated(tb, TCA_ACT_BPF_MAX, nla,
296 act_bpf_policy, NULL);
297 if (ret < 0)
298 return ret;
299
300 if (!tb[TCA_ACT_BPF_PARMS])
301 return -EINVAL;
302
303 parm = nla_data(tb[TCA_ACT_BPF_PARMS]);
304 index = parm->index;
305 ret = tcf_idr_check_alloc(tn, &index, act, bind);
306 if (!ret) {
307 ret = tcf_idr_create(tn, index, est, act,
308 &act_bpf_ops, bind, true, 0);
309 if (ret < 0) {
310 tcf_idr_cleanup(tn, index);
311 return ret;
312 }
313
314 res = ACT_P_CREATED;
315 } else if (ret > 0) {
316
317 if (bind)
318 return 0;
319
320 if (!(flags & TCA_ACT_FLAGS_REPLACE)) {
321 tcf_idr_release(*act, bind);
322 return -EEXIST;
323 }
324 } else {
325 return ret;
326 }
327
328 ret = tcf_action_check_ctrlact(parm->action, tp, &goto_ch, extack);
329 if (ret < 0)
330 goto release_idr;
331
332 is_bpf = tb[TCA_ACT_BPF_OPS_LEN] && tb[TCA_ACT_BPF_OPS];
333 is_ebpf = tb[TCA_ACT_BPF_FD];
334
335 if ((!is_bpf && !is_ebpf) || (is_bpf && is_ebpf)) {
336 ret = -EINVAL;
337 goto put_chain;
338 }
339
340 memset(&cfg, 0, sizeof(cfg));
341
342 ret = is_bpf ? tcf_bpf_init_from_ops(tb, &cfg) :
343 tcf_bpf_init_from_efd(tb, &cfg);
344 if (ret < 0)
345 goto put_chain;
346
347 prog = to_bpf(*act);
348
349 spin_lock_bh(&prog->tcf_lock);
350 if (res != ACT_P_CREATED)
351 tcf_bpf_prog_fill_cfg(prog, &old);
352
353 prog->bpf_ops = cfg.bpf_ops;
354 prog->bpf_name = cfg.bpf_name;
355
356 if (cfg.bpf_num_ops)
357 prog->bpf_num_ops = cfg.bpf_num_ops;
358
359 goto_ch = tcf_action_set_ctrlact(*act, parm->action, goto_ch);
360 rcu_assign_pointer(prog->filter, cfg.filter);
361 spin_unlock_bh(&prog->tcf_lock);
362
363 if (goto_ch)
364 tcf_chain_put_by_act(goto_ch);
365
366 if (res != ACT_P_CREATED) {
367
368 synchronize_rcu();
369 tcf_bpf_cfg_cleanup(&old);
370 }
371
372 return res;
373
374put_chain:
375 if (goto_ch)
376 tcf_chain_put_by_act(goto_ch);
377
378release_idr:
379 tcf_idr_release(*act, bind);
380 return ret;
381}
382
383static void tcf_bpf_cleanup(struct tc_action *act)
384{
385 struct tcf_bpf_cfg tmp;
386
387 tcf_bpf_prog_fill_cfg(to_bpf(act), &tmp);
388 tcf_bpf_cfg_cleanup(&tmp);
389}
390
391static int tcf_bpf_walker(struct net *net, struct sk_buff *skb,
392 struct netlink_callback *cb, int type,
393 const struct tc_action_ops *ops,
394 struct netlink_ext_ack *extack)
395{
396 struct tc_action_net *tn = net_generic(net, bpf_net_id);
397
398 return tcf_generic_walker(tn, skb, cb, type, ops, extack);
399}
400
401static int tcf_bpf_search(struct net *net, struct tc_action **a, u32 index)
402{
403 struct tc_action_net *tn = net_generic(net, bpf_net_id);
404
405 return tcf_idr_search(tn, a, index);
406}
407
408static struct tc_action_ops act_bpf_ops __read_mostly = {
409 .kind = "bpf",
410 .id = TCA_ID_BPF,
411 .owner = THIS_MODULE,
412 .act = tcf_bpf_act,
413 .dump = tcf_bpf_dump,
414 .cleanup = tcf_bpf_cleanup,
415 .init = tcf_bpf_init,
416 .walk = tcf_bpf_walker,
417 .lookup = tcf_bpf_search,
418 .size = sizeof(struct tcf_bpf),
419};
420
421static __net_init int bpf_init_net(struct net *net)
422{
423 struct tc_action_net *tn = net_generic(net, bpf_net_id);
424
425 return tc_action_net_init(net, tn, &act_bpf_ops);
426}
427
428static void __net_exit bpf_exit_net(struct list_head *net_list)
429{
430 tc_action_net_exit(net_list, bpf_net_id);
431}
432
433static struct pernet_operations bpf_net_ops = {
434 .init = bpf_init_net,
435 .exit_batch = bpf_exit_net,
436 .id = &bpf_net_id,
437 .size = sizeof(struct tc_action_net),
438};
439
440static int __init bpf_init_module(void)
441{
442 return tcf_register_action(&act_bpf_ops, &bpf_net_ops);
443}
444
445static void __exit bpf_cleanup_module(void)
446{
447 tcf_unregister_action(&act_bpf_ops, &bpf_net_ops);
448}
449
450module_init(bpf_init_module);
451module_exit(bpf_cleanup_module);
452
453MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
454MODULE_DESCRIPTION("TC BPF based action");
455MODULE_LICENSE("GPL v2");
456
