gdb/auxv.c

   1 /* Auxiliary vector support for GDB, the GNU debugger.
   2
   3    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "target.h"
  23 #include "gdbtypes.h"
  24 #include "command.h"
  25 #include "inferior.h"
  26 #include "valprint.h"
  27 #include "gdb_assert.h"
  28 #include "gdbcore.h"
  29
  30 #include "auxv.h"
  31 #include "elf/common.h"
  32
  33 #include <unistd.h>
  34 #include <fcntl.h>
  35
  36
  37 /* This function handles access via /proc/PID/auxv, which is a common
  38    method for native targets.  */
  39
  40 static LONGEST
  41 procfs_xfer_auxv (gdb_byte *readbuf,
  42                   const gdb_byte *writebuf,
  43                   ULONGEST offset,
  44                   LONGEST len)
  45 {
  46   char *pathname;
  47   int fd;
  48   LONGEST n;
  49
  50   pathname = xstrprintf ("/proc/%d/auxv", PIDGET (inferior_ptid));
  51   fd = open (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY);
  52   xfree (pathname);
  53   if (fd < 0)
  54     return -1;
  55
  56   if (offset != (ULONGEST) 0
  57       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
  58     n = -1;
  59   else if (readbuf != NULL)
  60     n = read (fd, readbuf, len);
  61   else
  62     n = write (fd, writebuf, len);
  63
  64   (void) close (fd);
  65
  66   return n;
  67 }
  68
  69 /* This function handles access via ld.so's symbol `_dl_auxv'.  */
  70
  71 static LONGEST
  72 ld_so_xfer_auxv (gdb_byte *readbuf,
  73                  const gdb_byte *writebuf,
  74                  ULONGEST offset,
  75                  LONGEST len)
  76 {
  77   struct minimal_symbol *msym;
  78   CORE_ADDR data_address, pointer_address;
  79   struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
  80   size_t ptr_size = TYPE_LENGTH (ptr_type);
  81   size_t auxv_pair_size = 2 * ptr_size;
  82   gdb_byte *ptr_buf = alloca (ptr_size);
  83   LONGEST retval;
  84   size_t block;
  85
  86   msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
  87   if (msym == NULL)
  88     return -1;
  89
  90   if (MSYMBOL_SIZE (msym) != ptr_size)
  91     return -1;
  92
  93   /* POINTER_ADDRESS is a location where the `_dl_auxv' variable
  94      resides.  DATA_ADDRESS is the inferior value present in
  95      `_dl_auxv', therefore the real inferior AUXV address.  */
  96
  97   pointer_address = SYMBOL_VALUE_ADDRESS (msym);
  98
  99   /* The location of the _dl_auxv symbol may no longer be correct if
 100      ld.so runs at a different address than the one present in the
 101      file.  This is very common case - for unprelinked ld.so or with a
 102      PIE executable.  PIE executable forces random address even for
 103      libraries already being prelinked to some address.  PIE
 104      executables themselves are never prelinked even on prelinked
 105      systems.  Prelinking of a PIE executable would block their
 106      purpose of randomizing load of everything including the
 107      executable.
 108
 109      If the memory read fails, return -1 to fallback on another
 110      mechanism for retrieving the AUXV.
 111
 112      In most cases of a PIE running under valgrind there is no way to
 113      find out the base addresses of any of ld.so, executable or AUXV
 114      as everything is randomized and /proc information is not relevant
 115      for the virtual executable running under valgrind.  We think that
 116      we might need a valgrind extension to make it work.  This is PR
 117      11440.  */
 118
 119   if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
 120     return -1;
 121
 122   data_address = extract_typed_address (ptr_buf, ptr_type);
 123
 124   /* Possibly still not initialized such as during an inferior
 125      startup.  */
 126   if (data_address == 0)
 127     return -1;
 128
 129   data_address += offset;
 130
 131   if (writebuf != NULL)
 132     {
 133       if (target_write_memory (data_address, writebuf, len) == 0)
 134         return len;
 135       else
 136         return -1;
 137     }
 138
 139   /* Stop if trying to read past the existing AUXV block.  The final
 140      AT_NULL was already returned before.  */
 141
 142   if (offset >= auxv_pair_size)
 143     {
 144       if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
 145                               ptr_size) != 0)
 146         return -1;
 147
 148       if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
 149         return 0;
 150     }
 151
 152   retval = 0;
 153   block = 0x400;
 154   gdb_assert (block % auxv_pair_size == 0);
 155
 156   while (len > 0)
 157     {
 158       if (block > len)
 159         block = len;
 160
 161       /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported.
 162          Tails unaligned to AUXV_PAIR_SIZE will not be read during a
 163          call (they should be completed during next read with
 164          new/extended buffer).  */
 165
 166       block &= -auxv_pair_size;
 167       if (block == 0)
 168         return retval;
 169
 170       if (target_read_memory (data_address, readbuf, block) != 0)
 171         {
 172           if (block <= auxv_pair_size)
 173             return retval;
 174
 175           block = auxv_pair_size;
 176           continue;
 177         }
 178
 179       data_address += block;
 180       len -= block;
 181
 182       /* Check terminal AT_NULL.  This function is being called
 183          indefinitely being extended its READBUF until it returns EOF
 184          (0).  */
 185
 186       while (block >= auxv_pair_size)
 187         {
 188           retval += auxv_pair_size;
 189
 190           if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
 191             return retval;
 192
 193           readbuf += auxv_pair_size;
 194           block -= auxv_pair_size;
 195         }
 196     }
 197
 198   return retval;
 199 }
 200
 201 /* This function is called like a to_xfer_partial hook, but must be
 202    called with TARGET_OBJECT_AUXV.  It handles access to AUXV.  */
 203
 204 LONGEST
 205 memory_xfer_auxv (struct target_ops *ops,
 206                   enum target_object object,
 207                   const char *annex,
 208                   gdb_byte *readbuf,
 209                   const gdb_byte *writebuf,
 210                   ULONGEST offset,
 211                   LONGEST len)
 212 {
 213   gdb_assert (object == TARGET_OBJECT_AUXV);
 214   gdb_assert (readbuf || writebuf);
 215
 216    /* ld_so_xfer_auxv is the only function safe for virtual
 217       executables being executed by valgrind's memcheck.  Using
 218       ld_so_xfer_auxv during inferior startup is problematic, because
 219       ld.so symbol tables have not yet been relocated.  So GDB uses
 220       this function only when attaching to a process.
 221       */
 222
 223   if (current_inferior ()->attach_flag != 0)
 224     {
 225       LONGEST retval;
 226
 227       retval = ld_so_xfer_auxv (readbuf, writebuf, offset, len);
 228       if (retval != -1)
 229         return retval;
 230     }
 231
 232   return procfs_xfer_auxv (readbuf, writebuf, offset, len);
 233 }
 234
 235 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
 236    Return 0 if *READPTR is already at the end of the buffer.
 237    Return -1 if there is insufficient buffer for a whole entry.
 238    Return 1 if an entry was read into *TYPEP and *VALP.  */
 239 static int
 240 default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
 241                    gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 242 {
 243   const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch)
 244                                 / TARGET_CHAR_BIT;
 245   const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 246   gdb_byte *ptr = *readptr;
 247
 248   if (endptr == ptr)
 249     return 0;
 250
 251   if (endptr - ptr < sizeof_auxv_field * 2)
 252     return -1;
 253
 254   *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
 255   ptr += sizeof_auxv_field;
 256   *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
 257   ptr += sizeof_auxv_field;
 258
 259   *readptr = ptr;
 260   return 1;
 261 }
 262
 263 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
 264    Return 0 if *READPTR is already at the end of the buffer.
 265    Return -1 if there is insufficient buffer for a whole entry.
 266    Return 1 if an entry was read into *TYPEP and *VALP.  */
 267 int
 268 target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
 269                   gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 270 {
 271   struct target_ops *t;
 272
 273   for (t = ops; t != NULL; t = t->beneath)
 274     if (t->to_auxv_parse != NULL)
 275       return t->to_auxv_parse (t, readptr, endptr, typep, valp);
 276
 277   return default_auxv_parse (ops, readptr, endptr, typep, valp);
 278 }
 279
 280 /* Extract the auxiliary vector entry with a_type matching MATCH.
 281    Return zero if no such entry was found, or -1 if there was
 282    an error getting the information.  On success, return 1 after
 283    storing the entry's value field in *VALP.  */
 284 int
 285 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
 286 {
 287   CORE_ADDR type, val;
 288   gdb_byte *data;
 289   LONGEST n = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, &data);
 290   gdb_byte *ptr = data;
 291
 292   if (n <= 0)
 293     return n;
 294
 295   while (1)
 296     switch (target_auxv_parse (ops, &ptr, data + n, &type, &val))
 297       {
 298       case 1:                   /* Here's an entry, check it.  */
 299         if (type == match)
 300           {
 301             xfree (data);
 302             *valp = val;
 303             return 1;
 304           }
 305         break;
 306       case 0:                   /* End of the vector.  */
 307         xfree (data);
 308         return 0;
 309       default:                  /* Bogosity.  */
 310         xfree (data);
 311         return -1;
 312       }
 313
 314   /*NOTREACHED*/
 315 }
 316
 317
 318 /* Print the contents of the target's AUXV on the specified file.  */
 319 int
 320 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
 321 {
 322   CORE_ADDR type, val;
 323   gdb_byte *data;
 324   LONGEST len = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL,
 325                                    &data);
 326   gdb_byte *ptr = data;
 327   int ents = 0;
 328
 329   if (len <= 0)
 330     return len;
 331
 332   while (target_auxv_parse (ops, &ptr, data + len, &type, &val) > 0)
 333     {
 334       const char *name = "???";
 335       const char *description = "";
 336       enum { dec, hex, str } flavor = hex;
 337
 338       switch (type)
 339         {
 340 #define TAG(tag, text, kind) \
 341         case tag: name = #tag; description = text; flavor = kind; break
 342           TAG (AT_NULL, _("End of vector"), hex);
 343           TAG (AT_IGNORE, _("Entry should be ignored"), hex);
 344           TAG (AT_EXECFD, _("File descriptor of program"), dec);
 345           TAG (AT_PHDR, _("Program headers for program"), hex);
 346           TAG (AT_PHENT, _("Size of program header entry"), dec);
 347           TAG (AT_PHNUM, _("Number of program headers"), dec);
 348           TAG (AT_PAGESZ, _("System page size"), dec);
 349           TAG (AT_BASE, _("Base address of interpreter"), hex);
 350           TAG (AT_FLAGS, _("Flags"), hex);
 351           TAG (AT_ENTRY, _("Entry point of program"), hex);
 352           TAG (AT_NOTELF, _("Program is not ELF"), dec);
 353           TAG (AT_UID, _("Real user ID"), dec);
 354           TAG (AT_EUID, _("Effective user ID"), dec);
 355           TAG (AT_GID, _("Real group ID"), dec);
 356           TAG (AT_EGID, _("Effective group ID"), dec);
 357           TAG (AT_CLKTCK, _("Frequency of times()"), dec);
 358           TAG (AT_PLATFORM, _("String identifying platform"), str);
 359           TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
 360           TAG (AT_FPUCW, _("Used FPU control word"), dec);
 361           TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
 362           TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
 363           TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
 364           TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
 365           TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str);
 366           TAG (AT_RANDOM, _("Address of 16 random bytes"), hex);
 367           TAG (AT_EXECFN, _("File name of executable"), str);
 368           TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
 369           TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
 370           TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
 371           TAG (AT_SUN_UID, _("Effective user ID"), dec);
 372           TAG (AT_SUN_RUID, _("Real user ID"), dec);
 373           TAG (AT_SUN_GID, _("Effective group ID"), dec);
 374           TAG (AT_SUN_RGID, _("Real group ID"), dec);
 375           TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
 376           TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
 377           TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
 378           TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
 379           TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
 380           TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
 381           TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
 382           TAG (AT_SUN_CPU, _("CPU name string"), str);
 383           TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
 384           TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
 385           TAG (AT_SUN_EXECNAME,
 386                _("Canonicalized file name given to execve"), str);
 387           TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
 388           TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
 389           TAG (AT_SUN_AUXFLAGS,
 390                _("AF_SUN_ flags passed from the kernel"), hex);
 391         }
 392
 393       fprintf_filtered (file, "%-4s %-20s %-30s ",
 394                         plongest (type), name, description);
 395       switch (flavor)
 396         {
 397         case dec:
 398           fprintf_filtered (file, "%s\n", plongest (val));
 399           break;
 400         case hex:
 401           fprintf_filtered (file, "%s\n", paddress (target_gdbarch, val));
 402           break;
 403         case str:
 404           {
 405             struct value_print_options opts;
 406
 407             get_user_print_options (&opts);
 408             if (opts.addressprint)
 409               fprintf_filtered (file, "%s", paddress (target_gdbarch, val));
 410             val_print_string (builtin_type (target_gdbarch)->builtin_char,
 411                               NULL, val, -1, file, &opts);
 412             fprintf_filtered (file, "\n");
 413           }
 414           break;
 415         }
 416       ++ents;
 417       if (type == AT_NULL)
 418         break;
 419     }
 420
 421   xfree (data);
 422
 423   return ents;
 424 }
 425
 426 static void
 427 info_auxv_command (char *cmd, int from_tty)
 428 {
 429   if (! target_has_stack)
 430     error (_("The program has no auxiliary information now."));
 431   else
 432     {
 433       int ents = fprint_target_auxv (gdb_stdout, &current_target);
 434
 435       if (ents < 0)
 436         error (_("No auxiliary vector found, or failed reading it."));
 437       else if (ents == 0)
 438         error (_("Auxiliary vector is empty."));
 439     }
 440 }
 441
 442
 443 extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
 444
 445 void
 446 _initialize_auxv (void)
 447 {
 448   add_info ("auxv", info_auxv_command,
 449             _("Display the inferior's auxiliary vector.\n\
 450 This is information provided by the operating system at program startup."));
 451 }