1/* 2 * This file is part of ltrace. 3 * Copyright (C) 2012,2013 Petr Machata, Red Hat Inc. 4 * Copyright (C) 2006 Paul Gilliam, IBM Corporation 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation; either version 2 of the 9 * License, or (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, but 12 * WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 19 * 02110-1301 USA 20 */ 21 22#ifndef _LIBRARY_H_ 23#define _LIBRARY_H_ 24 25#include <stdint.h> 26 27#include "callback.h" 28#include "forward.h" 29#include "sysdep.h" 30 31enum toplt { 32 LS_TOPLT_NONE = 0, /* PLT not used for this symbol. */ 33 LS_TOPLT_EXEC, /* PLT for this symbol is executable. */ 34}; 35 36/* Dict interface. */ 37size_t arch_addr_hash(const arch_addr_t *addr); 38int arch_addr_eq(const arch_addr_t *addr1, const arch_addr_t *addr2); 39 40/* For handling -l. */ 41struct library_exported_name { 42 struct library_exported_name *next; 43 const char *name; 44 int own_name : 1; 45}; 46 47struct library_symbol { 48 struct library_symbol *next; 49 struct library *lib; 50 const char *name; 51 arch_addr_t enter_addr; 52 enum toplt plt_type; 53 54 /* If this is non-NULL, this prototype is used instead of 55 * looking up one in LIB->protolib. */ 56 struct prototype *proto; 57 58 int own_name : 1; 59 60 /* This is relevant for PLT symbols. Latent PLT symbols are 61 * those that don't match any of the -e rules, but that might 62 * potentially become active if a library implementing them 63 * appears that matches a -l rule. Ltrace core is responsible 64 * for clearing latent flag. */ 65 int latent : 1; 66 67 /* Delayed symbols are those for which a breakpoint shouldn't 68 * be enabled yet. They are similar to latent symbols, but 69 * backend is responsible for clearing the delayed flag. See 70 * proc_activate_delayed_symbol. */ 71 int delayed : 1; 72 73 struct arch_library_symbol_data arch; 74 struct os_library_symbol_data os; 75}; 76 77/* Init LIBSYM. NAME will be freed when LIBSYM is destroyed if 78 * OWN_NAME. ARCH has to be initialized by a separate call. */ 79int library_symbol_init(struct library_symbol *libsym, 80 arch_addr_t addr, const char *name, int own_name, 81 enum toplt type_of_plt); 82 83/* Copy library symbol SYM into the area pointed-to by RETP. Return 0 84 * on success or a negative value on failure. */ 85int library_symbol_clone(struct library_symbol *retp, 86 struct library_symbol *sym); 87 88/* Destroy library symbol. This essentially just frees name if it's 89 * owned. It doesn't free the memory associated with SYM pointer 90 * itself. Returns 0 on success or a negative value in case of an 91 * error (which would be an out of memory condition). */ 92void library_symbol_destroy(struct library_symbol *sym); 93 94/* Compare two library symbols. Returns a negative value, 0, or a 95 * positive value, much like strcmp. The function compares symbol 96 * addresses, and if those are equal, it compares symbol names. If 97 * those are equal, too, the symbols are considered equal. */ 98int library_symbol_cmp(struct library_symbol *a, struct library_symbol *b); 99 100/* Set a name for library symbol. This frees the old name, if 101 * that is owned. */ 102void library_symbol_set_name(struct library_symbol *libsym, 103 const char *name, int own_name); 104 105/* A function that can be used as library_each_symbol callback. Looks 106 * for a symbol SYM for which library_symbol_cmp(SYM, STANDARD) 107 * returns 0. */ 108enum callback_status library_symbol_equal_cb(struct library_symbol *libsym, 109 void *standard); 110 111/* A function that can be used as library_each_symbol callback. Looks 112 * for a symbol SYM for which strcmp(SYM->name, NAME) == 0. */ 113enum callback_status library_symbol_named_cb(struct library_symbol *libsym, 114 void *name); 115 116/* A function that can be used as library_each_symbol callback. Looks 117 * for a delayed symbol. */ 118enum callback_status library_symbol_delayed_cb(struct library_symbol *libsym, 119 void *unused); 120 121enum library_type { 122 LT_LIBTYPE_MAIN, 123 LT_LIBTYPE_DSO, 124 LT_LIBTYPE_SYSCALL, 125}; 126 127/* XXX we might consider sharing libraries across processes. Things 128 * like libc will be opened by every single process, no point cloning 129 * these everywhere. But for now, keep the ownership structure 130 * simple. */ 131struct library { 132 struct library *next; 133 134 /* Unique key. Two library objects are considered equal, if 135 * they have the same key. */ 136 arch_addr_t key; 137 138 /* Address where the library is mapped. */ 139 arch_addr_t base; 140 141 /* Absolute address of the entry point. Useful for main 142 * binary, though I suppose the value might be useful for the 143 * dynamic linker, too (in case we ever want to do early 144 * process tracing). */ 145 arch_addr_t entry; 146 147 /* Address of PT_DYNAMIC segment. */ 148 arch_addr_t dyn_addr; 149 150 /* Symbols associated with the library. This includes a 151 * symbols that don't have a breakpoint attached (yet). */ 152 struct library_symbol *symbols; 153 154 /* List of names that this library implements, and that match 155 * -l filter. Each time a new library is mapped, its list of 156 * exports is examined, and corresponding PLT slots are 157 * enabled. */ 158 struct library_exported_name *exported_names; 159 160 /* Prototype library associated with this library. */ 161 struct protolib *protolib; 162 163 const char *soname; 164 const char *pathname; 165 166 enum library_type type; 167 168 char own_soname : 1; 169 char own_pathname : 1; 170 171 struct arch_library_data arch; 172 struct os_library_data os; 173}; 174 175/* Init LIB. */ 176int library_init(struct library *lib, enum library_type type); 177 178/* Initialize RETP to a library identical to LIB. Symbols are not 179 * shared, but copied over. Returns 0 on success and a negative value 180 * in case of failure. */ 181int library_clone(struct library *retp, struct library *lib); 182 183/* Destroy library. Doesn't free LIB itself. Symbols are destroyed 184 * and freed. */ 185void library_destroy(struct library *lib); 186 187/* Set library soname. Frees the old name if necessary. */ 188void library_set_soname(struct library *lib, 189 const char *new_name, int own_name); 190 191/* Set library pathname. Frees the old name if necessary. */ 192void library_set_pathname(struct library *lib, 193 const char *new_name, int own_name); 194 195/* Iterate through list of symbols of library LIB. See callback.h for 196 * notes on this interface. */ 197struct library_symbol *library_each_symbol 198 (struct library *lib, struct library_symbol *start_after, 199 enum callback_status (*cb)(struct library_symbol *, void *), 200 void *data); 201 202/* Add a new symbol SYM to LIB. SYM is assumed owned, we need to 203 * overwrite SYM->next. */ 204void library_add_symbol(struct library *lib, struct library_symbol *sym); 205 206/* A function that can be used as proc_each_library callback. Looks 207 * for a library with the name passed in DATA. PROC is ignored. */ 208enum callback_status library_named_cb(struct process *proc, 209 struct library *lib, void *name); 210 211/* A function that can be used as proc_each_library callback. Looks 212 * for a library with given base. 213 * 214 * NOTE: The key is passed as a POINTER to arch_addr_t (that 215 * because in general, arch_addr_t doesn't fit in void*). */ 216enum callback_status library_with_key_cb(struct process *proc, 217 struct library *lib, void *keyp); 218 219/* XXX this should really be in backend.h (as on pmachata/revamp 220 * branch), or, on this branch, in common.h. But we need 221 * arch_addr_t (which should also be in backend.h, I reckon), so 222 * stuff it here for the time being. */ 223/* This function is implemented in the back end. It is called for all 224 * raw addresses as read from symbol tables etc. If necessary on 225 * given architecture, this function should translate the address 226 * according to .opd or other indirection mechanism. Returns 0 on 227 * success and a negative value on failure. */ 228struct ltelf; 229int arch_translate_address(struct ltelf *lte, 230 arch_addr_t addr, arch_addr_t *ret); 231/* This is the same function as arch_translate_address, except it's 232 * used at the point that we don't have ELF available anymore. */ 233int arch_translate_address_dyn(struct process *proc, 234 arch_addr_t addr, arch_addr_t *ret); 235 236#endif /* _LIBRARY_H_ */ 237