gdb/auxv.c

   1 /* Auxiliary vector support for GDB, the GNU debugger.
   2
   3    Copyright (C) 2004-2018 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 "gdbcore.h"
  27 #include "observer.h"
  28 #include "filestuff.h"
  29 #include "objfiles.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 bound_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 = (gdb_byte *) alloca (ptr_size);
  94   LONGEST retval;
  95   size_t block;
  96
  97   msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
  98   if (msym.minsym == NULL)
  99     return TARGET_XFER_E_IO;
 100
 101   if (MSYMBOL_SIZE (msym.minsym) != 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 = BMSYMBOL_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 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 gdbarch *gdbarch = target_gdbarch();
 290
 291   if (gdbarch_auxv_parse_p (gdbarch))
 292     return gdbarch_auxv_parse (gdbarch, readptr, endptr, typep, valp);
 293
 294   return current_target.to_auxv_parse (&current_target, readptr, endptr,
 295                                        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 = (struct auxv_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 = (struct auxv_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 description of a single AUXV entry on the specified file.  */
 411
 412 void
 413 fprint_auxv_entry (struct ui_file *file, const char *name,
 414                    const char *description, enum auxv_format format,
 415                    CORE_ADDR type, CORE_ADDR val)
 416 {
 417   fprintf_filtered (file, ("%-4s %-20s %-30s "),
 418                     plongest (type), name, description);
 419   switch (format)
 420     {
 421     case AUXV_FORMAT_DEC:
 422       fprintf_filtered (file, ("%s\n"), plongest (val));
 423       break;
 424     case AUXV_FORMAT_HEX:
 425       fprintf_filtered (file, ("%s\n"), paddress (target_gdbarch (), val));
 426       break;
 427     case AUXV_FORMAT_STR:
 428       {
 429         struct value_print_options opts;
 430
 431         get_user_print_options (&opts);
 432         if (opts.addressprint)
 433           fprintf_filtered (file, ("%s "), paddress (target_gdbarch (), val));
 434         val_print_string (builtin_type (target_gdbarch ())->builtin_char,
 435                           NULL, val, -1, file, &opts);
 436         fprintf_filtered (file, ("\n"));
 437       }
 438       break;
 439     }
 440 }
 441
 442 /* The default implementation of gdbarch_print_auxv_entry.  */
 443
 444 void
 445 default_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
 446                           CORE_ADDR type, CORE_ADDR val)
 447 {
 448   const char *name = "???";
 449   const char *description = "";
 450   enum auxv_format format = AUXV_FORMAT_HEX;
 451
 452   switch (type)
 453     {
 454 #define TAG(tag, text, kind) \
 455       case tag: name = #tag; description = text; format = kind; break
 456       TAG (AT_NULL, _("End of vector"), AUXV_FORMAT_HEX);
 457       TAG (AT_IGNORE, _("Entry should be ignored"), AUXV_FORMAT_HEX);
 458       TAG (AT_EXECFD, _("File descriptor of program"), AUXV_FORMAT_DEC);
 459       TAG (AT_PHDR, _("Program headers for program"), AUXV_FORMAT_HEX);
 460       TAG (AT_PHENT, _("Size of program header entry"), AUXV_FORMAT_DEC);
 461       TAG (AT_PHNUM, _("Number of program headers"), AUXV_FORMAT_DEC);
 462       TAG (AT_PAGESZ, _("System page size"), AUXV_FORMAT_DEC);
 463       TAG (AT_BASE, _("Base address of interpreter"), AUXV_FORMAT_HEX);
 464       TAG (AT_FLAGS, _("Flags"), AUXV_FORMAT_HEX);
 465       TAG (AT_ENTRY, _("Entry point of program"), AUXV_FORMAT_HEX);
 466       TAG (AT_NOTELF, _("Program is not ELF"), AUXV_FORMAT_DEC);
 467       TAG (AT_UID, _("Real user ID"), AUXV_FORMAT_DEC);
 468       TAG (AT_EUID, _("Effective user ID"), AUXV_FORMAT_DEC);
 469       TAG (AT_GID, _("Real group ID"), AUXV_FORMAT_DEC);
 470       TAG (AT_EGID, _("Effective group ID"), AUXV_FORMAT_DEC);
 471       TAG (AT_CLKTCK, _("Frequency of times()"), AUXV_FORMAT_DEC);
 472       TAG (AT_PLATFORM, _("String identifying platform"), AUXV_FORMAT_STR);
 473       TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"),
 474            AUXV_FORMAT_HEX);
 475       TAG (AT_FPUCW, _("Used FPU control word"), AUXV_FORMAT_DEC);
 476       TAG (AT_DCACHEBSIZE, _("Data cache block size"), AUXV_FORMAT_DEC);
 477       TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), AUXV_FORMAT_DEC);
 478       TAG (AT_UCACHEBSIZE, _("Unified cache block size"), AUXV_FORMAT_DEC);
 479       TAG (AT_IGNOREPPC, _("Entry should be ignored"), AUXV_FORMAT_DEC);
 480       TAG (AT_BASE_PLATFORM, _("String identifying base platform"),
 481            AUXV_FORMAT_STR);
 482       TAG (AT_RANDOM, _("Address of 16 random bytes"), AUXV_FORMAT_HEX);
 483       TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX);
 484       TAG (AT_EXECFN, _("File name of executable"), AUXV_FORMAT_STR);
 485       TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), AUXV_FORMAT_DEC);
 486       TAG (AT_SYSINFO, _("Special system info/entry points"), AUXV_FORMAT_HEX);
 487       TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"),
 488            AUXV_FORMAT_HEX);
 489       TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"),
 490            AUXV_FORMAT_HEX);
 491       TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), AUXV_FORMAT_HEX);
 492       TAG (AT_L2_CACHESHAPE, _("L2 cache information"), AUXV_FORMAT_HEX);
 493       TAG (AT_L3_CACHESHAPE, _("L3 cache information"), AUXV_FORMAT_HEX);
 494       TAG (AT_SUN_UID, _("Effective user ID"), AUXV_FORMAT_DEC);
 495       TAG (AT_SUN_RUID, _("Real user ID"), AUXV_FORMAT_DEC);
 496       TAG (AT_SUN_GID, _("Effective group ID"), AUXV_FORMAT_DEC);
 497       TAG (AT_SUN_RGID, _("Real group ID"), AUXV_FORMAT_DEC);
 498       TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), AUXV_FORMAT_HEX);
 499       TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"),
 500            AUXV_FORMAT_HEX);
 501       TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"),
 502            AUXV_FORMAT_STR);
 503       TAG (AT_SUN_LPAGESZ, _("Large pagesize"), AUXV_FORMAT_DEC);
 504       TAG (AT_SUN_PLATFORM, _("Platform name string"), AUXV_FORMAT_STR);
 505       TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"),
 506            AUXV_FORMAT_HEX);
 507       TAG (AT_SUN_IFLUSH, _("Should flush icache?"), AUXV_FORMAT_DEC);
 508       TAG (AT_SUN_CPU, _("CPU name string"), AUXV_FORMAT_STR);
 509       TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), AUXV_FORMAT_HEX);
 510       TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"),
 511            AUXV_FORMAT_DEC);
 512       TAG (AT_SUN_EXECNAME,
 513            _("Canonicalized file name given to execve"), AUXV_FORMAT_STR);
 514       TAG (AT_SUN_MMU, _("String for name of MMU module"), AUXV_FORMAT_STR);
 515       TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"),
 516            AUXV_FORMAT_HEX);
 517       TAG (AT_SUN_AUXFLAGS,
 518            _("AF_SUN_ flags passed from the kernel"), AUXV_FORMAT_HEX);
 519     }
 520
 521   fprint_auxv_entry (file, name, description, format, type, val);
 522 }
 523
 524 /* Print the contents of the target's AUXV on the specified file.  */
 525
 526 int
 527 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
 528 {
 529   struct gdbarch *gdbarch = target_gdbarch ();
 530   CORE_ADDR type, val;
 531   gdb_byte *data;
 532   gdb_byte *ptr;
 533   struct auxv_info *info;
 534   int ents = 0;
 535
 536   info = get_auxv_inferior_data (ops);
 537
 538   data = info->data;
 539   ptr = data;
 540   if (info->length <= 0)
 541     return info->length;
 542
 543   while (target_auxv_parse (ops, &ptr, data + info->length, &type, &val) > 0)
 544     {
 545       gdbarch_print_auxv_entry (gdbarch, file, type, val);
 546       ++ents;
 547       if (type == AT_NULL)
 548         break;
 549     }
 550
 551   return ents;
 552 }
 553
 554 static void
 555 info_auxv_command (const char *cmd, int from_tty)
 556 {
 557   if (! target_has_stack)
 558     error (_("The program has no auxiliary information now."));
 559   else
 560     {
 561       int ents = fprint_target_auxv (gdb_stdout, &current_target);
 562
 563       if (ents < 0)
 564         error (_("No auxiliary vector found, or failed reading it."));
 565       else if (ents == 0)
 566         error (_("Auxiliary vector is empty."));
 567     }
 568 }
 569
 570 void
 571 _initialize_auxv (void)
 572 {
 573   add_info ("auxv", info_auxv_command,
 574             _("Display the inferior's auxiliary vector.\n\
 575 This is information provided by the operating system at program startup."));
 576
 577   /* Set an auxv cache per-inferior.  */
 578   auxv_inferior_data
 579     = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
 580
 581   /* Observers used to invalidate the auxv cache when needed.  */
 582   observer_attach_inferior_exit (invalidate_auxv_cache_inf);
 583   observer_attach_inferior_appeared (invalidate_auxv_cache_inf);
 584   observer_attach_executable_changed (invalidate_auxv_cache);
 585 }