gdb/auxv.c

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