Commit | Line | Data |
---|---|---|
32d0add0 | 1 | /* Copyright 2013-2015 Free Software Foundation, Inc. |
681f229a NB |
2 | This program is free software; you can redistribute it and/or modify |
3 | it under the terms of the GNU General Public License as published by | |
4 | the Free Software Foundation; either version 3 of the License, or | |
5 | (at your option) any later version. | |
6 | ||
7 | This program is distributed in the hope that it will be useful, | |
8 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
9 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
10 | GNU General Public License for more details. | |
11 | ||
12 | You should have received a copy of the GNU General Public License | |
13 | along with this program. If not, see <http://www.gnu.org/licenses/>. | |
14 | */ | |
15 | ||
16 | #include <unistd.h> | |
17 | #include <fcntl.h> | |
2d1baf52 | 18 | #include <limits.h> |
681f229a NB |
19 | #include <stdio.h> |
20 | #include <stdlib.h> | |
21 | #include <string.h> | |
22 | #include <sys/mman.h> | |
23 | ||
24 | #include "sym-file-loader.h" | |
25 | ||
35e5d2f0 PA |
26 | #include <inttypes.h> |
27 | #include <ansidecl.h> | |
28 | #include <elf/common.h> | |
29 | #include <elf/external.h> | |
30 | ||
31 | #ifdef TARGET_LP64 | |
32 | ||
33 | typedef Elf64_External_Phdr Elf_External_Phdr; | |
34 | typedef Elf64_External_Ehdr Elf_External_Ehdr; | |
35 | typedef Elf64_External_Shdr Elf_External_Shdr; | |
36 | typedef Elf64_External_Sym Elf_External_Sym; | |
37 | typedef uint64_t Elf_Addr; | |
38 | ||
39 | #elif defined TARGET_ILP32 | |
40 | ||
41 | typedef Elf32_External_Phdr Elf_External_Phdr; | |
42 | typedef Elf32_External_Ehdr Elf_External_Ehdr; | |
43 | typedef Elf32_External_Shdr Elf_External_Shdr; | |
44 | typedef Elf32_External_Sym Elf_External_Sym; | |
45 | typedef uint32_t Elf_Addr; | |
46 | ||
47 | #endif | |
48 | ||
49 | #define GET(hdr, field) (\ | |
50 | sizeof ((hdr)->field) == 1 ? (uint64_t) (hdr)->field[0] : \ | |
51 | sizeof ((hdr)->field) == 2 ? (uint64_t) *(uint16_t *) (hdr)->field : \ | |
52 | sizeof ((hdr)->field) == 4 ? (uint64_t) *(uint32_t *) (hdr)->field : \ | |
53 | sizeof ((hdr)->field) == 8 ? *(uint64_t *) (hdr)->field : \ | |
54 | *(uint64_t *) NULL) | |
55 | ||
56 | #define GETADDR(hdr, field) (\ | |
57 | sizeof ((hdr)->field) == sizeof (Elf_Addr) ? *(Elf_Addr *) (hdr)->field : \ | |
58 | *(Elf_Addr *) NULL) | |
59 | ||
60 | struct segment | |
61 | { | |
62 | uint8_t *mapped_addr; | |
08351840 | 63 | size_t mapped_size; |
35e5d2f0 PA |
64 | Elf_External_Phdr *phdr; |
65 | struct segment *next; | |
66 | }; | |
67 | ||
68 | struct library | |
69 | { | |
70 | int fd; | |
71 | Elf_External_Ehdr *ehdr; | |
72 | struct segment *segments; | |
73 | }; | |
74 | ||
75 | static Elf_External_Shdr *find_shdr (Elf_External_Ehdr *ehdr, | |
76 | const char *section); | |
77 | static int translate_offset (uint64_t file_offset, struct segment *seg, | |
78 | void **addr); | |
79 | ||
681f229a NB |
80 | #ifdef TARGET_LP64 |
81 | ||
82 | uint8_t | |
83 | elf_st_type (uint8_t st_info) | |
84 | { | |
85 | return ELF64_ST_TYPE (st_info); | |
86 | } | |
87 | ||
88 | #elif defined TARGET_ILP32 | |
89 | ||
90 | uint8_t | |
91 | elf_st_type (uint8_t st_info) | |
92 | { | |
93 | return ELF32_ST_TYPE (st_info); | |
94 | } | |
95 | ||
96 | #endif | |
97 | ||
98 | /* Load a program segment. */ | |
99 | ||
100 | static struct segment * | |
101 | load (uint8_t *addr, Elf_External_Phdr *phdr, struct segment *tail_seg) | |
102 | { | |
103 | struct segment *seg = NULL; | |
104 | uint8_t *mapped_addr = NULL; | |
08351840 | 105 | size_t mapped_size = 0; |
681f229a NB |
106 | void *from = NULL; |
107 | void *to = NULL; | |
108 | ||
109 | /* For the sake of simplicity all operations are permitted. */ | |
110 | unsigned perm = PROT_READ | PROT_WRITE | PROT_EXEC; | |
111 | ||
112 | mapped_addr = (uint8_t *) mmap ((void *) GETADDR (phdr, p_vaddr), | |
113 | GET (phdr, p_memsz), perm, | |
114 | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); | |
08351840 | 115 | mapped_size = GET (phdr, p_memsz); |
681f229a NB |
116 | |
117 | from = (void *) (addr + GET (phdr, p_offset)); | |
118 | to = (void *) mapped_addr; | |
119 | ||
120 | memcpy (to, from, GET (phdr, p_filesz)); | |
121 | ||
122 | seg = (struct segment *) malloc (sizeof (struct segment)); | |
123 | ||
124 | if (seg == 0) | |
125 | return 0; | |
126 | ||
127 | seg->mapped_addr = mapped_addr; | |
08351840 | 128 | seg->mapped_size = mapped_size; |
681f229a NB |
129 | seg->phdr = phdr; |
130 | seg->next = 0; | |
131 | ||
132 | if (tail_seg != 0) | |
133 | tail_seg->next = seg; | |
134 | ||
135 | return seg; | |
136 | } | |
137 | ||
2d1baf52 PA |
138 | #ifdef __linux__ |
139 | # define SELF_LINK "/proc/self/exe" | |
140 | #elif defined NETBSD | |
eb4c1710 | 141 | # define SELF_LINK "/proc/curproc/exe" |
2d1baf52 | 142 | #elif defined __OpenBSD__ || defined __FreeBSD__ || defined __DragonFly__ |
eb4c1710 | 143 | # define SELF_LINK "/proc/curproc/file" |
2d1baf52 | 144 | #elif defined SunOS |
eb4c1710 | 145 | # define SELF_LINK "/proc/self/path/a.out" |
2d1baf52 PA |
146 | #endif |
147 | ||
148 | /* Like RPATH=$ORIGIN, return the dirname of the current | |
149 | executable. */ | |
150 | ||
151 | static const char * | |
152 | get_origin (void) | |
153 | { | |
154 | static char self_path[PATH_MAX]; | |
155 | static ssize_t self_path_len; | |
156 | ||
157 | if (self_path_len == 0) | |
158 | { | |
159 | #ifdef SELF_LINK | |
160 | self_path_len = readlink (SELF_LINK, self_path, PATH_MAX - 1); | |
161 | if (self_path_len != -1) | |
162 | { | |
163 | char *dirsep; | |
164 | ||
165 | self_path[self_path_len] = '\0'; | |
166 | dirsep = strrchr (self_path, '/'); | |
167 | *dirsep = '\0'; | |
168 | } | |
169 | #else | |
170 | self_path_len = -1; | |
171 | #endif | |
172 | } | |
173 | ||
174 | if (self_path_len == -1) | |
175 | return NULL; | |
176 | else | |
177 | return self_path; | |
178 | } | |
179 | ||
08351840 PA |
180 | /* Unload/unmap a segment. */ |
181 | ||
182 | static void | |
183 | unload (struct segment *seg) | |
184 | { | |
185 | munmap (seg->mapped_addr, seg->mapped_size); | |
186 | free (seg); | |
187 | } | |
188 | ||
189 | void | |
190 | unload_shlib (struct library *lib) | |
191 | { | |
192 | struct segment *seg, *next_seg; | |
193 | ||
194 | for (seg = lib->segments; seg != NULL; seg = next_seg) | |
195 | { | |
196 | next_seg = seg->next; | |
197 | unload (seg); | |
198 | } | |
199 | ||
200 | close (lib->fd); | |
201 | free (lib); | |
202 | } | |
203 | ||
681f229a NB |
204 | /* Mini shared library loader. No reallocation |
205 | is performed for the sake of simplicity. */ | |
206 | ||
35e5d2f0 PA |
207 | struct library * |
208 | load_shlib (const char *file) | |
681f229a | 209 | { |
35e5d2f0 | 210 | struct library *lib; |
681f229a | 211 | uint64_t i; |
2d1baf52 | 212 | int fd = -1; |
681f229a NB |
213 | off_t fsize; |
214 | uint8_t *addr; | |
215 | Elf_External_Ehdr *ehdr; | |
216 | Elf_External_Phdr *phdr; | |
217 | struct segment *head_seg = NULL; | |
218 | struct segment *tail_seg = NULL; | |
2d1baf52 PA |
219 | const char *origin; |
220 | char *path; | |
221 | ||
222 | /* Map the lib in memory for reading. | |
223 | ||
224 | If the file name is relative, try looking it up relative to the | |
225 | main executable's path. I.e., emulate RPATH=$ORIGIN. */ | |
226 | if (file[0] != '/') | |
227 | { | |
228 | origin = get_origin (); | |
229 | if (origin == NULL) | |
230 | { | |
231 | fprintf (stderr, "get_origin not implemented."); | |
35e5d2f0 | 232 | return NULL; |
2d1baf52 PA |
233 | } |
234 | ||
235 | path = alloca (strlen (origin) + 1 + strlen (file) + 1); | |
236 | sprintf (path, "%s/%s", origin, file); | |
237 | fd = open (path, O_RDONLY); | |
238 | } | |
239 | ||
240 | if (fd < 0) | |
241 | fd = open (file, O_RDONLY); | |
681f229a | 242 | |
681f229a NB |
243 | if (fd < 0) |
244 | { | |
245 | perror ("fopen failed."); | |
35e5d2f0 | 246 | return NULL; |
681f229a NB |
247 | } |
248 | ||
249 | fsize = lseek (fd, 0, SEEK_END); | |
250 | ||
251 | if (fsize < 0) | |
252 | { | |
253 | perror ("lseek failed."); | |
35e5d2f0 | 254 | return NULL; |
681f229a NB |
255 | } |
256 | ||
257 | addr = (uint8_t *) mmap (NULL, fsize, PROT_READ, MAP_PRIVATE, fd, 0); | |
258 | if (addr == (uint8_t *) -1) | |
259 | { | |
260 | perror ("mmap failed."); | |
35e5d2f0 | 261 | return NULL; |
681f229a NB |
262 | } |
263 | ||
264 | /* Check if the lib is an ELF file. */ | |
265 | ehdr = (Elf_External_Ehdr *) addr; | |
266 | if (ehdr->e_ident[EI_MAG0] != ELFMAG0 | |
267 | || ehdr->e_ident[EI_MAG1] != ELFMAG1 | |
268 | || ehdr->e_ident[EI_MAG2] != ELFMAG2 | |
269 | || ehdr->e_ident[EI_MAG3] != ELFMAG3) | |
270 | { | |
271 | printf ("Not an ELF file: %x\n", ehdr->e_ident[EI_MAG0]); | |
35e5d2f0 | 272 | return NULL; |
681f229a NB |
273 | } |
274 | ||
275 | if (ehdr->e_ident[EI_CLASS] == ELFCLASS32) | |
276 | { | |
277 | if (sizeof (void *) != 4) | |
278 | { | |
279 | printf ("Architecture mismatch."); | |
35e5d2f0 | 280 | return NULL; |
681f229a NB |
281 | } |
282 | } | |
283 | else if (ehdr->e_ident[EI_CLASS] == ELFCLASS64) | |
284 | { | |
285 | if (sizeof (void *) != 8) | |
286 | { | |
287 | printf ("Architecture mismatch."); | |
35e5d2f0 | 288 | return NULL; |
681f229a NB |
289 | } |
290 | } | |
291 | ||
35e5d2f0 PA |
292 | lib = malloc (sizeof (struct library)); |
293 | if (lib == NULL) | |
294 | { | |
295 | printf ("malloc failed."); | |
296 | return NULL; | |
297 | } | |
298 | ||
299 | lib->fd = fd; | |
300 | ||
681f229a NB |
301 | /* Load the program segments. For the sake of simplicity |
302 | assume that no reallocation is needed. */ | |
303 | phdr = (Elf_External_Phdr *) (addr + GET (ehdr, e_phoff)); | |
304 | for (i = 0; i < GET (ehdr, e_phnum); i++, phdr++) | |
305 | { | |
306 | if (GET (phdr, p_type) == PT_LOAD) | |
307 | { | |
308 | struct segment *next_seg = load (addr, phdr, tail_seg); | |
309 | if (next_seg == 0) | |
310 | continue; | |
311 | tail_seg = next_seg; | |
312 | if (head_seg == 0) | |
313 | head_seg = next_seg; | |
314 | } | |
315 | } | |
35e5d2f0 PA |
316 | lib->ehdr = ehdr; |
317 | lib->segments = head_seg; | |
318 | return lib; | |
319 | } | |
320 | ||
321 | int | |
322 | get_text_addr (struct library *lib, void **text_addr) | |
323 | { | |
324 | Elf_External_Shdr *text; | |
325 | ||
326 | /* Get the text section. */ | |
327 | text = find_shdr (lib->ehdr, ".text"); | |
328 | if (text == NULL) | |
329 | return -1; | |
330 | ||
331 | if (translate_offset (GET (text, sh_offset), lib->segments, text_addr) | |
332 | != 0) | |
333 | return -1; | |
334 | ||
681f229a NB |
335 | return 0; |
336 | } | |
337 | ||
338 | /* Return the section-header table. */ | |
339 | ||
340 | Elf_External_Shdr * | |
341 | find_shdrtab (Elf_External_Ehdr *ehdr) | |
342 | { | |
343 | return (Elf_External_Shdr *) (((uint8_t *) ehdr) + GET (ehdr, e_shoff)); | |
344 | } | |
345 | ||
346 | /* Return the string table of the section headers. */ | |
347 | ||
348 | const char * | |
349 | find_shstrtab (Elf_External_Ehdr *ehdr, uint64_t *size) | |
350 | { | |
351 | const Elf_External_Shdr *shdr; | |
352 | const Elf_External_Shdr *shstr; | |
353 | ||
354 | if (GET (ehdr, e_shnum) <= GET (ehdr, e_shstrndx)) | |
355 | { | |
356 | printf ("The index of the string table is corrupt."); | |
357 | return NULL; | |
358 | } | |
359 | ||
360 | shdr = find_shdrtab (ehdr); | |
361 | ||
362 | shstr = &shdr[GET (ehdr, e_shstrndx)]; | |
363 | *size = GET (shstr, sh_size); | |
364 | return ((const char *) ehdr) + GET (shstr, sh_offset); | |
365 | } | |
366 | ||
367 | /* Return the string table named SECTION. */ | |
368 | ||
369 | const char * | |
370 | find_strtab (Elf_External_Ehdr *ehdr, | |
371 | const char *section, uint64_t *strtab_size) | |
372 | { | |
373 | uint64_t shstrtab_size = 0; | |
374 | const char *shstrtab; | |
375 | uint64_t i; | |
376 | const Elf_External_Shdr *shdr = find_shdrtab (ehdr); | |
377 | ||
378 | /* Get the string table of the section headers. */ | |
379 | shstrtab = find_shstrtab (ehdr, &shstrtab_size); | |
380 | if (shstrtab == NULL) | |
381 | return NULL; | |
382 | ||
383 | for (i = 0; i < GET (ehdr, e_shnum); i++) | |
384 | { | |
385 | uint64_t name = GET (shdr + i, sh_name); | |
386 | if (GET (shdr + i, sh_type) == SHT_STRTAB && name <= shstrtab_size | |
387 | && strcmp ((const char *) &shstrtab[name], section) == 0) | |
388 | { | |
389 | *strtab_size = GET (shdr + i, sh_size); | |
390 | return ((const char *) ehdr) + GET (shdr + i, sh_offset); | |
391 | } | |
392 | ||
393 | } | |
394 | return NULL; | |
395 | } | |
396 | ||
397 | /* Return the section header named SECTION. */ | |
398 | ||
35e5d2f0 | 399 | static Elf_External_Shdr * |
681f229a NB |
400 | find_shdr (Elf_External_Ehdr *ehdr, const char *section) |
401 | { | |
402 | uint64_t shstrtab_size = 0; | |
403 | const char *shstrtab; | |
404 | uint64_t i; | |
405 | ||
406 | /* Get the string table of the section headers. */ | |
407 | shstrtab = find_shstrtab (ehdr, &shstrtab_size); | |
408 | if (shstrtab == NULL) | |
409 | return NULL; | |
410 | ||
411 | Elf_External_Shdr *shdr = find_shdrtab (ehdr); | |
412 | for (i = 0; i < GET (ehdr, e_shnum); i++) | |
413 | { | |
414 | uint64_t name = GET (shdr + i, sh_name); | |
415 | if (name <= shstrtab_size) | |
416 | { | |
417 | if (strcmp ((const char *) &shstrtab[name], section) == 0) | |
418 | return &shdr[i]; | |
419 | } | |
420 | ||
421 | } | |
422 | return NULL; | |
423 | } | |
424 | ||
425 | /* Return the symbol table. */ | |
426 | ||
35e5d2f0 | 427 | static Elf_External_Sym * |
681f229a NB |
428 | find_symtab (Elf_External_Ehdr *ehdr, uint64_t *symtab_size) |
429 | { | |
430 | uint64_t i; | |
431 | const Elf_External_Shdr *shdr = find_shdrtab (ehdr); | |
432 | ||
433 | for (i = 0; i < GET (ehdr, e_shnum); i++) | |
434 | { | |
435 | if (GET (shdr + i, sh_type) == SHT_SYMTAB) | |
436 | { | |
437 | *symtab_size = GET (shdr + i, sh_size) / sizeof (Elf_External_Sym); | |
438 | return (Elf_External_Sym *) (((const char *) ehdr) + | |
439 | GET (shdr + i, sh_offset)); | |
440 | } | |
441 | } | |
442 | return NULL; | |
443 | } | |
444 | ||
445 | /* Translate a file offset to an address in a loaded segment. */ | |
446 | ||
35e5d2f0 | 447 | static int |
681f229a NB |
448 | translate_offset (uint64_t file_offset, struct segment *seg, void **addr) |
449 | { | |
450 | while (seg) | |
451 | { | |
452 | uint64_t p_from, p_to; | |
453 | ||
454 | Elf_External_Phdr *phdr = seg->phdr; | |
455 | ||
456 | if (phdr == NULL) | |
457 | { | |
458 | seg = seg->next; | |
459 | continue; | |
460 | } | |
461 | ||
462 | p_from = GET (phdr, p_offset); | |
463 | p_to = p_from + GET (phdr, p_filesz); | |
464 | ||
465 | if (p_from <= file_offset && file_offset < p_to) | |
466 | { | |
467 | *addr = (void *) (seg->mapped_addr + (file_offset - p_from)); | |
468 | return 0; | |
469 | } | |
470 | seg = seg->next; | |
471 | } | |
472 | ||
473 | return -1; | |
474 | } | |
475 | ||
476 | /* Lookup the address of FUNC. */ | |
477 | ||
478 | int | |
35e5d2f0 | 479 | lookup_function (struct library *lib, const char *func, void **addr) |
681f229a NB |
480 | { |
481 | const char *strtab; | |
482 | uint64_t strtab_size = 0; | |
483 | Elf_External_Sym *symtab; | |
484 | uint64_t symtab_size = 0; | |
485 | uint64_t i; | |
35e5d2f0 PA |
486 | Elf_External_Ehdr *ehdr = lib->ehdr; |
487 | struct segment *seg = lib->segments; | |
681f229a NB |
488 | |
489 | /* Get the string table for the symbols. */ | |
490 | strtab = find_strtab (ehdr, ".strtab", &strtab_size); | |
491 | if (strtab == NULL) | |
492 | { | |
493 | printf (".strtab not found."); | |
494 | return -1; | |
495 | } | |
496 | ||
497 | /* Get the symbol table. */ | |
498 | symtab = find_symtab (ehdr, &symtab_size); | |
499 | if (symtab == NULL) | |
500 | { | |
501 | printf ("symbol table not found."); | |
502 | return -1; | |
503 | } | |
504 | ||
505 | for (i = 0; i < symtab_size; i++) | |
506 | { | |
507 | Elf_External_Sym *sym = &symtab[i]; | |
508 | ||
509 | if (elf_st_type (GET (sym, st_info)) != STT_FUNC) | |
510 | continue; | |
511 | ||
512 | if (GET (sym, st_name) < strtab_size) | |
513 | { | |
514 | const char *name = &strtab[GET (sym, st_name)]; | |
515 | if (strcmp (name, func) == 0) | |
516 | { | |
517 | ||
518 | uint64_t offset = GET (sym, st_value); | |
519 | return translate_offset (offset, seg, addr); | |
520 | } | |
521 | } | |
522 | } | |
523 | ||
524 | return -1; | |
525 | } |