GNU Linux-libre 4.19.211-gnu1
[releases.git] / tools / perf / util / symbol-minimal.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include "symbol.h"
3 #include "util.h"
4
5 #include <errno.h>
6 #include <stdio.h>
7 #include <fcntl.h>
8 #include <string.h>
9 #include <byteswap.h>
10 #include <sys/stat.h>
11
12
13 static bool check_need_swap(int file_endian)
14 {
15         const int data = 1;
16         u8 *check = (u8 *)&data;
17         int host_endian;
18
19         if (check[0] == 1)
20                 host_endian = ELFDATA2LSB;
21         else
22                 host_endian = ELFDATA2MSB;
23
24         return host_endian != file_endian;
25 }
26
27 #define NOTE_ALIGN(sz) (((sz) + 3) & ~3)
28
29 #define NT_GNU_BUILD_ID 3
30
31 static int read_build_id(void *note_data, size_t note_len, void *bf,
32                          size_t size, bool need_swap)
33 {
34         struct {
35                 u32 n_namesz;
36                 u32 n_descsz;
37                 u32 n_type;
38         } *nhdr;
39         void *ptr;
40
41         ptr = note_data;
42         while (ptr < (note_data + note_len)) {
43                 const char *name;
44                 size_t namesz, descsz;
45
46                 nhdr = ptr;
47                 if (need_swap) {
48                         nhdr->n_namesz = bswap_32(nhdr->n_namesz);
49                         nhdr->n_descsz = bswap_32(nhdr->n_descsz);
50                         nhdr->n_type = bswap_32(nhdr->n_type);
51                 }
52
53                 namesz = NOTE_ALIGN(nhdr->n_namesz);
54                 descsz = NOTE_ALIGN(nhdr->n_descsz);
55
56                 ptr += sizeof(*nhdr);
57                 name = ptr;
58                 ptr += namesz;
59                 if (nhdr->n_type == NT_GNU_BUILD_ID &&
60                     nhdr->n_namesz == sizeof("GNU")) {
61                         if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
62                                 size_t sz = min(size, descsz);
63                                 memcpy(bf, ptr, sz);
64                                 memset(bf + sz, 0, size - sz);
65                                 return 0;
66                         }
67                 }
68                 ptr += descsz;
69         }
70
71         return -1;
72 }
73
74 int filename__read_debuglink(const char *filename __maybe_unused,
75                              char *debuglink __maybe_unused,
76                              size_t size __maybe_unused)
77 {
78         return -1;
79 }
80
81 /*
82  * Just try PT_NOTE header otherwise fails
83  */
84 int filename__read_build_id(const char *filename, void *bf, size_t size)
85 {
86         FILE *fp;
87         int ret = -1;
88         bool need_swap = false;
89         u8 e_ident[EI_NIDENT];
90         size_t buf_size;
91         void *buf;
92         int i;
93
94         fp = fopen(filename, "r");
95         if (fp == NULL)
96                 return -1;
97
98         if (fread(e_ident, sizeof(e_ident), 1, fp) != 1)
99                 goto out;
100
101         if (memcmp(e_ident, ELFMAG, SELFMAG) ||
102             e_ident[EI_VERSION] != EV_CURRENT)
103                 goto out;
104
105         need_swap = check_need_swap(e_ident[EI_DATA]);
106
107         /* for simplicity */
108         fseek(fp, 0, SEEK_SET);
109
110         if (e_ident[EI_CLASS] == ELFCLASS32) {
111                 Elf32_Ehdr ehdr;
112                 Elf32_Phdr *phdr;
113
114                 if (fread(&ehdr, sizeof(ehdr), 1, fp) != 1)
115                         goto out;
116
117                 if (need_swap) {
118                         ehdr.e_phoff = bswap_32(ehdr.e_phoff);
119                         ehdr.e_phentsize = bswap_16(ehdr.e_phentsize);
120                         ehdr.e_phnum = bswap_16(ehdr.e_phnum);
121                 }
122
123                 buf_size = ehdr.e_phentsize * ehdr.e_phnum;
124                 buf = malloc(buf_size);
125                 if (buf == NULL)
126                         goto out;
127
128                 fseek(fp, ehdr.e_phoff, SEEK_SET);
129                 if (fread(buf, buf_size, 1, fp) != 1)
130                         goto out_free;
131
132                 for (i = 0, phdr = buf; i < ehdr.e_phnum; i++, phdr++) {
133                         void *tmp;
134                         long offset;
135
136                         if (need_swap) {
137                                 phdr->p_type = bswap_32(phdr->p_type);
138                                 phdr->p_offset = bswap_32(phdr->p_offset);
139                                 phdr->p_filesz = bswap_32(phdr->p_filesz);
140                         }
141
142                         if (phdr->p_type != PT_NOTE)
143                                 continue;
144
145                         buf_size = phdr->p_filesz;
146                         offset = phdr->p_offset;
147                         tmp = realloc(buf, buf_size);
148                         if (tmp == NULL)
149                                 goto out_free;
150
151                         buf = tmp;
152                         fseek(fp, offset, SEEK_SET);
153                         if (fread(buf, buf_size, 1, fp) != 1)
154                                 goto out_free;
155
156                         ret = read_build_id(buf, buf_size, bf, size, need_swap);
157                         if (ret == 0)
158                                 ret = size;
159                         break;
160                 }
161         } else {
162                 Elf64_Ehdr ehdr;
163                 Elf64_Phdr *phdr;
164
165                 if (fread(&ehdr, sizeof(ehdr), 1, fp) != 1)
166                         goto out;
167
168                 if (need_swap) {
169                         ehdr.e_phoff = bswap_64(ehdr.e_phoff);
170                         ehdr.e_phentsize = bswap_16(ehdr.e_phentsize);
171                         ehdr.e_phnum = bswap_16(ehdr.e_phnum);
172                 }
173
174                 buf_size = ehdr.e_phentsize * ehdr.e_phnum;
175                 buf = malloc(buf_size);
176                 if (buf == NULL)
177                         goto out;
178
179                 fseek(fp, ehdr.e_phoff, SEEK_SET);
180                 if (fread(buf, buf_size, 1, fp) != 1)
181                         goto out_free;
182
183                 for (i = 0, phdr = buf; i < ehdr.e_phnum; i++, phdr++) {
184                         void *tmp;
185                         long offset;
186
187                         if (need_swap) {
188                                 phdr->p_type = bswap_32(phdr->p_type);
189                                 phdr->p_offset = bswap_64(phdr->p_offset);
190                                 phdr->p_filesz = bswap_64(phdr->p_filesz);
191                         }
192
193                         if (phdr->p_type != PT_NOTE)
194                                 continue;
195
196                         buf_size = phdr->p_filesz;
197                         offset = phdr->p_offset;
198                         tmp = realloc(buf, buf_size);
199                         if (tmp == NULL)
200                                 goto out_free;
201
202                         buf = tmp;
203                         fseek(fp, offset, SEEK_SET);
204                         if (fread(buf, buf_size, 1, fp) != 1)
205                                 goto out_free;
206
207                         ret = read_build_id(buf, buf_size, bf, size, need_swap);
208                         if (ret == 0)
209                                 ret = size;
210                         break;
211                 }
212         }
213 out_free:
214         free(buf);
215 out:
216         fclose(fp);
217         return ret;
218 }
219
220 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
221 {
222         int fd;
223         int ret = -1;
224         struct stat stbuf;
225         size_t buf_size;
226         void *buf;
227
228         fd = open(filename, O_RDONLY);
229         if (fd < 0)
230                 return -1;
231
232         if (fstat(fd, &stbuf) < 0)
233                 goto out;
234
235         buf_size = stbuf.st_size;
236         buf = malloc(buf_size);
237         if (buf == NULL)
238                 goto out;
239
240         if (read(fd, buf, buf_size) != (ssize_t) buf_size)
241                 goto out_free;
242
243         ret = read_build_id(buf, buf_size, build_id, size, false);
244 out_free:
245         free(buf);
246 out:
247         close(fd);
248         return ret;
249 }
250
251 int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
252                  enum dso_binary_type type)
253 {
254         int fd = open(name, O_RDONLY);
255         if (fd < 0)
256                 goto out_errno;
257
258         ss->name = strdup(name);
259         if (!ss->name)
260                 goto out_close;
261
262         ss->fd = fd;
263         ss->type = type;
264
265         return 0;
266 out_close:
267         close(fd);
268 out_errno:
269         dso->load_errno = errno;
270         return -1;
271 }
272
273 bool symsrc__possibly_runtime(struct symsrc *ss __maybe_unused)
274 {
275         /* Assume all sym sources could be a runtime image. */
276         return true;
277 }
278
279 bool symsrc__has_symtab(struct symsrc *ss __maybe_unused)
280 {
281         return false;
282 }
283
284 void symsrc__destroy(struct symsrc *ss)
285 {
286         zfree(&ss->name);
287         close(ss->fd);
288 }
289
290 int dso__synthesize_plt_symbols(struct dso *dso __maybe_unused,
291                                 struct symsrc *ss __maybe_unused)
292 {
293         return 0;
294 }
295
296 static int fd__is_64_bit(int fd)
297 {
298         u8 e_ident[EI_NIDENT];
299
300         if (lseek(fd, 0, SEEK_SET))
301                 return -1;
302
303         if (readn(fd, e_ident, sizeof(e_ident)) != sizeof(e_ident))
304                 return -1;
305
306         if (memcmp(e_ident, ELFMAG, SELFMAG) ||
307             e_ident[EI_VERSION] != EV_CURRENT)
308                 return -1;
309
310         return e_ident[EI_CLASS] == ELFCLASS64;
311 }
312
313 enum dso_type dso__type_fd(int fd)
314 {
315         Elf64_Ehdr ehdr;
316         int ret;
317
318         ret = fd__is_64_bit(fd);
319         if (ret < 0)
320                 return DSO__TYPE_UNKNOWN;
321
322         if (ret)
323                 return DSO__TYPE_64BIT;
324
325         if (readn(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr))
326                 return DSO__TYPE_UNKNOWN;
327
328         if (ehdr.e_machine == EM_X86_64)
329                 return DSO__TYPE_X32BIT;
330
331         return DSO__TYPE_32BIT;
332 }
333
334 int dso__load_sym(struct dso *dso, struct map *map __maybe_unused,
335                   struct symsrc *ss,
336                   struct symsrc *runtime_ss __maybe_unused,
337                   int kmodule __maybe_unused)
338 {
339         unsigned char build_id[BUILD_ID_SIZE];
340         int ret;
341
342         ret = fd__is_64_bit(ss->fd);
343         if (ret >= 0)
344                 dso->is_64_bit = ret;
345
346         if (filename__read_build_id(ss->name, build_id, BUILD_ID_SIZE) > 0) {
347                 dso__set_build_id(dso, build_id);
348         }
349         return 0;
350 }
351
352 int file__read_maps(int fd __maybe_unused, bool exe __maybe_unused,
353                     mapfn_t mapfn __maybe_unused, void *data __maybe_unused,
354                     bool *is_64_bit __maybe_unused)
355 {
356         return -1;
357 }
358
359 int kcore_extract__create(struct kcore_extract *kce __maybe_unused)
360 {
361         return -1;
362 }
363
364 void kcore_extract__delete(struct kcore_extract *kce __maybe_unused)
365 {
366 }
367
368 int kcore_copy(const char *from_dir __maybe_unused,
369                const char *to_dir __maybe_unused)
370 {
371         return -1;
372 }
373
374 void symbol__elf_init(void)
375 {
376 }
377
378 char *dso__demangle_sym(struct dso *dso __maybe_unused,
379                         int kmodule __maybe_unused,
380                         const char *elf_name __maybe_unused)
381 {
382         return NULL;
383 }