blob: a12bbd32c0a64ebe42689b411928709189df5b07 [file] [log] [blame]
Alexei Starovoitov25415172015-03-25 12:49:20 -07001/* Copyright (c) 2011-2015 PLUMgrid, http://plumgrid.com
2 *
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of version 2 of the GNU General Public
5 * License as published by the Free Software Foundation.
6 */
7#include <linux/kernel.h>
8#include <linux/types.h>
9#include <linux/slab.h>
10#include <linux/bpf.h>
11#include <linux/filter.h>
12#include <linux/uaccess.h>
Alexei Starovoitov9c959c82015-03-25 12:49:22 -070013#include <linux/ctype.h>
Alexei Starovoitov25415172015-03-25 12:49:20 -070014#include "trace.h"
15
Alexei Starovoitov25415172015-03-25 12:49:20 -070016/**
17 * trace_call_bpf - invoke BPF program
18 * @prog: BPF program
19 * @ctx: opaque context pointer
20 *
21 * kprobe handlers execute BPF programs via this helper.
22 * Can be used from static tracepoints in the future.
23 *
24 * Return: BPF programs always return an integer which is interpreted by
25 * kprobe handler as:
26 * 0 - return from kprobe (event is filtered out)
27 * 1 - store kprobe event into ring buffer
28 * Other values are reserved and currently alias to 1
29 */
30unsigned int trace_call_bpf(struct bpf_prog *prog, void *ctx)
31{
32 unsigned int ret;
33
34 if (in_nmi()) /* not supported yet */
35 return 1;
36
37 preempt_disable();
38
39 if (unlikely(__this_cpu_inc_return(bpf_prog_active) != 1)) {
40 /*
41 * since some bpf program is already running on this cpu,
42 * don't call into another bpf program (same or different)
43 * and don't send kprobe event into ring-buffer,
44 * so return zero here
45 */
46 ret = 0;
47 goto out;
48 }
49
50 rcu_read_lock();
51 ret = BPF_PROG_RUN(prog, ctx);
52 rcu_read_unlock();
53
54 out:
55 __this_cpu_dec(bpf_prog_active);
56 preempt_enable();
57
58 return ret;
59}
60EXPORT_SYMBOL_GPL(trace_call_bpf);
61
62static u64 bpf_probe_read(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)
63{
64 void *dst = (void *) (long) r1;
Daniel Borkmann074f528e2016-04-13 00:10:52 +020065 int ret, size = (int) r2;
Alexei Starovoitov25415172015-03-25 12:49:20 -070066 void *unsafe_ptr = (void *) (long) r3;
67
Daniel Borkmann074f528e2016-04-13 00:10:52 +020068 ret = probe_kernel_read(dst, unsafe_ptr, size);
69 if (unlikely(ret < 0))
70 memset(dst, 0, size);
71
72 return ret;
Alexei Starovoitov25415172015-03-25 12:49:20 -070073}
74
75static const struct bpf_func_proto bpf_probe_read_proto = {
76 .func = bpf_probe_read,
77 .gpl_only = true,
78 .ret_type = RET_INTEGER,
Daniel Borkmann074f528e2016-04-13 00:10:52 +020079 .arg1_type = ARG_PTR_TO_RAW_STACK,
Alexei Starovoitov25415172015-03-25 12:49:20 -070080 .arg2_type = ARG_CONST_STACK_SIZE,
81 .arg3_type = ARG_ANYTHING,
82};
83
Alexei Starovoitov9c959c82015-03-25 12:49:22 -070084/*
85 * limited trace_printk()
Alexei Starovoitov8d3b7dc2015-08-28 15:56:23 -070086 * only %d %u %x %ld %lu %lx %lld %llu %llx %p %s conversion specifiers allowed
Alexei Starovoitov9c959c82015-03-25 12:49:22 -070087 */
88static u64 bpf_trace_printk(u64 r1, u64 fmt_size, u64 r3, u64 r4, u64 r5)
89{
90 char *fmt = (char *) (long) r1;
Alexei Starovoitov8d3b7dc2015-08-28 15:56:23 -070091 bool str_seen = false;
Alexei Starovoitov9c959c82015-03-25 12:49:22 -070092 int mod[3] = {};
93 int fmt_cnt = 0;
Alexei Starovoitov8d3b7dc2015-08-28 15:56:23 -070094 u64 unsafe_addr;
95 char buf[64];
Alexei Starovoitov9c959c82015-03-25 12:49:22 -070096 int i;
97
98 /*
99 * bpf_check()->check_func_arg()->check_stack_boundary()
100 * guarantees that fmt points to bpf program stack,
101 * fmt_size bytes of it were initialized and fmt_size > 0
102 */
103 if (fmt[--fmt_size] != 0)
104 return -EINVAL;
105
106 /* check format string for allowed specifiers */
107 for (i = 0; i < fmt_size; i++) {
108 if ((!isprint(fmt[i]) && !isspace(fmt[i])) || !isascii(fmt[i]))
109 return -EINVAL;
110
111 if (fmt[i] != '%')
112 continue;
113
114 if (fmt_cnt >= 3)
115 return -EINVAL;
116
117 /* fmt[i] != 0 && fmt[last] == 0, so we can access fmt[i + 1] */
118 i++;
119 if (fmt[i] == 'l') {
120 mod[fmt_cnt]++;
121 i++;
Alexei Starovoitov8d3b7dc2015-08-28 15:56:23 -0700122 } else if (fmt[i] == 'p' || fmt[i] == 's') {
Alexei Starovoitov9c959c82015-03-25 12:49:22 -0700123 mod[fmt_cnt]++;
124 i++;
125 if (!isspace(fmt[i]) && !ispunct(fmt[i]) && fmt[i] != 0)
126 return -EINVAL;
127 fmt_cnt++;
Alexei Starovoitov8d3b7dc2015-08-28 15:56:23 -0700128 if (fmt[i - 1] == 's') {
129 if (str_seen)
130 /* allow only one '%s' per fmt string */
131 return -EINVAL;
132 str_seen = true;
133
134 switch (fmt_cnt) {
135 case 1:
136 unsafe_addr = r3;
137 r3 = (long) buf;
138 break;
139 case 2:
140 unsafe_addr = r4;
141 r4 = (long) buf;
142 break;
143 case 3:
144 unsafe_addr = r5;
145 r5 = (long) buf;
146 break;
147 }
148 buf[0] = 0;
149 strncpy_from_unsafe(buf,
150 (void *) (long) unsafe_addr,
151 sizeof(buf));
152 }
Alexei Starovoitov9c959c82015-03-25 12:49:22 -0700153 continue;
154 }
155
156 if (fmt[i] == 'l') {
157 mod[fmt_cnt]++;
158 i++;
159 }
160
161 if (fmt[i] != 'd' && fmt[i] != 'u' && fmt[i] != 'x')
162 return -EINVAL;
163 fmt_cnt++;
164 }
165
166 return __trace_printk(1/* fake ip will not be printed */, fmt,
167 mod[0] == 2 ? r3 : mod[0] == 1 ? (long) r3 : (u32) r3,
168 mod[1] == 2 ? r4 : mod[1] == 1 ? (long) r4 : (u32) r4,
169 mod[2] == 2 ? r5 : mod[2] == 1 ? (long) r5 : (u32) r5);
170}
171
172static const struct bpf_func_proto bpf_trace_printk_proto = {
173 .func = bpf_trace_printk,
174 .gpl_only = true,
175 .ret_type = RET_INTEGER,
176 .arg1_type = ARG_PTR_TO_STACK,
177 .arg2_type = ARG_CONST_STACK_SIZE,
178};
179
Alexei Starovoitov0756ea32015-06-12 19:39:13 -0700180const struct bpf_func_proto *bpf_get_trace_printk_proto(void)
181{
182 /*
183 * this program might be calling bpf_trace_printk,
184 * so allocate per-cpu printk buffers
185 */
186 trace_printk_init_buffers();
187
188 return &bpf_trace_printk_proto;
189}
190
Daniel Borkmann6816a7f2016-06-28 12:18:25 +0200191static u64 bpf_perf_event_read(u64 r1, u64 flags, u64 r3, u64 r4, u64 r5)
Kaixu Xia35578d72015-08-06 07:02:35 +0000192{
193 struct bpf_map *map = (struct bpf_map *) (unsigned long) r1;
194 struct bpf_array *array = container_of(map, struct bpf_array, map);
Daniel Borkmann6816a7f2016-06-28 12:18:25 +0200195 unsigned int cpu = smp_processor_id();
196 u64 index = flags & BPF_F_INDEX_MASK;
Daniel Borkmann3b1efb12016-06-15 22:47:14 +0200197 struct bpf_event_entry *ee;
Kaixu Xia35578d72015-08-06 07:02:35 +0000198 struct perf_event *event;
199
Daniel Borkmann6816a7f2016-06-28 12:18:25 +0200200 if (unlikely(flags & ~(BPF_F_INDEX_MASK)))
201 return -EINVAL;
202 if (index == BPF_F_CURRENT_CPU)
203 index = cpu;
Kaixu Xia35578d72015-08-06 07:02:35 +0000204 if (unlikely(index >= array->map.max_entries))
205 return -E2BIG;
206
Daniel Borkmann3b1efb12016-06-15 22:47:14 +0200207 ee = READ_ONCE(array->ptrs[index]);
Daniel Borkmann1ca1cc92016-06-28 12:18:23 +0200208 if (!ee)
Kaixu Xia35578d72015-08-06 07:02:35 +0000209 return -ENOENT;
210
Daniel Borkmann3b1efb12016-06-15 22:47:14 +0200211 event = ee->event;
Daniel Borkmann1ca1cc92016-06-28 12:18:23 +0200212 if (unlikely(event->attr.type != PERF_TYPE_HARDWARE &&
213 event->attr.type != PERF_TYPE_RAW))
214 return -EINVAL;
215
Alexei Starovoitov62544ce2015-10-22 17:10:14 -0700216 /* make sure event is local and doesn't have pmu::count */
Daniel Borkmann6816a7f2016-06-28 12:18:25 +0200217 if (unlikely(event->oncpu != cpu || event->pmu->count))
Alexei Starovoitov62544ce2015-10-22 17:10:14 -0700218 return -EINVAL;
219
Kaixu Xia35578d72015-08-06 07:02:35 +0000220 /*
221 * we don't know if the function is run successfully by the
222 * return value. It can be judged in other places, such as
223 * eBPF programs.
224 */
225 return perf_event_read_local(event);
226}
227
Alexei Starovoitov62544ce2015-10-22 17:10:14 -0700228static const struct bpf_func_proto bpf_perf_event_read_proto = {
Kaixu Xia35578d72015-08-06 07:02:35 +0000229 .func = bpf_perf_event_read,
Alexei Starovoitov1075ef52015-10-23 14:58:19 -0700230 .gpl_only = true,
Kaixu Xia35578d72015-08-06 07:02:35 +0000231 .ret_type = RET_INTEGER,
232 .arg1_type = ARG_CONST_MAP_PTR,
233 .arg2_type = ARG_ANYTHING,
234};
235
Daniel Borkmann8e7a3922016-07-14 18:08:04 +0200236static __always_inline u64
237__bpf_perf_event_output(struct pt_regs *regs, struct bpf_map *map,
238 u64 flags, struct perf_raw_record *raw)
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700239{
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700240 struct bpf_array *array = container_of(map, struct bpf_array, map);
Daniel Borkmannd7931332016-06-28 12:18:24 +0200241 unsigned int cpu = smp_processor_id();
Daniel Borkmann1e337592016-04-18 21:01:23 +0200242 u64 index = flags & BPF_F_INDEX_MASK;
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700243 struct perf_sample_data sample_data;
Daniel Borkmann3b1efb12016-06-15 22:47:14 +0200244 struct bpf_event_entry *ee;
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700245 struct perf_event *event;
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700246
Daniel Borkmann1e337592016-04-18 21:01:23 +0200247 if (index == BPF_F_CURRENT_CPU)
Daniel Borkmannd7931332016-06-28 12:18:24 +0200248 index = cpu;
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700249 if (unlikely(index >= array->map.max_entries))
250 return -E2BIG;
251
Daniel Borkmann3b1efb12016-06-15 22:47:14 +0200252 ee = READ_ONCE(array->ptrs[index]);
Daniel Borkmann1ca1cc92016-06-28 12:18:23 +0200253 if (!ee)
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700254 return -ENOENT;
255
Daniel Borkmann3b1efb12016-06-15 22:47:14 +0200256 event = ee->event;
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700257 if (unlikely(event->attr.type != PERF_TYPE_SOFTWARE ||
258 event->attr.config != PERF_COUNT_SW_BPF_OUTPUT))
259 return -EINVAL;
260
Daniel Borkmannd7931332016-06-28 12:18:24 +0200261 if (unlikely(event->oncpu != cpu))
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700262 return -EOPNOTSUPP;
263
264 perf_sample_data_init(&sample_data, 0, 0);
Daniel Borkmann8e7a3922016-07-14 18:08:04 +0200265 sample_data.raw = raw;
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700266 perf_event_output(event, &sample_data, regs);
267 return 0;
268}
269
Daniel Borkmann8e7a3922016-07-14 18:08:04 +0200270static u64 bpf_perf_event_output(u64 r1, u64 r2, u64 flags, u64 r4, u64 size)
271{
272 struct pt_regs *regs = (struct pt_regs *)(long) r1;
273 struct bpf_map *map = (struct bpf_map *)(long) r2;
274 void *data = (void *)(long) r4;
275 struct perf_raw_record raw = {
276 .frag = {
277 .size = size,
278 .data = data,
279 },
280 };
281
282 if (unlikely(flags & ~(BPF_F_INDEX_MASK)))
283 return -EINVAL;
284
285 return __bpf_perf_event_output(regs, map, flags, &raw);
286}
287
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700288static const struct bpf_func_proto bpf_perf_event_output_proto = {
289 .func = bpf_perf_event_output,
Alexei Starovoitov1075ef52015-10-23 14:58:19 -0700290 .gpl_only = true,
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700291 .ret_type = RET_INTEGER,
292 .arg1_type = ARG_PTR_TO_CTX,
293 .arg2_type = ARG_CONST_MAP_PTR,
294 .arg3_type = ARG_ANYTHING,
295 .arg4_type = ARG_PTR_TO_STACK,
296 .arg5_type = ARG_CONST_STACK_SIZE,
297};
298
Daniel Borkmannbd570ff2016-04-18 21:01:24 +0200299static DEFINE_PER_CPU(struct pt_regs, bpf_pt_regs);
300
Daniel Borkmann555c8a82016-07-14 18:08:05 +0200301u64 bpf_event_output(struct bpf_map *map, u64 flags, void *meta, u64 meta_size,
302 void *ctx, u64 ctx_size, bpf_ctx_copy_t ctx_copy)
Daniel Borkmannbd570ff2016-04-18 21:01:24 +0200303{
304 struct pt_regs *regs = this_cpu_ptr(&bpf_pt_regs);
Daniel Borkmann555c8a82016-07-14 18:08:05 +0200305 struct perf_raw_frag frag = {
306 .copy = ctx_copy,
307 .size = ctx_size,
308 .data = ctx,
309 };
310 struct perf_raw_record raw = {
311 .frag = {
Andrew Morton183fc152016-07-18 15:50:58 -0700312 {
313 .next = ctx_size ? &frag : NULL,
314 },
Daniel Borkmann555c8a82016-07-14 18:08:05 +0200315 .size = meta_size,
316 .data = meta,
317 },
318 };
Daniel Borkmannbd570ff2016-04-18 21:01:24 +0200319
320 perf_fetch_caller_regs(regs);
321
Daniel Borkmann555c8a82016-07-14 18:08:05 +0200322 return __bpf_perf_event_output(regs, map, flags, &raw);
Daniel Borkmannbd570ff2016-04-18 21:01:24 +0200323}
324
Alexei Starovoitov606274c2016-07-06 22:38:36 -0700325static u64 bpf_get_current_task(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)
326{
327 return (long) current;
328}
329
330static const struct bpf_func_proto bpf_get_current_task_proto = {
331 .func = bpf_get_current_task,
332 .gpl_only = true,
333 .ret_type = RET_INTEGER,
334};
335
Alexei Starovoitov9fd82b612016-04-06 18:43:26 -0700336static const struct bpf_func_proto *tracing_func_proto(enum bpf_func_id func_id)
Alexei Starovoitov25415172015-03-25 12:49:20 -0700337{
338 switch (func_id) {
339 case BPF_FUNC_map_lookup_elem:
340 return &bpf_map_lookup_elem_proto;
341 case BPF_FUNC_map_update_elem:
342 return &bpf_map_update_elem_proto;
343 case BPF_FUNC_map_delete_elem:
344 return &bpf_map_delete_elem_proto;
345 case BPF_FUNC_probe_read:
346 return &bpf_probe_read_proto;
Alexei Starovoitovd9847d32015-03-25 12:49:21 -0700347 case BPF_FUNC_ktime_get_ns:
348 return &bpf_ktime_get_ns_proto;
Alexei Starovoitov04fd61ab2015-05-19 16:59:03 -0700349 case BPF_FUNC_tail_call:
350 return &bpf_tail_call_proto;
Alexei Starovoitovffeedaf2015-06-12 19:39:12 -0700351 case BPF_FUNC_get_current_pid_tgid:
352 return &bpf_get_current_pid_tgid_proto;
Alexei Starovoitov606274c2016-07-06 22:38:36 -0700353 case BPF_FUNC_get_current_task:
354 return &bpf_get_current_task_proto;
Alexei Starovoitovffeedaf2015-06-12 19:39:12 -0700355 case BPF_FUNC_get_current_uid_gid:
356 return &bpf_get_current_uid_gid_proto;
357 case BPF_FUNC_get_current_comm:
358 return &bpf_get_current_comm_proto;
Alexei Starovoitov9c959c82015-03-25 12:49:22 -0700359 case BPF_FUNC_trace_printk:
Alexei Starovoitov0756ea32015-06-12 19:39:13 -0700360 return bpf_get_trace_printk_proto();
Alexei Starovoitovab1973d2015-06-12 19:39:14 -0700361 case BPF_FUNC_get_smp_processor_id:
362 return &bpf_get_smp_processor_id_proto;
Kaixu Xia35578d72015-08-06 07:02:35 +0000363 case BPF_FUNC_perf_event_read:
364 return &bpf_perf_event_read_proto;
Alexei Starovoitov9fd82b612016-04-06 18:43:26 -0700365 default:
366 return NULL;
367 }
368}
369
370static const struct bpf_func_proto *kprobe_prog_func_proto(enum bpf_func_id func_id)
371{
372 switch (func_id) {
Alexei Starovoitova43eec32015-10-20 20:02:34 -0700373 case BPF_FUNC_perf_event_output:
374 return &bpf_perf_event_output_proto;
Alexei Starovoitovd5a3b1f2016-02-17 19:58:58 -0800375 case BPF_FUNC_get_stackid:
376 return &bpf_get_stackid_proto;
Alexei Starovoitov25415172015-03-25 12:49:20 -0700377 default:
Alexei Starovoitov9fd82b612016-04-06 18:43:26 -0700378 return tracing_func_proto(func_id);
Alexei Starovoitov25415172015-03-25 12:49:20 -0700379 }
380}
381
382/* bpf+kprobe programs can access fields of 'struct pt_regs' */
Alexei Starovoitov19de99f2016-06-15 18:25:38 -0700383static bool kprobe_prog_is_valid_access(int off, int size, enum bpf_access_type type,
384 enum bpf_reg_type *reg_type)
Alexei Starovoitov25415172015-03-25 12:49:20 -0700385{
Alexei Starovoitov25415172015-03-25 12:49:20 -0700386 if (off < 0 || off >= sizeof(struct pt_regs))
387 return false;
Alexei Starovoitov25415172015-03-25 12:49:20 -0700388 if (type != BPF_READ)
389 return false;
Alexei Starovoitov25415172015-03-25 12:49:20 -0700390 if (off % size != 0)
391 return false;
Alexei Starovoitov25415172015-03-25 12:49:20 -0700392 return true;
393}
394
Julia Lawall27dff4e2015-12-11 18:35:59 +0100395static const struct bpf_verifier_ops kprobe_prog_ops = {
Alexei Starovoitov25415172015-03-25 12:49:20 -0700396 .get_func_proto = kprobe_prog_func_proto,
397 .is_valid_access = kprobe_prog_is_valid_access,
398};
399
400static struct bpf_prog_type_list kprobe_tl = {
401 .ops = &kprobe_prog_ops,
402 .type = BPF_PROG_TYPE_KPROBE,
403};
404
Alexei Starovoitov9940d672016-04-06 18:43:27 -0700405static u64 bpf_perf_event_output_tp(u64 r1, u64 r2, u64 index, u64 r4, u64 size)
406{
407 /*
408 * r1 points to perf tracepoint buffer where first 8 bytes are hidden
409 * from bpf program and contain a pointer to 'struct pt_regs'. Fetch it
410 * from there and call the same bpf_perf_event_output() helper
411 */
Arnd Bergmann266a0a72016-04-16 22:29:33 +0200412 u64 ctx = *(long *)(uintptr_t)r1;
Alexei Starovoitov9940d672016-04-06 18:43:27 -0700413
414 return bpf_perf_event_output(ctx, r2, index, r4, size);
415}
416
417static const struct bpf_func_proto bpf_perf_event_output_proto_tp = {
418 .func = bpf_perf_event_output_tp,
419 .gpl_only = true,
420 .ret_type = RET_INTEGER,
421 .arg1_type = ARG_PTR_TO_CTX,
422 .arg2_type = ARG_CONST_MAP_PTR,
423 .arg3_type = ARG_ANYTHING,
424 .arg4_type = ARG_PTR_TO_STACK,
425 .arg5_type = ARG_CONST_STACK_SIZE,
426};
427
428static u64 bpf_get_stackid_tp(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)
429{
Arnd Bergmann266a0a72016-04-16 22:29:33 +0200430 u64 ctx = *(long *)(uintptr_t)r1;
Alexei Starovoitov9940d672016-04-06 18:43:27 -0700431
432 return bpf_get_stackid(ctx, r2, r3, r4, r5);
433}
434
435static const struct bpf_func_proto bpf_get_stackid_proto_tp = {
436 .func = bpf_get_stackid_tp,
437 .gpl_only = true,
438 .ret_type = RET_INTEGER,
439 .arg1_type = ARG_PTR_TO_CTX,
440 .arg2_type = ARG_CONST_MAP_PTR,
441 .arg3_type = ARG_ANYTHING,
442};
443
Alexei Starovoitov9fd82b612016-04-06 18:43:26 -0700444static const struct bpf_func_proto *tp_prog_func_proto(enum bpf_func_id func_id)
445{
446 switch (func_id) {
447 case BPF_FUNC_perf_event_output:
Alexei Starovoitov9940d672016-04-06 18:43:27 -0700448 return &bpf_perf_event_output_proto_tp;
Alexei Starovoitov9fd82b612016-04-06 18:43:26 -0700449 case BPF_FUNC_get_stackid:
Alexei Starovoitov9940d672016-04-06 18:43:27 -0700450 return &bpf_get_stackid_proto_tp;
Alexei Starovoitov9fd82b612016-04-06 18:43:26 -0700451 default:
452 return tracing_func_proto(func_id);
453 }
454}
455
Alexei Starovoitov19de99f2016-06-15 18:25:38 -0700456static bool tp_prog_is_valid_access(int off, int size, enum bpf_access_type type,
457 enum bpf_reg_type *reg_type)
Alexei Starovoitov9fd82b612016-04-06 18:43:26 -0700458{
459 if (off < sizeof(void *) || off >= PERF_MAX_TRACE_SIZE)
460 return false;
461 if (type != BPF_READ)
462 return false;
463 if (off % size != 0)
464 return false;
465 return true;
466}
467
468static const struct bpf_verifier_ops tracepoint_prog_ops = {
469 .get_func_proto = tp_prog_func_proto,
470 .is_valid_access = tp_prog_is_valid_access,
471};
472
473static struct bpf_prog_type_list tracepoint_tl = {
474 .ops = &tracepoint_prog_ops,
475 .type = BPF_PROG_TYPE_TRACEPOINT,
476};
477
Alexei Starovoitov25415172015-03-25 12:49:20 -0700478static int __init register_kprobe_prog_ops(void)
479{
480 bpf_register_prog_type(&kprobe_tl);
Alexei Starovoitov9fd82b612016-04-06 18:43:26 -0700481 bpf_register_prog_type(&tracepoint_tl);
Alexei Starovoitov25415172015-03-25 12:49:20 -0700482 return 0;
483}
484late_initcall(register_kprobe_prog_ops);