Merge tag '5.10-rc-smb3-fixes-part1' of git://git.samba.org/sfrench/cifs-2.6
[linux-2.6-microblaze.git] / tools / lib / bpf / bpf_prog_linfo.c
1 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
2 /* Copyright (c) 2018 Facebook */
3
4 #include <string.h>
5 #include <stdlib.h>
6 #include <linux/err.h>
7 #include <linux/bpf.h>
8 #include "libbpf.h"
9 #include "libbpf_internal.h"
10
11 struct bpf_prog_linfo {
12         void *raw_linfo;
13         void *raw_jited_linfo;
14         __u32 *nr_jited_linfo_per_func;
15         __u32 *jited_linfo_func_idx;
16         __u32 nr_linfo;
17         __u32 nr_jited_func;
18         __u32 rec_size;
19         __u32 jited_rec_size;
20 };
21
22 static int dissect_jited_func(struct bpf_prog_linfo *prog_linfo,
23                               const __u64 *ksym_func, const __u32 *ksym_len)
24 {
25         __u32 nr_jited_func, nr_linfo;
26         const void *raw_jited_linfo;
27         const __u64 *jited_linfo;
28         __u64 last_jited_linfo;
29         /*
30          * Index to raw_jited_linfo:
31          *      i: Index for searching the next ksym_func
32          * prev_i: Index to the last found ksym_func
33          */
34         __u32 i, prev_i;
35         __u32 f; /* Index to ksym_func */
36
37         raw_jited_linfo = prog_linfo->raw_jited_linfo;
38         jited_linfo = raw_jited_linfo;
39         if (ksym_func[0] != *jited_linfo)
40                 goto errout;
41
42         prog_linfo->jited_linfo_func_idx[0] = 0;
43         nr_jited_func = prog_linfo->nr_jited_func;
44         nr_linfo = prog_linfo->nr_linfo;
45
46         for (prev_i = 0, i = 1, f = 1;
47              i < nr_linfo && f < nr_jited_func;
48              i++) {
49                 raw_jited_linfo += prog_linfo->jited_rec_size;
50                 last_jited_linfo = *jited_linfo;
51                 jited_linfo = raw_jited_linfo;
52
53                 if (ksym_func[f] == *jited_linfo) {
54                         prog_linfo->jited_linfo_func_idx[f] = i;
55
56                         /* Sanity check */
57                         if (last_jited_linfo - ksym_func[f - 1] + 1 >
58                             ksym_len[f - 1])
59                                 goto errout;
60
61                         prog_linfo->nr_jited_linfo_per_func[f - 1] =
62                                 i - prev_i;
63                         prev_i = i;
64
65                         /*
66                          * The ksym_func[f] is found in jited_linfo.
67                          * Look for the next one.
68                          */
69                         f++;
70                 } else if (*jited_linfo <= last_jited_linfo) {
71                         /* Ensure the addr is increasing _within_ a func */
72                         goto errout;
73                 }
74         }
75
76         if (f != nr_jited_func)
77                 goto errout;
78
79         prog_linfo->nr_jited_linfo_per_func[nr_jited_func - 1] =
80                 nr_linfo - prev_i;
81
82         return 0;
83
84 errout:
85         return -EINVAL;
86 }
87
88 void bpf_prog_linfo__free(struct bpf_prog_linfo *prog_linfo)
89 {
90         if (!prog_linfo)
91                 return;
92
93         free(prog_linfo->raw_linfo);
94         free(prog_linfo->raw_jited_linfo);
95         free(prog_linfo->nr_jited_linfo_per_func);
96         free(prog_linfo->jited_linfo_func_idx);
97         free(prog_linfo);
98 }
99
100 struct bpf_prog_linfo *bpf_prog_linfo__new(const struct bpf_prog_info *info)
101 {
102         struct bpf_prog_linfo *prog_linfo;
103         __u32 nr_linfo, nr_jited_func;
104         __u64 data_sz;
105
106         nr_linfo = info->nr_line_info;
107
108         if (!nr_linfo)
109                 return NULL;
110
111         /*
112          * The min size that bpf_prog_linfo has to access for
113          * searching purpose.
114          */
115         if (info->line_info_rec_size <
116             offsetof(struct bpf_line_info, file_name_off))
117                 return NULL;
118
119         prog_linfo = calloc(1, sizeof(*prog_linfo));
120         if (!prog_linfo)
121                 return NULL;
122
123         /* Copy xlated line_info */
124         prog_linfo->nr_linfo = nr_linfo;
125         prog_linfo->rec_size = info->line_info_rec_size;
126         data_sz = (__u64)nr_linfo * prog_linfo->rec_size;
127         prog_linfo->raw_linfo = malloc(data_sz);
128         if (!prog_linfo->raw_linfo)
129                 goto err_free;
130         memcpy(prog_linfo->raw_linfo, (void *)(long)info->line_info, data_sz);
131
132         nr_jited_func = info->nr_jited_ksyms;
133         if (!nr_jited_func ||
134             !info->jited_line_info ||
135             info->nr_jited_line_info != nr_linfo ||
136             info->jited_line_info_rec_size < sizeof(__u64) ||
137             info->nr_jited_func_lens != nr_jited_func ||
138             !info->jited_ksyms ||
139             !info->jited_func_lens)
140                 /* Not enough info to provide jited_line_info */
141                 return prog_linfo;
142
143         /* Copy jited_line_info */
144         prog_linfo->nr_jited_func = nr_jited_func;
145         prog_linfo->jited_rec_size = info->jited_line_info_rec_size;
146         data_sz = (__u64)nr_linfo * prog_linfo->jited_rec_size;
147         prog_linfo->raw_jited_linfo = malloc(data_sz);
148         if (!prog_linfo->raw_jited_linfo)
149                 goto err_free;
150         memcpy(prog_linfo->raw_jited_linfo,
151                (void *)(long)info->jited_line_info, data_sz);
152
153         /* Number of jited_line_info per jited func */
154         prog_linfo->nr_jited_linfo_per_func = malloc(nr_jited_func *
155                                                      sizeof(__u32));
156         if (!prog_linfo->nr_jited_linfo_per_func)
157                 goto err_free;
158
159         /*
160          * For each jited func,
161          * the start idx to the "linfo" and "jited_linfo" array,
162          */
163         prog_linfo->jited_linfo_func_idx = malloc(nr_jited_func *
164                                                   sizeof(__u32));
165         if (!prog_linfo->jited_linfo_func_idx)
166                 goto err_free;
167
168         if (dissect_jited_func(prog_linfo,
169                                (__u64 *)(long)info->jited_ksyms,
170                                (__u32 *)(long)info->jited_func_lens))
171                 goto err_free;
172
173         return prog_linfo;
174
175 err_free:
176         bpf_prog_linfo__free(prog_linfo);
177         return NULL;
178 }
179
180 const struct bpf_line_info *
181 bpf_prog_linfo__lfind_addr_func(const struct bpf_prog_linfo *prog_linfo,
182                                 __u64 addr, __u32 func_idx, __u32 nr_skip)
183 {
184         __u32 jited_rec_size, rec_size, nr_linfo, start, i;
185         const void *raw_jited_linfo, *raw_linfo;
186         const __u64 *jited_linfo;
187
188         if (func_idx >= prog_linfo->nr_jited_func)
189                 return NULL;
190
191         nr_linfo = prog_linfo->nr_jited_linfo_per_func[func_idx];
192         if (nr_skip >= nr_linfo)
193                 return NULL;
194
195         start = prog_linfo->jited_linfo_func_idx[func_idx] + nr_skip;
196         jited_rec_size = prog_linfo->jited_rec_size;
197         raw_jited_linfo = prog_linfo->raw_jited_linfo +
198                 (start * jited_rec_size);
199         jited_linfo = raw_jited_linfo;
200         if (addr < *jited_linfo)
201                 return NULL;
202
203         nr_linfo -= nr_skip;
204         rec_size = prog_linfo->rec_size;
205         raw_linfo = prog_linfo->raw_linfo + (start * rec_size);
206         for (i = 0; i < nr_linfo; i++) {
207                 if (addr < *jited_linfo)
208                         break;
209
210                 raw_linfo += rec_size;
211                 raw_jited_linfo += jited_rec_size;
212                 jited_linfo = raw_jited_linfo;
213         }
214
215         return raw_linfo - rec_size;
216 }
217
218 const struct bpf_line_info *
219 bpf_prog_linfo__lfind(const struct bpf_prog_linfo *prog_linfo,
220                       __u32 insn_off, __u32 nr_skip)
221 {
222         const struct bpf_line_info *linfo;
223         __u32 rec_size, nr_linfo, i;
224         const void *raw_linfo;
225
226         nr_linfo = prog_linfo->nr_linfo;
227         if (nr_skip >= nr_linfo)
228                 return NULL;
229
230         rec_size = prog_linfo->rec_size;
231         raw_linfo = prog_linfo->raw_linfo + (nr_skip * rec_size);
232         linfo = raw_linfo;
233         if (insn_off < linfo->insn_off)
234                 return NULL;
235
236         nr_linfo -= nr_skip;
237         for (i = 0; i < nr_linfo; i++) {
238                 if (insn_off < linfo->insn_off)
239                         break;
240
241                 raw_linfo += rec_size;
242                 linfo = raw_linfo;
243         }
244
245         return raw_linfo - rec_size;
246 }