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