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

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

Version: ~ [ linux-4.20-rc5 ] ~ [ linux-4.19.6 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.85 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.142 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.166 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.128 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.61 ] ~ [ 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.102 ] ~ [ 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.31.14 ] ~ [ linux-2.6.30.10 ] ~ [ linux-2.6.29.6 ] ~ [ linux-2.6.28.10 ] ~ [ 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 #include <errno.h>
 30 
 31 #include "elf.h"
 32 #include "warn.h"
 33 
 34 #define MAX_NAME_LEN 128
 35 
 36 struct section *find_section_by_name(struct elf *elf, const char *name)
 37 {
 38         struct section *sec;
 39 
 40         list_for_each_entry(sec, &elf->sections, list)
 41                 if (!strcmp(sec->name, name))
 42                         return sec;
 43 
 44         return NULL;
 45 }
 46 
 47 static struct section *find_section_by_index(struct elf *elf,
 48                                              unsigned int idx)
 49 {
 50         struct section *sec;
 51 
 52         list_for_each_entry(sec, &elf->sections, list)
 53                 if (sec->idx == idx)
 54                         return sec;
 55 
 56         return NULL;
 57 }
 58 
 59 static struct symbol *find_symbol_by_index(struct elf *elf, unsigned int idx)
 60 {
 61         struct section *sec;
 62         struct symbol *sym;
 63 
 64         list_for_each_entry(sec, &elf->sections, list)
 65                 hash_for_each_possible(sec->symbol_hash, sym, hash, idx)
 66                         if (sym->idx == idx)
 67                                 return sym;
 68 
 69         return NULL;
 70 }
 71 
 72 struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset)
 73 {
 74         struct symbol *sym;
 75 
 76         list_for_each_entry(sym, &sec->symbol_list, list)
 77                 if (sym->type != STT_SECTION &&
 78                     sym->offset == offset)
 79                         return sym;
 80 
 81         return NULL;
 82 }
 83 
 84 struct symbol *find_symbol_by_name(struct elf *elf, const char *name)
 85 {
 86         struct section *sec;
 87         struct symbol *sym;
 88 
 89         list_for_each_entry(sec, &elf->sections, list)
 90                 list_for_each_entry(sym, &sec->symbol_list, list)
 91                         if (!strcmp(sym->name, name))
 92                                 return sym;
 93 
 94         return NULL;
 95 }
 96 
 97 struct symbol *find_symbol_containing(struct section *sec, unsigned long offset)
 98 {
 99         struct symbol *sym;
100 
101         list_for_each_entry(sym, &sec->symbol_list, list)
102                 if (sym->type != STT_SECTION &&
103                     offset >= sym->offset && offset < sym->offset + sym->len)
104                         return sym;
105 
106         return NULL;
107 }
108 
109 struct rela *find_rela_by_dest_range(struct section *sec, unsigned long offset,
110                                      unsigned int len)
111 {
112         struct rela *rela;
113         unsigned long o;
114 
115         if (!sec->rela)
116                 return NULL;
117 
118         for (o = offset; o < offset + len; o++)
119                 hash_for_each_possible(sec->rela->rela_hash, rela, hash, o)
120                         if (rela->offset == o)
121                                 return rela;
122 
123         return NULL;
124 }
125 
126 struct rela *find_rela_by_dest(struct section *sec, unsigned long offset)
127 {
128         return find_rela_by_dest_range(sec, offset, 1);
129 }
130 
131 struct symbol *find_containing_func(struct section *sec, unsigned long offset)
132 {
133         struct symbol *func;
134 
135         list_for_each_entry(func, &sec->symbol_list, list)
136                 if (func->type == STT_FUNC && offset >= func->offset &&
137                     offset < func->offset + func->len)
138                         return func;
139 
140         return NULL;
141 }
142 
143 static int read_sections(struct elf *elf)
144 {
145         Elf_Scn *s = NULL;
146         struct section *sec;
147         size_t shstrndx, sections_nr;
148         int i;
149 
150         if (elf_getshdrnum(elf->elf, &sections_nr)) {
151                 WARN_ELF("elf_getshdrnum");
152                 return -1;
153         }
154 
155         if (elf_getshdrstrndx(elf->elf, &shstrndx)) {
156                 WARN_ELF("elf_getshdrstrndx");
157                 return -1;
158         }
159 
160         for (i = 0; i < sections_nr; i++) {
161                 sec = malloc(sizeof(*sec));
162                 if (!sec) {
163                         perror("malloc");
164                         return -1;
165                 }
166                 memset(sec, 0, sizeof(*sec));
167 
168                 INIT_LIST_HEAD(&sec->symbol_list);
169                 INIT_LIST_HEAD(&sec->rela_list);
170                 hash_init(sec->rela_hash);
171                 hash_init(sec->symbol_hash);
172 
173                 list_add_tail(&sec->list, &elf->sections);
174 
175                 s = elf_getscn(elf->elf, i);
176                 if (!s) {
177                         WARN_ELF("elf_getscn");
178                         return -1;
179                 }
180 
181                 sec->idx = elf_ndxscn(s);
182 
183                 if (!gelf_getshdr(s, &sec->sh)) {
184                         WARN_ELF("gelf_getshdr");
185                         return -1;
186                 }
187 
188                 sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name);
189                 if (!sec->name) {
190                         WARN_ELF("elf_strptr");
191                         return -1;
192                 }
193 
194                 if (sec->sh.sh_size != 0) {
195                         sec->data = elf_getdata(s, NULL);
196                         if (!sec->data) {
197                                 WARN_ELF("elf_getdata");
198                                 return -1;
199                         }
200                         if (sec->data->d_off != 0 ||
201                             sec->data->d_size != sec->sh.sh_size) {
202                                 WARN("unexpected data attributes for %s",
203                                      sec->name);
204                                 return -1;
205                         }
206                 }
207                 sec->len = sec->sh.sh_size;
208         }
209 
210         /* sanity check, one more call to elf_nextscn() should return NULL */
211         if (elf_nextscn(elf->elf, s)) {
212                 WARN("section entry mismatch");
213                 return -1;
214         }
215 
216         return 0;
217 }
218 
219 static int read_symbols(struct elf *elf)
220 {
221         struct section *symtab, *sec;
222         struct symbol *sym, *pfunc;
223         struct list_head *entry, *tmp;
224         int symbols_nr, i;
225         char *coldstr;
226 
227         symtab = find_section_by_name(elf, ".symtab");
228         if (!symtab) {
229                 WARN("missing symbol table");
230                 return -1;
231         }
232 
233         symbols_nr = symtab->sh.sh_size / symtab->sh.sh_entsize;
234 
235         for (i = 0; i < symbols_nr; i++) {
236                 sym = malloc(sizeof(*sym));
237                 if (!sym) {
238                         perror("malloc");
239                         return -1;
240                 }
241                 memset(sym, 0, sizeof(*sym));
242 
243                 sym->idx = i;
244 
245                 if (!gelf_getsym(symtab->data, i, &sym->sym)) {
246                         WARN_ELF("gelf_getsym");
247                         goto err;
248                 }
249 
250                 sym->name = elf_strptr(elf->elf, symtab->sh.sh_link,
251                                        sym->sym.st_name);
252                 if (!sym->name) {
253                         WARN_ELF("elf_strptr");
254                         goto err;
255                 }
256 
257                 sym->type = GELF_ST_TYPE(sym->sym.st_info);
258                 sym->bind = GELF_ST_BIND(sym->sym.st_info);
259 
260                 if (sym->sym.st_shndx > SHN_UNDEF &&
261                     sym->sym.st_shndx < SHN_LORESERVE) {
262                         sym->sec = find_section_by_index(elf,
263                                                          sym->sym.st_shndx);
264                         if (!sym->sec) {
265                                 WARN("couldn't find section for symbol %s",
266                                      sym->name);
267                                 goto err;
268                         }
269                         if (sym->type == STT_SECTION) {
270                                 sym->name = sym->sec->name;
271                                 sym->sec->sym = sym;
272                         }
273                 } else
274                         sym->sec = find_section_by_index(elf, 0);
275 
276                 sym->offset = sym->sym.st_value;
277                 sym->len = sym->sym.st_size;
278 
279                 /* sorted insert into a per-section list */
280                 entry = &sym->sec->symbol_list;
281                 list_for_each_prev(tmp, &sym->sec->symbol_list) {
282                         struct symbol *s;
283 
284                         s = list_entry(tmp, struct symbol, list);
285 
286                         if (sym->offset > s->offset) {
287                                 entry = tmp;
288                                 break;
289                         }
290 
291                         if (sym->offset == s->offset && sym->len >= s->len) {
292                                 entry = tmp;
293                                 break;
294                         }
295                 }
296                 list_add(&sym->list, entry);
297                 hash_add(sym->sec->symbol_hash, &sym->hash, sym->idx);
298         }
299 
300         /* Create parent/child links for any cold subfunctions */
301         list_for_each_entry(sec, &elf->sections, list) {
302                 list_for_each_entry(sym, &sec->symbol_list, list) {
303                         char pname[MAX_NAME_LEN + 1];
304                         size_t pnamelen;
305                         if (sym->type != STT_FUNC)
306                                 continue;
307                         sym->pfunc = sym->cfunc = sym;
308                         coldstr = strstr(sym->name, ".cold");
309                         if (!coldstr)
310                                 continue;
311 
312                         pnamelen = coldstr - sym->name;
313                         if (pnamelen > MAX_NAME_LEN) {
314                                 WARN("%s(): parent function name exceeds maximum length of %d characters",
315                                      sym->name, MAX_NAME_LEN);
316                                 return -1;
317                         }
318 
319                         strncpy(pname, sym->name, pnamelen);
320                         pname[pnamelen] = '\0';
321                         pfunc = find_symbol_by_name(elf, pname);
322 
323                         if (!pfunc) {
324                                 WARN("%s(): can't find parent function",
325                                      sym->name);
326                                 return -1;
327                         }
328 
329                         sym->pfunc = pfunc;
330                         pfunc->cfunc = sym;
331 
332                         /*
333                          * Unfortunately, -fnoreorder-functions puts the child
334                          * inside the parent.  Remove the overlap so we can
335                          * have sane assumptions.
336                          *
337                          * Note that pfunc->len now no longer matches
338                          * pfunc->sym.st_size.
339                          */
340                         if (sym->sec == pfunc->sec &&
341                             sym->offset >= pfunc->offset &&
342                             sym->offset + sym->len == pfunc->offset + pfunc->len) {
343                                 pfunc->len -= sym->len;
344                         }
345                 }
346         }
347 
348         return 0;
349 
350 err:
351         free(sym);
352         return -1;
353 }
354 
355 static int read_relas(struct elf *elf)
356 {
357         struct section *sec;
358         struct rela *rela;
359         int i;
360         unsigned int symndx;
361 
362         list_for_each_entry(sec, &elf->sections, list) {
363                 if (sec->sh.sh_type != SHT_RELA)
364                         continue;
365 
366                 sec->base = find_section_by_name(elf, sec->name + 5);
367                 if (!sec->base) {
368                         WARN("can't find base section for rela section %s",
369                              sec->name);
370                         return -1;
371                 }
372 
373                 sec->base->rela = sec;
374 
375                 for (i = 0; i < sec->sh.sh_size / sec->sh.sh_entsize; i++) {
376                         rela = malloc(sizeof(*rela));
377                         if (!rela) {
378                                 perror("malloc");
379                                 return -1;
380                         }
381                         memset(rela, 0, sizeof(*rela));
382 
383                         if (!gelf_getrela(sec->data, i, &rela->rela)) {
384                                 WARN_ELF("gelf_getrela");
385                                 return -1;
386                         }
387 
388                         rela->type = GELF_R_TYPE(rela->rela.r_info);
389                         rela->addend = rela->rela.r_addend;
390                         rela->offset = rela->rela.r_offset;
391                         symndx = GELF_R_SYM(rela->rela.r_info);
392                         rela->sym = find_symbol_by_index(elf, symndx);
393                         rela->rela_sec = sec;
394                         if (!rela->sym) {
395                                 WARN("can't find rela entry symbol %d for %s",
396                                      symndx, sec->name);
397                                 return -1;
398                         }
399 
400                         list_add_tail(&rela->list, &sec->rela_list);
401                         hash_add(sec->rela_hash, &rela->hash, rela->offset);
402 
403                 }
404         }
405 
406         return 0;
407 }
408 
409 struct elf *elf_open(const char *name, int flags)
410 {
411         struct elf *elf;
412         Elf_Cmd cmd;
413 
414         elf_version(EV_CURRENT);
415 
416         elf = malloc(sizeof(*elf));
417         if (!elf) {
418                 perror("malloc");
419                 return NULL;
420         }
421         memset(elf, 0, sizeof(*elf));
422 
423         INIT_LIST_HEAD(&elf->sections);
424 
425         elf->fd = open(name, flags);
426         if (elf->fd == -1) {
427                 fprintf(stderr, "objtool: Can't open '%s': %s\n",
428                         name, strerror(errno));
429                 goto err;
430         }
431 
432         if ((flags & O_ACCMODE) == O_RDONLY)
433                 cmd = ELF_C_READ_MMAP;
434         else if ((flags & O_ACCMODE) == O_RDWR)
435                 cmd = ELF_C_RDWR;
436         else /* O_WRONLY */
437                 cmd = ELF_C_WRITE;
438 
439         elf->elf = elf_begin(elf->fd, cmd, NULL);
440         if (!elf->elf) {
441                 WARN_ELF("elf_begin");
442                 goto err;
443         }
444 
445         if (!gelf_getehdr(elf->elf, &elf->ehdr)) {
446                 WARN_ELF("gelf_getehdr");
447                 goto err;
448         }
449 
450         if (read_sections(elf))
451                 goto err;
452 
453         if (read_symbols(elf))
454                 goto err;
455 
456         if (read_relas(elf))
457                 goto err;
458 
459         return elf;
460 
461 err:
462         elf_close(elf);
463         return NULL;
464 }
465 
466 struct section *elf_create_section(struct elf *elf, const char *name,
467                                    size_t entsize, int nr)
468 {
469         struct section *sec, *shstrtab;
470         size_t size = entsize * nr;
471         struct Elf_Scn *s;
472         Elf_Data *data;
473 
474         sec = malloc(sizeof(*sec));
475         if (!sec) {
476                 perror("malloc");
477                 return NULL;
478         }
479         memset(sec, 0, sizeof(*sec));
480 
481         INIT_LIST_HEAD(&sec->symbol_list);
482         INIT_LIST_HEAD(&sec->rela_list);
483         hash_init(sec->rela_hash);
484         hash_init(sec->symbol_hash);
485 
486         list_add_tail(&sec->list, &elf->sections);
487 
488         s = elf_newscn(elf->elf);
489         if (!s) {
490                 WARN_ELF("elf_newscn");
491                 return NULL;
492         }
493 
494         sec->name = strdup(name);
495         if (!sec->name) {
496                 perror("strdup");
497                 return NULL;
498         }
499 
500         sec->idx = elf_ndxscn(s);
501         sec->len = size;
502         sec->changed = true;
503 
504         sec->data = elf_newdata(s);
505         if (!sec->data) {
506                 WARN_ELF("elf_newdata");
507                 return NULL;
508         }
509 
510         sec->data->d_size = size;
511         sec->data->d_align = 1;
512 
513         if (size) {
514                 sec->data->d_buf = malloc(size);
515                 if (!sec->data->d_buf) {
516                         perror("malloc");
517                         return NULL;
518                 }
519                 memset(sec->data->d_buf, 0, size);
520         }
521 
522         if (!gelf_getshdr(s, &sec->sh)) {
523                 WARN_ELF("gelf_getshdr");
524                 return NULL;
525         }
526 
527         sec->sh.sh_size = size;
528         sec->sh.sh_entsize = entsize;
529         sec->sh.sh_type = SHT_PROGBITS;
530         sec->sh.sh_addralign = 1;
531         sec->sh.sh_flags = SHF_ALLOC;
532 
533 
534         /* Add section name to .shstrtab (or .strtab for Clang) */
535         shstrtab = find_section_by_name(elf, ".shstrtab");
536         if (!shstrtab)
537                 shstrtab = find_section_by_name(elf, ".strtab");
538         if (!shstrtab) {
539                 WARN("can't find .shstrtab or .strtab section");
540                 return NULL;
541         }
542 
543         s = elf_getscn(elf->elf, shstrtab->idx);
544         if (!s) {
545                 WARN_ELF("elf_getscn");
546                 return NULL;
547         }
548 
549         data = elf_newdata(s);
550         if (!data) {
551                 WARN_ELF("elf_newdata");
552                 return NULL;
553         }
554 
555         data->d_buf = sec->name;
556         data->d_size = strlen(name) + 1;
557         data->d_align = 1;
558 
559         sec->sh.sh_name = shstrtab->len;
560 
561         shstrtab->len += strlen(name) + 1;
562         shstrtab->changed = true;
563 
564         return sec;
565 }
566 
567 struct section *elf_create_rela_section(struct elf *elf, struct section *base)
568 {
569         char *relaname;
570         struct section *sec;
571 
572         relaname = malloc(strlen(base->name) + strlen(".rela") + 1);
573         if (!relaname) {
574                 perror("malloc");
575                 return NULL;
576         }
577         strcpy(relaname, ".rela");
578         strcat(relaname, base->name);
579 
580         sec = elf_create_section(elf, relaname, sizeof(GElf_Rela), 0);
581         free(relaname);
582         if (!sec)
583                 return NULL;
584 
585         base->rela = sec;
586         sec->base = base;
587 
588         sec->sh.sh_type = SHT_RELA;
589         sec->sh.sh_addralign = 8;
590         sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx;
591         sec->sh.sh_info = base->idx;
592         sec->sh.sh_flags = SHF_INFO_LINK;
593 
594         return sec;
595 }
596 
597 int elf_rebuild_rela_section(struct section *sec)
598 {
599         struct rela *rela;
600         int nr, idx = 0, size;
601         GElf_Rela *relas;
602 
603         nr = 0;
604         list_for_each_entry(rela, &sec->rela_list, list)
605                 nr++;
606 
607         size = nr * sizeof(*relas);
608         relas = malloc(size);
609         if (!relas) {
610                 perror("malloc");
611                 return -1;
612         }
613 
614         sec->data->d_buf = relas;
615         sec->data->d_size = size;
616 
617         sec->sh.sh_size = size;
618 
619         idx = 0;
620         list_for_each_entry(rela, &sec->rela_list, list) {
621                 relas[idx].r_offset = rela->offset;
622                 relas[idx].r_addend = rela->addend;
623                 relas[idx].r_info = GELF_R_INFO(rela->sym->idx, rela->type);
624                 idx++;
625         }
626 
627         return 0;
628 }
629 
630 int elf_write(struct elf *elf)
631 {
632         struct section *sec;
633         Elf_Scn *s;
634 
635         /* Update section headers for changed sections: */
636         list_for_each_entry(sec, &elf->sections, list) {
637                 if (sec->changed) {
638                         s = elf_getscn(elf->elf, sec->idx);
639                         if (!s) {
640                                 WARN_ELF("elf_getscn");
641                                 return -1;
642                         }
643                         if (!gelf_update_shdr(s, &sec->sh)) {
644                                 WARN_ELF("gelf_update_shdr");
645                                 return -1;
646                         }
647                 }
648         }
649 
650         /* Make sure the new section header entries get updated properly. */
651         elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY);
652 
653         /* Write all changes to the file. */
654         if (elf_update(elf->elf, ELF_C_WRITE) < 0) {
655                 WARN_ELF("elf_update");
656                 return -1;
657         }
658 
659         return 0;
660 }
661 
662 void elf_close(struct elf *elf)
663 {
664         struct section *sec, *tmpsec;
665         struct symbol *sym, *tmpsym;
666         struct rela *rela, *tmprela;
667 
668         if (elf->elf)
669                 elf_end(elf->elf);
670 
671         if (elf->fd > 0)
672                 close(elf->fd);
673 
674         list_for_each_entry_safe(sec, tmpsec, &elf->sections, list) {
675                 list_for_each_entry_safe(sym, tmpsym, &sec->symbol_list, list) {
676                         list_del(&sym->list);
677                         hash_del(&sym->hash);
678                         free(sym);
679                 }
680                 list_for_each_entry_safe(rela, tmprela, &sec->rela_list, list) {
681                         list_del(&rela->list);
682                         hash_del(&rela->hash);
683                         free(rela);
684                 }
685                 list_del(&sec->list);
686                 free(sec);
687         }
688 
689         free(elf);
690 }
691 

~ [ 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