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