library.c

   1 /*
   2  * This file is part of ltrace.
   3  * Copyright (C) 2011,2012,2013 Petr Machata, Red Hat Inc.
   4  * Copyright (C) 2001,2009 Juan Cespedes
   5  * Copyright (C) 2006 Ian Wienand
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  */
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <assert.h>
  26 #include <stdio.h>
  27
  28 #include "library.h"
  29 #include "callback.h"
  30 #include "debug.h"
  31 #include "dict.h"
  32 #include "backend.h" // for arch_library_symbol_init, arch_library_init
  33
  34 #ifndef OS_HAVE_LIBRARY_DATA
  35 int
  36 os_library_init(struct library *lib)
  37 {
  38         return 0;
  39 }
  40
  41 void
  42 os_library_destroy(struct library *lib)
  43 {
  44 }
  45
  46 int
  47 os_library_clone(struct library *retp, struct library *lib)
  48 {
  49         return 0;
  50 }
  51 #endif
  52
  53 #ifndef ARCH_HAVE_LIBRARY_DATA
  54 int
  55 arch_library_init(struct library *lib)
  56 {
  57         return 0;
  58 }
  59
  60 void
  61 arch_library_destroy(struct library *lib)
  62 {
  63 }
  64
  65 int
  66 arch_library_clone(struct library *retp, struct library *lib)
  67 {
  68         return 0;
  69 }
  70 #endif
  71
  72 #ifndef OS_HAVE_LIBRARY_SYMBOL_DATA
  73 int
  74 os_library_symbol_init(struct library_symbol *libsym)
  75 {
  76         return 0;
  77 }
  78
  79 void
  80 os_library_symbol_destroy(struct library_symbol *libsym)
  81 {
  82 }
  83
  84 int
  85 os_library_symbol_clone(struct library_symbol *retp,
  86                         struct library_symbol *libsym)
  87 {
  88         return 0;
  89 }
  90 #endif
  91
  92 #ifndef ARCH_HAVE_LIBRARY_SYMBOL_DATA
  93 int
  94 arch_library_symbol_init(struct library_symbol *libsym)
  95 {
  96         return 0;
  97 }
  98
  99 void
 100 arch_library_symbol_destroy(struct library_symbol *libsym)
 101 {
 102 }
 103
 104 int
 105 arch_library_symbol_clone(struct library_symbol *retp,
 106                           struct library_symbol *libsym)
 107 {
 108         return 0;
 109 }
 110 #endif
 111
 112 size_t
 113 arch_addr_hash(const arch_addr_t *addr)
 114 {
 115         union {
 116                 arch_addr_t addr;
 117                 int ints[sizeof(arch_addr_t)
 118                          / sizeof(unsigned int)];
 119         } u = { .addr = *addr };
 120
 121         size_t i;
 122         size_t h = 0;
 123         for (i = 0; i < sizeof(u.ints) / sizeof(*u.ints); ++i)
 124                 h ^= dict_hash_int(&u.ints[i]);
 125         return h;
 126 }
 127
 128 int
 129 arch_addr_eq(const arch_addr_t *addr1, const arch_addr_t *addr2)
 130 {
 131         return *addr1 == *addr2;
 132 }
 133
 134 int
 135 strdup_if(const char **retp, const char *str, int whether)
 136 {
 137         if (whether && str != NULL) {
 138                 str = strdup(str);
 139                 if (str == NULL)
 140                         return -1;
 141         }
 142
 143         *retp = str;
 144         return 0;
 145 }
 146
 147 static void
 148 private_library_symbol_init(struct library_symbol *libsym,
 149                             arch_addr_t addr,
 150                             const char *name, int own_name,
 151                             enum toplt type_of_plt,
 152                             int latent, int delayed)
 153 {
 154         libsym->next = NULL;
 155         libsym->lib = NULL;
 156         libsym->plt_type = type_of_plt;
 157         libsym->name = name;
 158         libsym->own_name = own_name;
 159         libsym->latent = latent;
 160         libsym->delayed = delayed;
 161         libsym->enter_addr = (void *)(uintptr_t)addr;
 162         libsym->proto = NULL;
 163 }
 164
 165 static void
 166 private_library_symbol_destroy(struct library_symbol *libsym)
 167 {
 168         library_symbol_set_name(libsym, NULL, 0);
 169 }
 170
 171 int
 172 library_symbol_init(struct library_symbol *libsym,
 173                     arch_addr_t addr, const char *name, int own_name,
 174                     enum toplt type_of_plt)
 175 {
 176         private_library_symbol_init(libsym, addr, name, own_name,
 177                                     type_of_plt, 0, 0);
 178
 179         if (os_library_symbol_init(libsym) < 0)
 180                 /* We've already set libsym->name and own_name.  But
 181                  * we return failure, and the client code isn't
 182                  * supposed to call library_symbol_destroy in such
 183                  * case.  */
 184                 return -1;
 185
 186         if (arch_library_symbol_init(libsym) < 0) {
 187                 os_library_symbol_destroy(libsym);
 188                 return -1;
 189         }
 190
 191         return 0;
 192 }
 193
 194 void
 195 library_symbol_destroy(struct library_symbol *libsym)
 196 {
 197         if (libsym != NULL) {
 198                 arch_library_symbol_destroy(libsym);
 199                 os_library_symbol_destroy(libsym);
 200                 private_library_symbol_destroy(libsym);
 201         }
 202 }
 203
 204 int
 205 library_symbol_clone(struct library_symbol *retp, struct library_symbol *libsym)
 206 {
 207         /* Make lifetimes of name stored at original independent of
 208          * the one at the clone.  */
 209         const char *name;
 210         if (strdup_if(&name, libsym->name, libsym->own_name) < 0)
 211                 return -1;
 212
 213         private_library_symbol_init(retp, libsym->enter_addr,
 214                                     name, libsym->own_name, libsym->plt_type,
 215                                     libsym->latent, libsym->delayed);
 216
 217         if (os_library_symbol_clone(retp, libsym) < 0) {
 218         fail:
 219                 private_library_symbol_destroy(retp);
 220                 return -1;
 221         }
 222
 223         if (arch_library_symbol_clone(retp, libsym) < 0) {
 224                 os_library_symbol_destroy(retp);
 225                 goto fail;
 226         }
 227
 228         return 0;
 229 }
 230
 231 int
 232 library_symbol_cmp(struct library_symbol *a, struct library_symbol *b)
 233 {
 234         if (a->enter_addr < b->enter_addr)
 235                 return -1;
 236         if (a->enter_addr > b->enter_addr)
 237                 return 1;
 238         if (a->name != NULL && b->name != NULL)
 239                 return strcmp(a->name, b->name);
 240         if (a->name == NULL) {
 241                 if (b->name == NULL)
 242                         return 0;
 243                 return -1;
 244         }
 245         return 1;
 246 }
 247
 248 void
 249 library_symbol_set_name(struct library_symbol *libsym,
 250                         const char *name, int own_name)
 251 {
 252         if (libsym->own_name)
 253                 free((char *)libsym->name);
 254         libsym->name = name;
 255         libsym->own_name = own_name;
 256 }
 257
 258 enum callback_status
 259 library_symbol_equal_cb(struct library_symbol *libsym, void *u)
 260 {
 261         struct library_symbol *standard = u;
 262         return library_symbol_cmp(libsym, standard) == 0 ? CBS_STOP : CBS_CONT;
 263 }
 264
 265 enum callback_status
 266 library_symbol_named_cb(struct library_symbol *libsym, void *name)
 267 {
 268         return strcmp(libsym->name, name) == 0 ? CBS_STOP : CBS_CONT;
 269 }
 270
 271 enum callback_status
 272 library_symbol_delayed_cb(struct library_symbol *libsym, void *unused)
 273 {
 274         return libsym->delayed ? CBS_STOP : CBS_CONT;
 275 }
 276
 277 static void
 278 private_library_init(struct library *lib, enum library_type type)
 279 {
 280         lib->next = NULL;
 281
 282         lib->key = 0;
 283         lib->base = 0;
 284         lib->entry = 0;
 285         lib->dyn_addr = 0;
 286         lib->protolib = NULL;
 287
 288         lib->soname = NULL;
 289         lib->own_soname = 0;
 290
 291         lib->pathname = NULL;
 292         lib->own_pathname = 0;
 293
 294         lib->symbols = NULL;
 295         lib->exported_names = NULL;
 296         lib->type = type;
 297 }
 298
 299 int
 300 library_init(struct library *lib, enum library_type type)
 301 {
 302         private_library_init(lib, type);
 303
 304         if (os_library_init(lib) < 0)
 305                 return -1;
 306
 307         if (arch_library_init(lib) < 0) {
 308                 os_library_destroy(lib);
 309                 return -1;
 310         }
 311
 312         return 0;
 313 }
 314
 315 static int
 316 library_exported_name_clone(struct library_exported_name *retp,
 317                             struct library_exported_name *exnm)
 318 {
 319         char *name = exnm->own_name ? strdup(exnm->name) : (char *)exnm->name;
 320         if (name == NULL)
 321                 return -1;
 322         retp->name = name;
 323         retp->own_name = exnm->own_name;
 324         return 0;
 325 }
 326
 327 int
 328 library_clone(struct library *retp, struct library *lib)
 329 {
 330         const char *soname = NULL;
 331         const char *pathname;
 332
 333         /* Make lifetimes of strings stored at original independent of
 334          * those at the clone.  */
 335         if (strdup_if(&soname, lib->soname, lib->own_soname) < 0
 336             || strdup_if(&pathname, lib->pathname, lib->own_pathname) < 0) {
 337                 if (lib->own_soname)
 338                         free((char *)soname);
 339                 return -1;
 340         }
 341
 342         private_library_init(retp, lib->type);
 343         library_set_soname(retp, soname, lib->own_soname);
 344         library_set_pathname(retp, pathname, lib->own_pathname);
 345
 346         retp->key = lib->key;
 347
 348         /* Clone symbols.  */
 349         {
 350                 struct library_symbol *it;
 351                 struct library_symbol **nsymp = &retp->symbols;
 352                 for (it = lib->symbols; it != NULL; it = it->next) {
 353                         *nsymp = malloc(sizeof(**nsymp));
 354                         if (*nsymp == NULL
 355                             || library_symbol_clone(*nsymp, it) < 0) {
 356                                 free(*nsymp);
 357                                 *nsymp = NULL;
 358                         fail:
 359                                 /* Release what we managed to allocate.  */
 360                                 library_destroy(retp);
 361                                 return -1;
 362                         }
 363
 364                         (*nsymp)->lib = retp;
 365                         nsymp = &(*nsymp)->next;
 366                 }
 367                 *nsymp = NULL;
 368         }
 369
 370         /* Clone exported names.  */
 371         {
 372                 struct library_exported_name *it;
 373                 struct library_exported_name **nnamep = &retp->exported_names;
 374                 for (it = lib->exported_names; it != NULL; it = it->next) {
 375                         *nnamep = malloc(sizeof(**nnamep));
 376                         if (*nnamep == NULL
 377                             || library_exported_name_clone(*nnamep, it) < 0) {
 378                                 free(*nnamep);
 379                                 goto fail;
 380                         }
 381                         nnamep = &(*nnamep)->next;
 382                 }
 383                 *nnamep = NULL;
 384         }
 385
 386         if (os_library_clone(retp, lib) < 0)
 387                 goto fail;
 388
 389         if (arch_library_clone(retp, lib) < 0) {
 390                 os_library_destroy(retp);
 391                 goto fail;
 392         }
 393
 394         return 0;
 395 }
 396
 397 void
 398 library_destroy(struct library *lib)
 399 {
 400         if (lib == NULL)
 401                 return;
 402
 403         arch_library_destroy(lib);
 404         os_library_destroy(lib);
 405
 406         library_set_soname(lib, NULL, 0);
 407         library_set_pathname(lib, NULL, 0);
 408
 409         struct library_symbol *sym;
 410         for (sym = lib->symbols; sym != NULL; ) {
 411                 struct library_symbol *next = sym->next;
 412                 library_symbol_destroy(sym);
 413                 free(sym);
 414                 sym = next;
 415         }
 416
 417         /* Release exported names.  */
 418         struct library_exported_name *it;
 419         for (it = lib->exported_names; it != NULL; ) {
 420                 struct library_exported_name *next = it->next;
 421                 if (it->own_name)
 422                         free((char *)it->name);
 423                 free(it);
 424                 it = next;
 425         }
 426 }
 427
 428 void
 429 library_set_soname(struct library *lib, const char *new_name, int own_name)
 430 {
 431         if (lib->own_soname)
 432                 free((char *)lib->soname);
 433         lib->soname = new_name;
 434         lib->own_soname = own_name;
 435 }
 436
 437 void
 438 library_set_pathname(struct library *lib, const char *new_name, int own_name)
 439 {
 440         if (lib->own_pathname)
 441                 free((char *)lib->pathname);
 442         lib->pathname = new_name;
 443         lib->own_pathname = own_name;
 444 }
 445
 446 struct library_symbol *
 447 library_each_symbol(struct library *lib, struct library_symbol *start_after,
 448                     enum callback_status (*cb)(struct library_symbol *, void *),
 449                     void *data)
 450 {
 451         struct library_symbol *it = start_after == NULL ? lib->symbols
 452                 : start_after->next;
 453
 454         while (it != NULL) {
 455                 struct library_symbol *next = it->next;
 456
 457                 switch ((*cb)(it, data)) {
 458                 case CBS_FAIL:
 459                         /* XXX handle me  */
 460                 case CBS_STOP:
 461                         return it;
 462                 case CBS_CONT:
 463                         break;
 464                 }
 465
 466                 it = next;
 467         }
 468
 469         return NULL;
 470 }
 471
 472 void
 473 library_add_symbol(struct library *lib, struct library_symbol *first)
 474 {
 475         struct library_symbol *last;
 476         for (last = first; last != NULL; ) {
 477                 last->lib = lib;
 478                 if (last->next != NULL)
 479                         last = last->next;
 480                 else
 481                         break;
 482         }
 483
 484         assert(last->next == NULL);
 485         last->next = lib->symbols;
 486         lib->symbols = first;
 487 }
 488
 489 enum callback_status
 490 library_named_cb(struct process *proc, struct library *lib, void *name)
 491 {
 492         if (name == lib->soname
 493             || strcmp(lib->soname, (char *)name) == 0)
 494                 return CBS_STOP;
 495         else
 496                 return CBS_CONT;
 497 }
 498
 499 enum callback_status
 500 library_with_key_cb(struct process *proc, struct library *lib, void *keyp)
 501 {
 502         return lib->key == *(arch_addr_t *)keyp ? CBS_STOP : CBS_CONT;
 503 }