~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/objtool/elf.c

Version: ~ [ linux-4.15-rc3 ] ~ [ linux-4.14.5 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.68 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.105 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.47 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.87 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.51 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.96 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * elf.c - ELF access library
  3  *
  4  * Adapted from kpatch (https://github.com/dynup/kpatch):
  5  * Copyright (C) 2013-2015 Josh Poimboeuf <jpoimboe@redhat.com>
  6  * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
  7  *
  8  * This program is free software; you can redistribute it and/or
  9  * modify it under the terms of the GNU General Public License
 10  * as published by the Free Software Foundation; either version 2
 11  * of the License, or (at your option) any later version.
 12  *
 13  * This program is distributed in the hope that it will be useful,
 14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16  * GNU General Public License for more details.
 17  *
 18  * You should have received a copy of the GNU General Public License
 19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
 20  */
 21 
 22 #include <sys/types.h>
 23 #include <sys/stat.h>
 24 #include <fcntl.h>
 25 #include <stdio.h>
 26 #include <stdlib.h>
 27 #include <string.h>
 28 #include <unistd.h>
 29 
 30 #include "elf.h"
 31 #include "warn.h"
 32 
 33 struct section *find_section_by_name(struct elf *elf, const char *name)
 34 {
 35         struct section *sec;
 36 
 37         list_for_each_entry(sec, &elf->sections, list)
 38                 if (!strcmp(sec->name, name))
 39                         return sec;
 40 
 41         return NULL;
 42 }
 43 
 44 static struct section *find_section_by_index(struct elf *elf,
 45                                              unsigned int idx)
 46 {
 47         struct section *sec;
 48 
 49         list_for_each_entry(sec, &elf->sections, list)
 50                 if (sec->idx == idx)
 51                         return sec;
 52 
 53         return NULL;
 54 }
 55 
 56 static struct symbol *find_symbol_by_index(struct elf *elf, unsigned int idx)
 57 {
 58         struct section *sec;
 59         struct symbol *sym;
 60 
 61         list_for_each_entry(sec, &elf->sections, list)
 62                 hash_for_each_possible(sec->symbol_hash, sym, hash, idx)
 63                         if (sym->idx == idx)
 64                                 return sym;
 65 
 66         return NULL;
 67 }
 68 
 69 struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset)
 70 {
 71         struct symbol *sym;
 72 
 73         list_for_each_entry(sym, &sec->symbol_list, list)
 74                 if (sym->type != STT_SECTION &&
 75                     sym->offset == offset)
 76                         return sym;
 77 
 78         return NULL;
 79 }
 80 
 81 struct symbol *find_symbol_containing(struct section *sec, unsigned long offset)
 82 {
 83         struct symbol *sym;
 84 
 85         list_for_each_entry(sym, &sec->symbol_list, list)
 86                 if (sym->type != STT_SECTION &&
 87                     offset >= sym->offset && offset < sym->offset + sym->len)
 88                         return sym;
 89 
 90         return NULL;
 91 }
 92 
 93 struct rela *find_rela_by_dest_range(struct section *sec, unsigned long offset,
 94                                      unsigned int len)
 95 {
 96         struct rela *rela;
 97         unsigned long o;
 98 
 99         if (!sec->rela)
100                 return NULL;
101 
102         for (o = offset; o < offset + len; o++)
103                 hash_for_each_possible(sec->rela->rela_hash, rela, hash, o)
104                         if (rela->offset == o)
105                                 return rela;
106 
107         return NULL;
108 }
109 
110 struct rela *find_rela_by_dest(struct section *sec, unsigned long offset)
111 {
112         return find_rela_by_dest_range(sec, offset, 1);
113 }
114 
115 struct symbol *find_containing_func(struct section *sec, unsigned long offset)
116 {
117         struct symbol *func;
118 
119         list_for_each_entry(func, &sec->symbol_list, list)
120                 if (func->type == STT_FUNC && offset >= func->offset &&
121                     offset < func->offset + func->len)
122                         return func;
123 
124         return NULL;
125 }
126 
127 static int read_sections(struct elf *elf)
128 {
129         Elf_Scn *s = NULL;
130         struct section *sec;
131         size_t shstrndx, sections_nr;
132         int i;
133 
134         if (elf_getshdrnum(elf->elf, &sections_nr)) {
135                 WARN_ELF("elf_getshdrnum");
136                 return -1;
137         }
138 
139         if (elf_getshdrstrndx(elf->elf, &shstrndx)) {
140                 WARN_ELF("elf_getshdrstrndx");
141                 return -1;
142         }
143 
144         for (i = 0; i < sections_nr; i++) {
145                 sec = malloc(sizeof(*sec));
146                 if (!sec) {
147                         perror("malloc");
148                         return -1;
149                 }
150                 memset(sec, 0, sizeof(*sec));
151 
152                 INIT_LIST_HEAD(&sec->symbol_list);
153                 INIT_LIST_HEAD(&sec->rela_list);
154                 hash_init(sec->rela_hash);
155                 hash_init(sec->symbol_hash);
156 
157                 list_add_tail(&sec->list, &elf->sections);
158 
159                 s = elf_getscn(elf->elf, i);
160                 if (!s) {
161                         WARN_ELF("elf_getscn");
162                         return -1;
163                 }
164 
165                 sec->idx = elf_ndxscn(s);
166 
167                 if (!gelf_getshdr(s, &sec->sh)) {
168                         WARN_ELF("gelf_getshdr");
169                         return -1;
170                 }
171 
172                 sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name);
173                 if (!sec->name) {
174                         WARN_ELF("elf_strptr");
175                         return -1;
176                 }
177 
178                 if (sec->sh.sh_size != 0) {
179                         sec->data = elf_getdata(s, NULL);
180                         if (!sec->data) {
181                                 WARN_ELF("elf_getdata");
182                                 return -1;
183                         }
184                         if (sec->data->d_off != 0 ||
185                             sec->data->d_size != sec->sh.sh_size) {
186                                 WARN("unexpected data attributes for %s",
187                                      sec->name);
188                                 return -1;
189                         }
190                 }
191                 sec->len = sec->sh.sh_size;
192         }
193 
194         /* sanity check, one more call to elf_nextscn() should return NULL */
195         if (elf_nextscn(elf->elf, s)) {
196                 WARN("section entry mismatch");
197                 return -1;
198         }
199 
200         return 0;
201 }
202 
203 static int read_symbols(struct elf *elf)
204 {
205         struct section *symtab;
206         struct symbol *sym;
207         struct list_head *entry, *tmp;
208         int symbols_nr, i;
209 
210         symtab = find_section_by_name(elf, ".symtab");
211         if (!symtab) {
212                 WARN("missing symbol table");
213                 return -1;
214         }
215 
216         symbols_nr = symtab->sh.sh_size / symtab->sh.sh_entsize;
217 
218         for (i = 0; i < symbols_nr; i++) {
219                 sym = malloc(sizeof(*sym));
220                 if (!sym) {
221                         perror("malloc");
222                         return -1;
223                 }
224                 memset(sym, 0, sizeof(*sym));
225 
226                 sym->idx = i;
227 
228                 if (!gelf_getsym(symtab->data, i, &sym->sym)) {
229                         WARN_ELF("gelf_getsym");
230                         goto err;
231                 }
232 
233                 sym->name = elf_strptr(elf->elf, symtab->sh.sh_link,
234                                        sym->sym.st_name);
235                 if (!sym->name) {
236                         WARN_ELF("elf_strptr");
237                         goto err;
238                 }
239 
240                 sym->type = GELF_ST_TYPE(sym->sym.st_info);
241                 sym->bind = GELF_ST_BIND(sym->sym.st_info);
242 
243                 if (sym->sym.st_shndx > SHN_UNDEF &&
244                     sym->sym.st_shndx < SHN_LORESERVE) {
245                         sym->sec = find_section_by_index(elf,
246                                                          sym->sym.st_shndx);
247                         if (!sym->sec) {
248                                 WARN("couldn't find section for symbol %s",
249                                      sym->name);
250                                 goto err;
251                         }
252                         if (sym->type == STT_SECTION) {
253                                 sym->name = sym->sec->name;
254                                 sym->sec->sym = sym;
255                         }
256                 } else
257                         sym->sec = find_section_by_index(elf, 0);
258 
259                 sym->offset = sym->sym.st_value;
260                 sym->len = sym->sym.st_size;
261 
262                 /* sorted insert into a per-section list */
263                 entry = &sym->sec->symbol_list;
264                 list_for_each_prev(tmp, &sym->sec->symbol_list) {
265                         struct symbol *s;
266 
267                         s = list_entry(tmp, struct symbol, list);
268 
269                         if (sym->offset > s->offset) {
270                                 entry = tmp;
271                                 break;
272                         }
273 
274                         if (sym->offset == s->offset && sym->len >= s->len) {
275                                 entry = tmp;
276                                 break;
277                         }
278                 }
279                 list_add(&sym->list, entry);
280                 hash_add(sym->sec->symbol_hash, &sym->hash, sym->idx);
281         }
282 
283         return 0;
284 
285 err:
286         free(sym);
287         return -1;
288 }
289 
290 static int read_relas(struct elf *elf)
291 {
292         struct section *sec;
293         struct rela *rela;
294         int i;
295         unsigned int symndx;
296 
297         list_for_each_entry(sec, &elf->sections, list) {
298                 if (sec->sh.sh_type != SHT_RELA)
299                         continue;
300 
301                 sec->base = find_section_by_name(elf, sec->name + 5);
302                 if (!sec->base) {
303                         WARN("can't find base section for rela section %s",
304                              sec->name);
305                         return -1;
306                 }
307 
308                 sec->base->rela = sec;
309 
310                 for (i = 0; i < sec->sh.sh_size / sec->sh.sh_entsize; i++) {
311                         rela = malloc(sizeof(*rela));
312                         if (!rela) {
313                                 perror("malloc");
314                                 return -1;
315                         }
316                         memset(rela, 0, sizeof(*rela));
317 
318                         if (!gelf_getrela(sec->data, i, &rela->rela)) {
319                                 WARN_ELF("gelf_getrela");
320                                 return -1;
321                         }
322 
323                         rela->type = GELF_R_TYPE(rela->rela.r_info);
324                         rela->addend = rela->rela.r_addend;
325                         rela->offset = rela->rela.r_offset;
326                         symndx = GELF_R_SYM(rela->rela.r_info);
327                         rela->sym = find_symbol_by_index(elf, symndx);
328                         if (!rela->sym) {
329                                 WARN("can't find rela entry symbol %d for %s",
330                                      symndx, sec->name);
331                                 return -1;
332                         }
333 
334                         list_add_tail(&rela->list, &sec->rela_list);
335                         hash_add(sec->rela_hash, &rela->hash, rela->offset);
336 
337                 }
338         }
339 
340         return 0;
341 }
342 
343 struct elf *elf_open(const char *name, int flags)
344 {
345         struct elf *elf;
346         Elf_Cmd cmd;
347 
348         elf_version(EV_CURRENT);
349 
350         elf = malloc(sizeof(*elf));
351         if (!elf) {
352                 perror("malloc");
353                 return NULL;
354         }
355         memset(elf, 0, sizeof(*elf));
356 
357         INIT_LIST_HEAD(&elf->sections);
358 
359         elf->fd = open(name, flags);
360         if (elf->fd == -1) {
361                 perror("open");
362                 goto err;
363         }
364 
365         if ((flags & O_ACCMODE) == O_RDONLY)
366                 cmd = ELF_C_READ_MMAP;
367         else if ((flags & O_ACCMODE) == O_RDWR)
368                 cmd = ELF_C_RDWR;
369         else /* O_WRONLY */
370                 cmd = ELF_C_WRITE;
371 
372         elf->elf = elf_begin(elf->fd, cmd, NULL);
373         if (!elf->elf) {
374                 WARN_ELF("elf_begin");
375                 goto err;
376         }
377 
378         if (!gelf_getehdr(elf->elf, &elf->ehdr)) {
379                 WARN_ELF("gelf_getehdr");
380                 goto err;
381         }
382 
383         if (read_sections(elf))
384                 goto err;
385 
386         if (read_symbols(elf))
387                 goto err;
388 
389         if (read_relas(elf))
390                 goto err;
391 
392         return elf;
393 
394 err:
395         elf_close(elf);
396         return NULL;
397 }
398 
399 struct section *elf_create_section(struct elf *elf, const char *name,
400                                    size_t entsize, int nr)
401 {
402         struct section *sec, *shstrtab;
403         size_t size = entsize * nr;
404         struct Elf_Scn *s;
405         Elf_Data *data;
406 
407         sec = malloc(sizeof(*sec));
408         if (!sec) {
409                 perror("malloc");
410                 return NULL;
411         }
412         memset(sec, 0, sizeof(*sec));
413 
414         INIT_LIST_HEAD(&sec->symbol_list);
415         INIT_LIST_HEAD(&sec->rela_list);
416         hash_init(sec->rela_hash);
417         hash_init(sec->symbol_hash);
418 
419         list_add_tail(&sec->list, &elf->sections);
420 
421         s = elf_newscn(elf->elf);
422         if (!s) {
423                 WARN_ELF("elf_newscn");
424                 return NULL;
425         }
426 
427         sec->name = strdup(name);
428         if (!sec->name) {
429                 perror("strdup");
430                 return NULL;
431         }
432 
433         sec->idx = elf_ndxscn(s);
434         sec->len = size;
435         sec->changed = true;
436 
437         sec->data = elf_newdata(s);
438         if (!sec->data) {
439                 WARN_ELF("elf_newdata");
440                 return NULL;
441         }
442 
443         sec->data->d_size = size;
444         sec->data->d_align = 1;
445 
446         if (size) {
447                 sec->data->d_buf = malloc(size);
448                 if (!sec->data->d_buf) {
449                         perror("malloc");
450                         return NULL;
451                 }
452                 memset(sec->data->d_buf, 0, size);
453         }
454 
455         if (!gelf_getshdr(s, &sec->sh)) {
456                 WARN_ELF("gelf_getshdr");
457                 return NULL;
458         }
459 
460         sec->sh.sh_size = size;
461         sec->sh.sh_entsize = entsize;
462         sec->sh.sh_type = SHT_PROGBITS;
463         sec->sh.sh_addralign = 1;
464         sec->sh.sh_flags = SHF_ALLOC;
465 
466 
467         /* Add section name to .shstrtab */
468         shstrtab = find_section_by_name(elf, ".shstrtab");
469         if (!shstrtab) {
470                 WARN("can't find .shstrtab section");
471                 return NULL;
472         }
473 
474         s = elf_getscn(elf->elf, shstrtab->idx);
475         if (!s) {
476                 WARN_ELF("elf_getscn");
477                 return NULL;
478         }
479 
480         data = elf_newdata(s);
481         if (!data) {
482                 WARN_ELF("elf_newdata");
483                 return NULL;
484         }
485 
486         data->d_buf = sec->name;
487         data->d_size = strlen(name) + 1;
488         data->d_align = 1;
489 
490         sec->sh.sh_name = shstrtab->len;
491 
492         shstrtab->len += strlen(name) + 1;
493         shstrtab->changed = true;
494 
495         return sec;
496 }
497 
498 struct section *elf_create_rela_section(struct elf *elf, struct section *base)
499 {
500         char *relaname;
501         struct section *sec;
502 
503         relaname = malloc(strlen(base->name) + strlen(".rela") + 1);
504         if (!relaname) {
505                 perror("malloc");
506                 return NULL;
507         }
508         strcpy(relaname, ".rela");
509         strcat(relaname, base->name);
510 
511         sec = elf_create_section(elf, relaname, sizeof(GElf_Rela), 0);
512         free(relaname);
513         if (!sec)
514                 return NULL;
515 
516         base->rela = sec;
517         sec->base = base;
518 
519         sec->sh.sh_type = SHT_RELA;
520         sec->sh.sh_addralign = 8;
521         sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx;
522         sec->sh.sh_info = base->idx;
523         sec->sh.sh_flags = SHF_INFO_LINK;
524 
525         return sec;
526 }
527 
528 int elf_rebuild_rela_section(struct section *sec)
529 {
530         struct rela *rela;
531         int nr, idx = 0, size;
532         GElf_Rela *relas;
533 
534         nr = 0;
535         list_for_each_entry(rela, &sec->rela_list, list)
536                 nr++;
537 
538         size = nr * sizeof(*relas);
539         relas = malloc(size);
540         if (!relas) {
541                 perror("malloc");
542                 return -1;
543         }
544 
545         sec->data->d_buf = relas;
546         sec->data->d_size = size;
547 
548         sec->sh.sh_size = size;
549 
550         idx = 0;
551         list_for_each_entry(rela, &sec->rela_list, list) {
552                 relas[idx].r_offset = rela->offset;
553                 relas[idx].r_addend = rela->addend;
554                 relas[idx].r_info = GELF_R_INFO(rela->sym->idx, rela->type);
555                 idx++;
556         }
557 
558         return 0;
559 }
560 
561 int elf_write(struct elf *elf)
562 {
563         struct section *sec;
564         Elf_Scn *s;
565 
566         /* Update section headers for changed sections: */
567         list_for_each_entry(sec, &elf->sections, list) {
568                 if (sec->changed) {
569                         s = elf_getscn(elf->elf, sec->idx);
570                         if (!s) {
571                                 WARN_ELF("elf_getscn");
572                                 return -1;
573                         }
574                         if (!gelf_update_shdr(s, &sec->sh)) {
575                                 WARN_ELF("gelf_update_shdr");
576                                 return -1;
577                         }
578                 }
579         }
580 
581         /* Make sure the new section header entries get updated properly. */
582         elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY);
583 
584         /* Write all changes to the file. */
585         if (elf_update(elf->elf, ELF_C_WRITE) < 0) {
586                 WARN_ELF("elf_update");
587                 return -1;
588         }
589 
590         return 0;
591 }
592 
593 void elf_close(struct elf *elf)
594 {
595         struct section *sec, *tmpsec;
596         struct symbol *sym, *tmpsym;
597         struct rela *rela, *tmprela;
598 
599         if (elf->elf)
600                 elf_end(elf->elf);
601 
602         if (elf->fd > 0)
603                 close(elf->fd);
604 
605         list_for_each_entry_safe(sec, tmpsec, &elf->sections, list) {
606                 list_for_each_entry_safe(sym, tmpsym, &sec->symbol_list, list) {
607                         list_del(&sym->list);
608                         hash_del(&sym->hash);
609                         free(sym);
610                 }
611                 list_for_each_entry_safe(rela, tmprela, &sec->rela_list, list) {
612                         list_del(&rela->list);
613                         hash_del(&rela->hash);
614                         free(rela);
615                 }
616                 list_del(&sec->list);
617                 free(sec);
618         }
619 
620         free(elf);
621 }
622 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp