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   return current_target.to_auxv_parse (&current_target, readptr, endptr,
 291                                        typep, valp);
 292 }
 293
 294
 295 /* Per-inferior data key for auxv.  */
 296 static const struct inferior_data *auxv_inferior_data;
 297
 298 /*  Auxiliary Vector information structure.  This is used by GDB
 299     for caching purposes for each inferior.  This helps reduce the
 300     overhead of transfering data from a remote target to the local host.  */
 301 struct auxv_info
 302 {
 303   LONGEST length;
 304   gdb_byte *data;
 305 };
 306
 307 /* Handles the cleanup of the auxv cache for inferior INF.  ARG is ignored.
 308    Frees whatever allocated space there is to be freed and sets INF's auxv cache
 309    data pointer to NULL.
 310
 311    This function is called when the following events occur: inferior_appeared,
 312    inferior_exit and executable_changed.  */
 313
 314 static void
 315 auxv_inferior_data_cleanup (struct inferior *inf, void *arg)
 316 {
 317   struct auxv_info *info;
 318
 319   info = inferior_data (inf, auxv_inferior_data);
 320   if (info != NULL)
 321     {
 322       xfree (info->data);
 323       xfree (info);
 324       set_inferior_data (inf, auxv_inferior_data, NULL);
 325     }
 326 }
 327
 328 /* Invalidate INF's auxv cache.  */
 329
 330 static void
 331 invalidate_auxv_cache_inf (struct inferior *inf)
 332 {
 333   auxv_inferior_data_cleanup (inf, NULL);
 334 }
 335
 336 /* Invalidate current inferior's auxv cache.  */
 337
 338 static void
 339 invalidate_auxv_cache (void)
 340 {
 341   invalidate_auxv_cache_inf (current_inferior ());
 342 }
 343
 344 /* Fetch the auxv object from inferior INF.  If auxv is cached already,
 345    return a pointer to the cache.  If not, fetch the auxv object from the
 346    target and cache it.  This function always returns a valid INFO pointer.  */
 347
 348 static struct auxv_info *
 349 get_auxv_inferior_data (struct target_ops *ops)
 350 {
 351   struct auxv_info *info;
 352   struct inferior *inf = current_inferior ();
 353
 354   info = inferior_data (inf, auxv_inferior_data);
 355   if (info == NULL)
 356     {
 357       info = XCNEW (struct auxv_info);
 358       info->length = target_read_alloc (ops, TARGET_OBJECT_AUXV,
 359                                         NULL, &info->data);
 360       set_inferior_data (inf, auxv_inferior_data, info);
 361     }
 362
 363   return info;
 364 }
 365
 366 /* Extract the auxiliary vector entry with a_type matching MATCH.
 367    Return zero if no such entry was found, or -1 if there was
 368    an error getting the information.  On success, return 1 after
 369    storing the entry's value field in *VALP.  */
 370 int
 371 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
 372 {
 373   CORE_ADDR type, val;
 374   gdb_byte *data;
 375   gdb_byte *ptr;
 376   struct auxv_info *info;
 377
 378   info = get_auxv_inferior_data (ops);
 379
 380   data = info->data;
 381   ptr = data;
 382
 383   if (info->length <= 0)
 384     return info->length;
 385
 386   while (1)
 387     switch (target_auxv_parse (ops, &ptr, data + info->length, &type, &val))
 388       {
 389       case 1:                   /* Here's an entry, check it.  */
 390         if (type == match)
 391           {
 392             *valp = val;
 393             return 1;
 394           }
 395         break;
 396       case 0:                   /* End of the vector.  */
 397         return 0;
 398       default:                  /* Bogosity.  */
 399         return -1;
 400       }
 401
 402   /*NOTREACHED*/
 403 }
 404
 405
 406 /* Print the contents of the target's AUXV on the specified file.  */
 407 int
 408 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
 409 {
 410   CORE_ADDR type, val;
 411   gdb_byte *data;
 412   gdb_byte *ptr;
 413   struct auxv_info *info;
 414   int ents = 0;
 415
 416   info = get_auxv_inferior_data (ops);
 417
 418   data = info->data;
 419   ptr = data;
 420   if (info->length <= 0)
 421     return info->length;
 422
 423   while (target_auxv_parse (ops, &ptr, data + info->length, &type, &val) > 0)
 424     {
 425       const char *name = "???";
 426       const char *description = "";
 427       enum { dec, hex, str } flavor = hex;
 428
 429       switch (type)
 430         {
 431 #define TAG(tag, text, kind) \
 432         case tag: name = #tag; description = text; flavor = kind; break
 433           TAG (AT_NULL, _("End of vector"), hex);
 434           TAG (AT_IGNORE, _("Entry should be ignored"), hex);
 435           TAG (AT_EXECFD, _("File descriptor of program"), dec);
 436           TAG (AT_PHDR, _("Program headers for program"), hex);
 437           TAG (AT_PHENT, _("Size of program header entry"), dec);
 438           TAG (AT_PHNUM, _("Number of program headers"), dec);
 439           TAG (AT_PAGESZ, _("System page size"), dec);
 440           TAG (AT_BASE, _("Base address of interpreter"), hex);
 441           TAG (AT_FLAGS, _("Flags"), hex);
 442           TAG (AT_ENTRY, _("Entry point of program"), hex);
 443           TAG (AT_NOTELF, _("Program is not ELF"), dec);
 444           TAG (AT_UID, _("Real user ID"), dec);
 445           TAG (AT_EUID, _("Effective user ID"), dec);
 446           TAG (AT_GID, _("Real group ID"), dec);
 447           TAG (AT_EGID, _("Effective group ID"), dec);
 448           TAG (AT_CLKTCK, _("Frequency of times()"), dec);
 449           TAG (AT_PLATFORM, _("String identifying platform"), str);
 450           TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
 451           TAG (AT_FPUCW, _("Used FPU control word"), dec);
 452           TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
 453           TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
 454           TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
 455           TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
 456           TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str);
 457           TAG (AT_RANDOM, _("Address of 16 random bytes"), hex);
 458           TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), hex);
 459           TAG (AT_EXECFN, _("File name of executable"), str);
 460           TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
 461           TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
 462           TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
 463           TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"), hex);
 464           TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), hex);
 465           TAG (AT_L2_CACHESHAPE, _("L2 cache information"), hex);
 466           TAG (AT_L3_CACHESHAPE, _("L3 cache information"), hex);
 467           TAG (AT_SUN_UID, _("Effective user ID"), dec);
 468           TAG (AT_SUN_RUID, _("Real user ID"), dec);
 469           TAG (AT_SUN_GID, _("Effective group ID"), dec);
 470           TAG (AT_SUN_RGID, _("Real group ID"), dec);
 471           TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
 472           TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
 473           TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
 474           TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
 475           TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
 476           TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
 477           TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
 478           TAG (AT_SUN_CPU, _("CPU name string"), str);
 479           TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
 480           TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
 481           TAG (AT_SUN_EXECNAME,
 482                _("Canonicalized file name given to execve"), str);
 483           TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
 484           TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
 485           TAG (AT_SUN_AUXFLAGS,
 486                _("AF_SUN_ flags passed from the kernel"), hex);
 487         }
 488
 489       fprintf_filtered (file, "%-4s %-20s %-30s ",
 490                         plongest (type), name, description);
 491       switch (flavor)
 492         {
 493         case dec:
 494           fprintf_filtered (file, "%s\n", plongest (val));
 495           break;
 496         case hex:
 497           fprintf_filtered (file, "%s\n", paddress (target_gdbarch (), val));
 498           break;
 499         case str:
 500           {
 501             struct value_print_options opts;
 502
 503             get_user_print_options (&opts);
 504             if (opts.addressprint)
 505               fprintf_filtered (file, "%s ", paddress (target_gdbarch (), val));
 506             val_print_string (builtin_type (target_gdbarch ())->builtin_char,
 507                               NULL, val, -1, file, &opts);
 508             fprintf_filtered (file, "\n");
 509           }
 510           break;
 511         }
 512       ++ents;
 513       if (type == AT_NULL)
 514         break;
 515     }
 516
 517   return ents;
 518 }
 519
 520 static void
 521 info_auxv_command (char *cmd, int from_tty)
 522 {
 523   if (! target_has_stack)
 524     error (_("The program has no auxiliary information now."));
 525   else
 526     {
 527       int ents = fprint_target_auxv (gdb_stdout, &current_target);
 528
 529       if (ents < 0)
 530         error (_("No auxiliary vector found, or failed reading it."));
 531       else if (ents == 0)
 532         error (_("Auxiliary vector is empty."));
 533     }
 534 }
 535
 536
 537 extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
 538
 539 void
 540 _initialize_auxv (void)
 541 {
 542   add_info ("auxv", info_auxv_command,
 543             _("Display the inferior's auxiliary vector.\n\
 544 This is information provided by the operating system at program startup."));
 545
 546   /* Set an auxv cache per-inferior.  */
 547   auxv_inferior_data
 548     = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
 549
 550   /* Observers used to invalidate the auxv cache when needed.  */
 551   observer_attach_inferior_exit (invalidate_auxv_cache_inf);
 552   observer_attach_inferior_appeared (invalidate_auxv_cache_inf);
 553   observer_attach_executable_changed (invalidate_auxv_cache);
 554 }