Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma
[platform/kernel/linux-rpi.git] / net / sched / act_bpf.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (c) 2015 Jiri Pirko <jiri@resnulli.us>
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
24 struct 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
32 static unsigned int bpf_net_id;
33 static struct tc_action_ops act_bpf_ops;
34
35 static 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         /* A BPF program may overwrite the default action opcode.
60          * Similarly as in cls_bpf, if filter_res == -1 we use the
61          * default action specified from tc.
62          *
63          * In case a different well-known TC_ACT opcode has been
64          * returned, it will overwrite the default one.
65          *
66          * For everything else that is unknown, TC_ACT_UNSPEC is
67          * returned.
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
91 static bool tcf_bpf_is_ebpf(const struct tcf_bpf *prog)
92 {
93         return !prog->bpf_ops;
94 }
95
96 static 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
114 static 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
135 static 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
168 nla_put_failure:
169         spin_unlock_bh(&prog->tcf_lock);
170         nlmsg_trim(skb, tp);
171         return -1;
172 }
173
174 static 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
184 static 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
221 static 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
248 static 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
263 static 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         /* updates to prog->filter are prevented, since it's called either
268          * with tcf lock or during final cleanup in rcu callback
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
276 static 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                 /* Don't override defaults. */
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                 /* make sure the program being replaced is no longer executing */
368                 synchronize_rcu();
369                 tcf_bpf_cfg_cleanup(&old);
370         }
371
372         return res;
373
374 put_chain:
375         if (goto_ch)
376                 tcf_chain_put_by_act(goto_ch);
377
378 release_idr:
379         tcf_idr_release(*act, bind);
380         return ret;
381 }
382
383 static 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
391 static 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
401 static 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
408 static 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
421 static __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
428 static void __net_exit bpf_exit_net(struct list_head *net_list)
429 {
430         tc_action_net_exit(net_list, bpf_net_id);
431 }
432
433 static 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
440 static int __init bpf_init_module(void)
441 {
442         return tcf_register_action(&act_bpf_ops, &bpf_net_ops);
443 }
444
445 static void __exit bpf_cleanup_module(void)
446 {
447         tcf_unregister_action(&act_bpf_ops, &bpf_net_ops);
448 }
449
450 module_init(bpf_init_module);
451 module_exit(bpf_cleanup_module);
452
453 MODULE_AUTHOR("Jiri Pirko <jiri@resnulli.us>");
454 MODULE_DESCRIPTION("TC BPF based action");
455 MODULE_LICENSE("GPL v2");