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