gdb/auxv.c

   1 /* Auxiliary vector support for GDB, the GNU debugger.
   2
   3    Copyright (C) 2004-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "target.h"
  22 #include "gdbtypes.h"
  23 #include "command.h"
  24 #include "inferior.h"
  25 #include "valprint.h"
  26 #include "gdb_assert.h"
  27 #include "gdbcore.h"
  28 #include "observer.h"
  29 #include "filestuff.h"
  30
  31 #include "auxv.h"
  32 #include "elf/common.h"
  33
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36
  37
  38 /* Implement the to_xfer_partial target_ops method.  This function
  39    handles access via /proc/PID/auxv, which is a common method for
  40    native targets.  */
  41
  42 static enum target_xfer_status
  43 procfs_xfer_auxv (gdb_byte *readbuf,
  44                   const gdb_byte *writebuf,
  45                   ULONGEST offset,
  46                   ULONGEST len,
  47                   ULONGEST *xfered_len)
  48 {
  49   char *pathname;
  50   int fd;
  51   ssize_t l;
  52
  53   pathname = xstrprintf ("/proc/%d/auxv", ptid_get_pid (inferior_ptid));
  54   fd = gdb_open_cloexec (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY, 0);
  55   xfree (pathname);
  56   if (fd < 0)
  57     return TARGET_XFER_E_IO;
  58
  59   if (offset != (ULONGEST) 0
  60       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
  61     l = -1;
  62   else if (readbuf != NULL)
  63     l = read (fd, readbuf, (size_t) len);
  64   else
  65     l = write (fd, writebuf, (size_t) len);
  66
  67   (void) close (fd);
  68
  69   if (l < 0)
  70     return TARGET_XFER_E_IO;
  71   else if (l == 0)
  72     return TARGET_XFER_EOF;
  73   else
  74     {
  75       *xfered_len = (ULONGEST) l;
  76       return TARGET_XFER_OK;
  77     }
  78 }
  79
  80 /* This function handles access via ld.so's symbol `_dl_auxv'.  */
  81
  82 static enum target_xfer_status
  83 ld_so_xfer_auxv (gdb_byte *readbuf,
  84                  const gdb_byte *writebuf,
  85                  ULONGEST offset,
  86                  ULONGEST len, ULONGEST *xfered_len)
  87 {
  88   struct minimal_symbol *msym;
  89   CORE_ADDR data_address, pointer_address;
  90   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
  91   size_t ptr_size = TYPE_LENGTH (ptr_type);
  92   size_t auxv_pair_size = 2 * ptr_size;
  93   gdb_byte *ptr_buf = alloca (ptr_size);
  94   LONGEST retval;
  95   size_t block;
  96
  97   msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
  98   if (msym == NULL)
  99     return TARGET_XFER_E_IO;
 100
 101   if (MSYMBOL_SIZE (msym) != ptr_size)
 102     return TARGET_XFER_E_IO;
 103
 104   /* POINTER_ADDRESS is a location where the `_dl_auxv' variable
 105      resides.  DATA_ADDRESS is the inferior value present in
 106      `_dl_auxv', therefore the real inferior AUXV address.  */
 107
 108   pointer_address = SYMBOL_VALUE_ADDRESS (msym);
 109
 110   /* The location of the _dl_auxv symbol may no longer be correct if
 111      ld.so runs at a different address than the one present in the
 112      file.  This is very common case - for unprelinked ld.so or with a
 113      PIE executable.  PIE executable forces random address even for
 114      libraries already being prelinked to some address.  PIE
 115      executables themselves are never prelinked even on prelinked
 116      systems.  Prelinking of a PIE executable would block their
 117      purpose of randomizing load of everything including the
 118      executable.
 119
 120      If the memory read fails, return -1 to fallback on another
 121      mechanism for retrieving the AUXV.
 122
 123      In most cases of a PIE running under valgrind there is no way to
 124      find out the base addresses of any of ld.so, executable or AUXV
 125      as everything is randomized and /proc information is not relevant
 126      for the virtual executable running under valgrind.  We think that
 127      we might need a valgrind extension to make it work.  This is PR
 128      11440.  */
 129
 130   if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
 131     return TARGET_XFER_E_IO;
 132
 133   data_address = extract_typed_address (ptr_buf, ptr_type);
 134
 135   /* Possibly still not initialized such as during an inferior
 136      startup.  */
 137   if (data_address == 0)
 138     return TARGET_XFER_E_IO;
 139
 140   data_address += offset;
 141
 142   if (writebuf != NULL)
 143     {
 144       if (target_write_memory (data_address, writebuf, len) == 0)
 145         {
 146           *xfered_len = (ULONGEST) len;
 147           return TARGET_XFER_OK;
 148         }
 149       else
 150         return TARGET_XFER_E_IO;
 151     }
 152
 153   /* Stop if trying to read past the existing AUXV block.  The final
 154      AT_NULL was already returned before.  */
 155
 156   if (offset >= auxv_pair_size)
 157     {
 158       if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
 159                               ptr_size) != 0)
 160         return TARGET_XFER_E_IO;
 161
 162       if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
 163         return TARGET_XFER_EOF;
 164     }
 165
 166   retval = 0;
 167   block = 0x400;
 168   gdb_assert (block % auxv_pair_size == 0);
 169
 170   while (len > 0)
 171     {
 172       if (block > len)
 173         block = len;
 174
 175       /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported.
 176          Tails unaligned to AUXV_PAIR_SIZE will not be read during a
 177          call (they should be completed during next read with
 178          new/extended buffer).  */
 179
 180       block &= -auxv_pair_size;
 181       if (block == 0)
 182         break;
 183
 184       if (target_read_memory (data_address, readbuf, block) != 0)
 185         {
 186           if (block <= auxv_pair_size)
 187             break;
 188
 189           block = auxv_pair_size;
 190           continue;
 191         }
 192
 193       data_address += block;
 194       len -= block;
 195
 196       /* Check terminal AT_NULL.  This function is being called
 197          indefinitely being extended its READBUF until it returns EOF
 198          (0).  */
 199
 200       while (block >= auxv_pair_size)
 201         {
 202           retval += auxv_pair_size;
 203
 204           if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
 205             {
 206               *xfered_len = (ULONGEST) retval;
 207               return TARGET_XFER_OK;
 208             }
 209
 210           readbuf += auxv_pair_size;
 211           block -= auxv_pair_size;
 212         }
 213     }
 214
 215   *xfered_len = (ULONGEST) retval;
 216   return TARGET_XFER_OK;
 217 }
 218
 219 /* Implement the to_xfer_partial target_ops method for
 220    TARGET_OBJECT_AUXV.  It handles access to AUXV.  */
 221
 222 enum target_xfer_status
 223 memory_xfer_auxv (struct target_ops *ops,
 224                   enum target_object object,
 225                   const char *annex,
 226                   gdb_byte *readbuf,
 227                   const gdb_byte *writebuf,
 228                   ULONGEST offset,
 229                   ULONGEST len, ULONGEST *xfered_len)
 230 {
 231   gdb_assert (object == TARGET_OBJECT_AUXV);
 232   gdb_assert (readbuf || writebuf);
 233
 234    /* ld_so_xfer_auxv is the only function safe for virtual
 235       executables being executed by valgrind's memcheck.  Using
 236       ld_so_xfer_auxv during inferior startup is problematic, because
 237       ld.so symbol tables have not yet been relocated.  So GDB uses
 238       this function only when attaching to a process.
 239       */
 240
 241   if (current_inferior ()->attach_flag != 0)
 242     {
 243       enum target_xfer_status ret;
 244
 245       ret = ld_so_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
 246       if (ret != TARGET_XFER_E_IO)
 247         return ret;
 248     }
 249
 250   return procfs_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
 251 }
 252
 253 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
 254    Return 0 if *READPTR is already at the end of the buffer.
 255    Return -1 if there is insufficient buffer for a whole entry.
 256    Return 1 if an entry was read into *TYPEP and *VALP.  */
 257 static int
 258 default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
 259                    gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 260 {
 261   const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch ())
 262                                 / TARGET_CHAR_BIT;
 263   const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 264   gdb_byte *ptr = *readptr;
 265
 266   if (endptr == ptr)
 267     return 0;
 268
 269   if (endptr - ptr < sizeof_auxv_field * 2)
 270     return -1;
 271
 272   *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
 273   ptr += sizeof_auxv_field;
 274   *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
 275   ptr += sizeof_auxv_field;
 276
 277   *readptr = ptr;
 278   return 1;
 279 }
 280
 281 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
 282    Return 0 if *READPTR is already at the end of the buffer.
 283    Return -1 if there is insufficient buffer for a whole entry.
 284    Return 1 if an entry was read into *TYPEP and *VALP.  */
 285 int
 286 target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
 287                   gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 288 {
 289   struct target_ops *t;
 290
 291   for (t = ops; t != NULL; t = t->beneath)
 292     if (t->to_auxv_parse != NULL)
 293       return t->to_auxv_parse (t, readptr, endptr, typep, valp);
 294
 295   return default_auxv_parse (ops, readptr, endptr, typep, valp);
 296 }
 297
 298
 299 /* Per-inferior data key for auxv.  */
 300 static const struct inferior_data *auxv_inferior_data;
 301
 302 /*  Auxiliary Vector information structure.  This is used by GDB
 303     for caching purposes for each inferior.  This helps reduce the
 304     overhead of transfering data from a remote target to the local host.  */
 305 struct auxv_info
 306 {
 307   LONGEST length;
 308   gdb_byte *data;
 309 };
 310
 311 /* Handles the cleanup of the auxv cache for inferior INF.  ARG is ignored.
 312    Frees whatever allocated space there is to be freed and sets INF's auxv cache
 313    data pointer to NULL.
 314
 315    This function is called when the following events occur: inferior_appeared,
 316    inferior_exit and executable_changed.  */
 317
 318 static void
 319 auxv_inferior_data_cleanup (struct inferior *inf, void *arg)
 320 {
 321   struct auxv_info *info;
 322
 323   info = inferior_data (inf, auxv_inferior_data);
 324   if (info != NULL)
 325     {
 326       xfree (info->data);
 327       xfree (info);
 328       set_inferior_data (inf, auxv_inferior_data, NULL);
 329     }
 330 }
 331
 332 /* Invalidate INF's auxv cache.  */
 333
 334 static void
 335 invalidate_auxv_cache_inf (struct inferior *inf)
 336 {
 337   auxv_inferior_data_cleanup (inf, NULL);
 338 }
 339
 340 /* Invalidate current inferior's auxv cache.  */
 341
 342 static void
 343 invalidate_auxv_cache (void)
 344 {
 345   invalidate_auxv_cache_inf (current_inferior ());
 346 }
 347
 348 /* Fetch the auxv object from inferior INF.  If auxv is cached already,
 349    return a pointer to the cache.  If not, fetch the auxv object from the
 350    target and cache it.  This function always returns a valid INFO pointer.  */
 351
 352 static struct auxv_info *
 353 get_auxv_inferior_data (struct target_ops *ops)
 354 {
 355   struct auxv_info *info;
 356   struct inferior *inf = current_inferior ();
 357
 358   info = inferior_data (inf, auxv_inferior_data);
 359   if (info == NULL)
 360     {
 361       info = XCNEW (struct auxv_info);
 362       info->length = target_read_alloc (ops, TARGET_OBJECT_AUXV,
 363                                         NULL, &info->data);
 364       set_inferior_data (inf, auxv_inferior_data, info);
 365     }
 366
 367   return info;
 368 }
 369
 370 /* Extract the auxiliary vector entry with a_type matching MATCH.
 371    Return zero if no such entry was found, or -1 if there was
 372    an error getting the information.  On success, return 1 after
 373    storing the entry's value field in *VALP.  */
 374 int
 375 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
 376 {
 377   CORE_ADDR type, val;
 378   gdb_byte *data;
 379   gdb_byte *ptr;
 380   struct auxv_info *info;
 381
 382   info = get_auxv_inferior_data (ops);
 383
 384   data = info->data;
 385   ptr = data;
 386
 387   if (info->length <= 0)
 388     return info->length;
 389
 390   while (1)
 391     switch (target_auxv_parse (ops, &ptr, data + info->length, &type, &val))
 392       {
 393       case 1:                   /* Here's an entry, check it.  */
 394         if (type == match)
 395           {
 396             *valp = val;
 397             return 1;
 398           }
 399         break;
 400       case 0:                   /* End of the vector.  */
 401         return 0;
 402       default:                  /* Bogosity.  */
 403         return -1;
 404       }
 405
 406   /*NOTREACHED*/
 407 }
 408
 409
 410 /* Print the contents of the target's AUXV on the specified file.  */
 411 int
 412 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
 413 {
 414   CORE_ADDR type, val;
 415   gdb_byte *data;
 416   gdb_byte *ptr;
 417   struct auxv_info *info;
 418   int ents = 0;
 419
 420   info = get_auxv_inferior_data (ops);
 421
 422   data = info->data;
 423   ptr = data;
 424   if (info->length <= 0)
 425     return info->length;
 426
 427   while (target_auxv_parse (ops, &ptr, data + info->length, &type, &val) > 0)
 428     {
 429       const char *name = "???";
 430       const char *description = "";
 431       enum { dec, hex, str } flavor = hex;
 432
 433       switch (type)
 434         {
 435 #define TAG(tag, text, kind) \
 436         case tag: name = #tag; description = text; flavor = kind; break
 437           TAG (AT_NULL, _("End of vector"), hex);
 438           TAG (AT_IGNORE, _("Entry should be ignored"), hex);
 439           TAG (AT_EXECFD, _("File descriptor of program"), dec);
 440           TAG (AT_PHDR, _("Program headers for program"), hex);
 441           TAG (AT_PHENT, _("Size of program header entry"), dec);
 442           TAG (AT_PHNUM, _("Number of program headers"), dec);
 443           TAG (AT_PAGESZ, _("System page size"), dec);
 444           TAG (AT_BASE, _("Base address of interpreter"), hex);
 445           TAG (AT_FLAGS, _("Flags"), hex);
 446           TAG (AT_ENTRY, _("Entry point of program"), hex);
 447           TAG (AT_NOTELF, _("Program is not ELF"), dec);
 448           TAG (AT_UID, _("Real user ID"), dec);
 449           TAG (AT_EUID, _("Effective user ID"), dec);
 450           TAG (AT_GID, _("Real group ID"), dec);
 451           TAG (AT_EGID, _("Effective group ID"), dec);
 452           TAG (AT_CLKTCK, _("Frequency of times()"), dec);
 453           TAG (AT_PLATFORM, _("String identifying platform"), str);
 454           TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
 455           TAG (AT_FPUCW, _("Used FPU control word"), dec);
 456           TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
 457           TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
 458           TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
 459           TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
 460           TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str);
 461           TAG (AT_RANDOM, _("Address of 16 random bytes"), hex);
 462           TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), hex);
 463           TAG (AT_EXECFN, _("File name of executable"), str);
 464           TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
 465           TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
 466           TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
 467           TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"), hex);
 468           TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), hex);
 469           TAG (AT_L2_CACHESHAPE, _("L2 cache information"), hex);
 470           TAG (AT_L3_CACHESHAPE, _("L3 cache information"), hex);
 471           TAG (AT_SUN_UID, _("Effective user ID"), dec);
 472           TAG (AT_SUN_RUID, _("Real user ID"), dec);
 473           TAG (AT_SUN_GID, _("Effective group ID"), dec);
 474           TAG (AT_SUN_RGID, _("Real group ID"), dec);
 475           TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
 476           TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
 477           TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
 478           TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
 479           TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
 480           TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
 481           TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
 482           TAG (AT_SUN_CPU, _("CPU name string"), str);
 483           TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
 484           TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
 485           TAG (AT_SUN_EXECNAME,
 486                _("Canonicalized file name given to execve"), str);
 487           TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
 488           TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
 489           TAG (AT_SUN_AUXFLAGS,
 490                _("AF_SUN_ flags passed from the kernel"), hex);
 491         }
 492
 493       fprintf_filtered (file, "%-4s %-20s %-30s ",
 494                         plongest (type), name, description);
 495       switch (flavor)
 496         {
 497         case dec:
 498           fprintf_filtered (file, "%s\n", plongest (val));
 499           break;
 500         case hex:
 501           fprintf_filtered (file, "%s\n", paddress (target_gdbarch (), val));
 502           break;
 503         case str:
 504           {
 505             struct value_print_options opts;
 506
 507             get_user_print_options (&opts);
 508             if (opts.addressprint)
 509               fprintf_filtered (file, "%s ", paddress (target_gdbarch (), val));
 510             val_print_string (builtin_type (target_gdbarch ())->builtin_char,
 511                               NULL, val, -1, file, &opts);
 512             fprintf_filtered (file, "\n");
 513           }
 514           break;
 515         }
 516       ++ents;
 517       if (type == AT_NULL)
 518         break;
 519     }
 520
 521   return ents;
 522 }
 523
 524 static void
 525 info_auxv_command (char *cmd, int from_tty)
 526 {
 527   if (! target_has_stack)
 528     error (_("The program has no auxiliary information now."));
 529   else
 530     {
 531       int ents = fprint_target_auxv (gdb_stdout, &current_target);
 532
 533       if (ents < 0)
 534         error (_("No auxiliary vector found, or failed reading it."));
 535       else if (ents == 0)
 536         error (_("Auxiliary vector is empty."));
 537     }
 538 }
 539
 540
 541 extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
 542
 543 void
 544 _initialize_auxv (void)
 545 {
 546   add_info ("auxv", info_auxv_command,
 547             _("Display the inferior's auxiliary vector.\n\
 548 This is information provided by the operating system at program startup."));
 549
 550   /* Set an auxv cache per-inferior.  */
 551   auxv_inferior_data
 552     = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
 553
 554   /* Observers used to invalidate the auxv cache when needed.  */
 555   observer_attach_inferior_exit (invalidate_auxv_cache_inf);
 556   observer_attach_inferior_appeared (invalidate_auxv_cache_inf);
 557   observer_attach_executable_changed (invalidate_auxv_cache);
 558 }