LCOV - code coverage report
Current view: top level - libdwelf - dwelf_elf_gnu_build_id.c (source / functions) Hit Total Coverage
Test: elfutils-0.178 Lines: 51 59 86.4 %
Date: 2019-11-26 23:55:16 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Returns the build id if found in a NT_GNU_BUILD_ID note.
       2             :    Copyright (C) 2014 Red Hat, Inc.
       3             :    This file is part of elfutils.
       4             : 
       5             :    This file is free software; you can redistribute it and/or modify
       6             :    it under the terms of either
       7             : 
       8             :      * the GNU Lesser General Public License as published by the Free
       9             :        Software Foundation; either version 3 of the License, or (at
      10             :        your option) any later version
      11             : 
      12             :    or
      13             : 
      14             :      * the GNU General Public License as published by the Free
      15             :        Software Foundation; either version 2 of the License, or (at
      16             :        your option) any later version
      17             : 
      18             :    or both in parallel, as here.
      19             : 
      20             :    elfutils is distributed in the hope that it will be useful, but
      21             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      22             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      23             :    General Public License for more details.
      24             : 
      25             :    You should have received copies of the GNU General Public License and
      26             :    the GNU Lesser General Public License along with this program.  If
      27             :    not, see <http://www.gnu.org/licenses/>.  */
      28             : 
      29             : #ifdef HAVE_CONFIG_H
      30             : # include <config.h>
      31             : #endif
      32             : 
      33             : #include "libdwelfP.h"
      34             : #include "libdwflP.h"
      35             : 
      36             : #define NO_VADDR        ((GElf_Addr) -1l)
      37             : 
      38             : static int
      39         386 : check_notes (Elf_Data *data, GElf_Addr data_elfaddr,
      40             :              const void **build_id_bits, GElf_Addr *build_id_elfaddr,
      41             :              int *build_id_len)
      42             : {
      43         386 :   size_t pos = 0;
      44         386 :   GElf_Nhdr nhdr;
      45         386 :   size_t name_pos;
      46         386 :   size_t desc_pos;
      47         528 :   while ((pos = gelf_getnote (data, pos, &nhdr, &name_pos, &desc_pos)) > 0)
      48         393 :     if (nhdr.n_type == NT_GNU_BUILD_ID
      49         251 :         && nhdr.n_namesz == sizeof "GNU"
      50         251 :         && !memcmp (data->d_buf + name_pos, "GNU", sizeof "GNU"))
      51             :         {
      52         251 :           *build_id_bits = data->d_buf + desc_pos;
      53         502 :           *build_id_elfaddr = (data_elfaddr == NO_VADDR
      54         251 :                               ? 0 : data_elfaddr + desc_pos);
      55         251 :           *build_id_len = nhdr.n_descsz;
      56         251 :           return 1;
      57             :         }
      58             :   return 0;
      59             : }
      60             : 
      61             : /* Defined here for reuse. The dwelf interface doesn't care about the
      62             :    address of the note, but libdwfl does.  */
      63             : static int
      64         266 : find_elf_build_id (Dwfl_Module *mod, int e_type, Elf *elf,
      65             :                    const void **build_id_bits, GElf_Addr *build_id_elfaddr,
      66             :                    int *build_id_len)
      67             : {
      68         266 :   size_t shstrndx = SHN_UNDEF;
      69         266 :   int result = 0;
      70             : 
      71         266 :   Elf_Scn *scn = elf_nextscn (elf, NULL);
      72             : 
      73         266 :   if (scn == NULL)
      74             :     {
      75             :       /* No sections, have to look for phdrs.  */
      76           9 :       size_t phnum;
      77           9 :       if (unlikely (elf_getphdrnum (elf, &phnum) != 0))
      78             :         {
      79           0 :           if (mod != NULL)
      80           0 :             __libdwfl_seterrno (DWFL_E_LIBELF);
      81           0 :           return -1;
      82             :         }
      83          46 :       for (size_t i = 0; result == 0 && i < phnum; ++i)
      84             :         {
      85          37 :           GElf_Phdr phdr_mem;
      86          37 :           GElf_Phdr *phdr = gelf_getphdr (elf, i, &phdr_mem);
      87          37 :           if (likely (phdr != NULL) && phdr->p_type == PT_NOTE)
      88           9 :             result = check_notes (elf_getdata_rawchunk (elf,
      89           9 :                                                         phdr->p_offset,
      90             :                                                         phdr->p_filesz,
      91           9 :                                                         (phdr->p_align == 8
      92             :                                                          ? ELF_T_NHDR8
      93             :                                                          : ELF_T_NHDR)),
      94             :                                   phdr->p_vaddr,
      95             :                                   build_id_bits,
      96             :                                   build_id_elfaddr,
      97             :                                   build_id_len);
      98             :         }
      99             :     }
     100             :   else
     101         778 :     do
     102             :       {
     103         778 :         GElf_Shdr shdr_mem;
     104         778 :         GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
     105         778 :         if (likely (shdr != NULL) && shdr->sh_type == SHT_NOTE)
     106             :           {
     107             :             /* Determine the right sh_addr in this module.  */
     108         377 :             GElf_Addr vaddr = 0;
     109         377 :             if (!(shdr->sh_flags & SHF_ALLOC))
     110          14 :               vaddr = NO_VADDR;
     111         363 :             else if (mod == NULL || e_type != ET_REL)
     112         363 :               vaddr = shdr->sh_addr;
     113           0 :             else if (__libdwfl_relocate_value (mod, elf, &shstrndx,
     114           0 :                                                elf_ndxscn (scn), &vaddr))
     115           0 :               vaddr = NO_VADDR;
     116         377 :             result = check_notes (elf_getdata (scn, NULL), vaddr,
     117             :                                   build_id_bits,
     118             :                                   build_id_elfaddr,
     119             :                                   build_id_len);
     120             :           }
     121             :       }
     122         778 :     while (result == 0 && (scn = elf_nextscn (elf, scn)) != NULL);
     123             : 
     124             :   return result;
     125             : }
     126             : 
     127             : int
     128             : internal_function
     129         167 : __libdwfl_find_elf_build_id (Dwfl_Module *mod, Elf *elf,
     130             :                              const void **build_id_bits,
     131             :                              GElf_Addr *build_id_elfaddr, int *build_id_len)
     132             : {
     133         167 :   GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr (elf, &ehdr_mem);
     134         167 :   if (unlikely (ehdr == NULL))
     135             :     {
     136           0 :       __libdwfl_seterrno (DWFL_E_LIBELF);
     137           0 :       return -1;
     138             :     }
     139             :   // MOD->E_TYPE is zero here.
     140         167 :   assert (ehdr->e_type != ET_REL || mod != NULL);
     141             : 
     142         167 :   return find_elf_build_id (mod, ehdr->e_type, elf,
     143             :                             build_id_bits, build_id_elfaddr, build_id_len);
     144             : }
     145             : 
     146             : ssize_t
     147          99 : dwelf_elf_gnu_build_id (Elf *elf, const void **build_idp)
     148             : {
     149          99 :   GElf_Addr build_id_elfaddr;
     150          99 :   int build_id_len;
     151          99 :   int result = find_elf_build_id (NULL, ET_NONE, elf, build_idp,
     152             :                                   &build_id_elfaddr, &build_id_len);
     153          99 :   if (result > 0)
     154          98 :     return build_id_len;
     155             : 
     156           1 :   return result;
     157             : }
     158             : INTDEF(dwelf_elf_gnu_build_id)

Generated by: LCOV version 1.13