1 /* 2 * This file is part of ltrace. 3 * Copyright (C) 2006,2010,2012,2013 Petr Machata, Red Hat Inc. 4 * Copyright (C) 2010 Zachary T Welch 5 * Copyright (C) 2001,2004,2007,2009 Juan Cespedes 6 * Copyright (C) 2006 Ian Wienand 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 as 10 * published by the Free Software Foundation; either version 2 of the 11 * License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * 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, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 21 * 02110-1301 USA 22 */ 23 24 #ifndef LTRACE_ELF_H 25 #define LTRACE_ELF_H 26 27 #include <gelf.h> 28 #include <stdlib.h> 29 #include <callback.h> 30 31 #include "forward.h" 32 #include "sysdep.h" 33 #include "vect.h" 34 35 /* XXX Ok, the original idea was to separate the low-level ELF data 36 * from the abstract "struct library" object, but we use some of the 37 * following extensively in the back end. Not all though. So what we 38 * use should be move to struct library, and the rest of this 39 * structure maybe could be safely hidden in .c. How to integrate the 40 * arch-specific bits into struct library is unclear as of now. */ 41 struct ltelf { 42 int fd; 43 Elf *elf; 44 GElf_Ehdr ehdr; 45 Elf_Data *dynsym; 46 size_t dynsym_count; 47 const char *dynstr; 48 GElf_Addr plt_addr; 49 GElf_Word plt_flags; 50 size_t plt_size; 51 Elf_Data *plt_data; 52 53 /* Vector of GElf_Rela with PLT relocations. */ 54 struct vect plt_relocs; 55 56 Elf_Data *symtab; 57 const char *strtab; 58 const char *soname; 59 size_t symtab_count; 60 Elf_Data *opd; 61 GElf_Addr *opd_addr; 62 size_t opd_size; 63 GElf_Addr dyn_addr; 64 size_t dyn_sz; 65 GElf_Addr bias; 66 GElf_Addr entry_addr; 67 GElf_Addr base_addr; 68 struct arch_ltelf_data arch; 69 }; 70 71 int ltelf_init(struct ltelf *lte, const char *filename); 72 void ltelf_destroy(struct ltelf *lte); 73 74 /* XXX is it possible to put breakpoints in VDSO and VSYSCALL 75 * pseudo-libraries? For now we assume that all libraries can be 76 * opened via a filesystem. BASE is ignored for ET_EXEC files. */ 77 int ltelf_read_library(struct library *lib, struct process *proc, 78 const char *filename, GElf_Addr bias); 79 80 /* Create a library object representing the main binary. The entry 81 * point address is stored to *ENTRYP. */ 82 struct library *ltelf_read_main_binary(struct process *proc, const char *path); 83 84 /* This is called for every PLT relocation R in ELF file LTE, that 85 * ltrace is about to add to a library constructed in process PROC. 86 * The corresponding PLT entry is for symbol called NAME, and it's 87 * I-th relocation in the file. *RET shall be initialized and 88 * symbol(s) corresponding to the given PLT entry will be added to the 89 * front. Returns 0 for success, or a negative value for failures. 90 * 91 * This calls os_elf_add_plt_entry and arch_elf_add_plt_entry in the 92 * background (see backend.h for documentation). The arch callback is 93 * called first. If it returns PLT_DEFAULT, the os callback is called 94 * next. If that returns PLT_DEFAULT, default_elf_add_plt_entry is 95 * called. */ 96 int elf_add_plt_entry(struct process *proc, struct ltelf *lte, 97 const char *name, GElf_Rela *rela, size_t idx, 98 struct library_symbol **ret); 99 100 /* Create a default PLT entry. This can be used instead (or in 101 * addition to) returning PLT_DEFAULT from arch_elf_add_plt_entry. 102 * RET shall be initialized, the created symbol will be added to the 103 * beginning of the linked list at *RET. This function doesn't add 104 * the symbol to LTE. arch_elf_add_plt_entry has the chance to adjust 105 * symbol internals to its liking, and then return either PLT_DEFAULT 106 * or PLT_OK. */ 107 int default_elf_add_plt_entry(struct process *proc, struct ltelf *lte, 108 const char *a_name, GElf_Rela *rela, size_t ndx, 109 struct library_symbol **ret); 110 111 Elf_Data *elf_loaddata(Elf_Scn *scn, GElf_Shdr *shdr); 112 113 /* The following three look for sections based on various criteria. 114 * They return 0 if there was no error, or a negative value if there 115 * was. If the section was found, it is returned in *TGT_SEC, and the 116 * header is stored to TGT_SHDR. If it wasn't found, *TGT_SEC is set 117 * to NULL. */ 118 int elf_get_section_covering(struct ltelf *lte, GElf_Addr addr, 119 Elf_Scn **tgt_sec, GElf_Shdr *tgt_shdr); 120 int elf_get_section_type(struct ltelf *lte, GElf_Word type, 121 Elf_Scn **tgt_sec, GElf_Shdr *tgt_shdr); 122 int elf_get_section_named(struct ltelf *lte, const char *name, 123 Elf_Scn **tgt_sec, GElf_Shdr *tgt_shdr); 124 125 /* Iterate through all symbols in LTE. See callback.h for notes on 126 * iteration interfaces. START_AFTER is 0 in initial call. */ 127 struct elf_each_symbol_t { 128 unsigned restart; 129 int status; 130 } elf_each_symbol(struct ltelf *lte, unsigned start_after, 131 enum callback_status (*cb)(GElf_Sym *symbol, 132 const char *name, 133 void *data), 134 void *data); 135 136 /* Read relocations from relocation section SCN with header SHDR and 137 * add them to RELA_VEC, which is a vector of GElf_Rela. Return 0 on 138 * success, or a negative value on failure. */ 139 int elf_read_relocs(struct ltelf *lte, Elf_Scn *scn, GElf_Shdr *shdr, 140 struct vect *rela_vec); 141 142 /* Read a given DT_ TAG from LTE. Value is returned in *VALUEP. 143 * Returns 0 on success or a negative value on failure. */ 144 int elf_load_dynamic_entry(struct ltelf *lte, int tag, GElf_Addr *valuep); 145 146 /* Read, respectively, 1, 2, 4, or 8 bytes from Elf data at given 147 * OFFSET, and store it in *RETP. Returns 0 on success or a negative 148 * value if there's not enough data. */ 149 int elf_read_u8(Elf_Data *data, GElf_Xword offset, uint8_t *retp); 150 int elf_read_u16(Elf_Data *data, GElf_Xword offset, uint16_t *retp); 151 int elf_read_u32(Elf_Data *data, GElf_Xword offset, uint32_t *retp); 152 int elf_read_u64(Elf_Data *data, GElf_Xword offset, uint64_t *retp); 153 154 /* Read at most 64-bit quantity recorded in an ULEB128 variable-length 155 * encoding. */ 156 int elf_read_uleb128(Elf_Data *data, GElf_Xword offset, uint64_t *retp); 157 158 /* These are same as above, but update *OFFSET with the width 159 * of read datum. */ 160 int elf_read_next_u8(Elf_Data *data, GElf_Xword *offset, uint8_t *retp); 161 int elf_read_next_u16(Elf_Data *data, GElf_Xword *offset, uint16_t *retp); 162 int elf_read_next_u32(Elf_Data *data, GElf_Xword *offset, uint32_t *retp); 163 int elf_read_next_u64(Elf_Data *data, GElf_Xword *offset, uint64_t *retp); 164 int elf_read_next_uleb128(Elf_Data *data, GElf_Xword *offset, uint64_t *retp); 165 166 /* Return whether there's AMOUNT more bytes after OFFSET in DATA. */ 167 int elf_can_read_next(Elf_Data *data, GElf_Xword offset, GElf_Xword amount); 168 169 #if __WORDSIZE == 32 170 #define PRI_ELF_ADDR PRIx32 171 #define GELF_ADDR_CAST(x) (void *)(uint32_t)(x) 172 #else 173 #define PRI_ELF_ADDR PRIx64 174 #define GELF_ADDR_CAST(x) (void *)(x) 175 #endif 176 177 #endif 178