1 /* Auxiliary vector support for GDB, the GNU debugger.
3 Copyright (C) 2004-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
26 #include "gdb_assert.h"
29 #include "filestuff.h"
32 #include "elf/common.h"
38 /* This function handles access via /proc/PID/auxv, which is a common
39 method for native targets. */
41 static enum target_xfer_status
42 procfs_xfer_auxv (gdb_byte *readbuf,
43 const gdb_byte *writebuf,
52 pathname = xstrprintf ("/proc/%d/auxv", ptid_get_pid (inferior_ptid));
53 fd = gdb_open_cloexec (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY, 0);
56 return TARGET_XFER_E_IO;
58 if (offset != (ULONGEST) 0
59 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
61 else if (readbuf != NULL)
62 l = read (fd, readbuf, (size_t) len);
64 l = write (fd, writebuf, (size_t) len);
69 return TARGET_XFER_E_IO;
71 return TARGET_XFER_EOF;
74 *xfered_len = (ULONGEST) l;
75 return TARGET_XFER_OK;
79 /* This function handles access via ld.so's symbol `_dl_auxv'. */
81 static enum target_xfer_status
82 ld_so_xfer_auxv (gdb_byte *readbuf,
83 const gdb_byte *writebuf,
85 ULONGEST len, ULONGEST *xfered_len)
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);
96 msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
98 return TARGET_XFER_E_IO;
100 if (MSYMBOL_SIZE (msym) != ptr_size)
101 return TARGET_XFER_E_IO;
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. */
107 pointer_address = SYMBOL_VALUE_ADDRESS (msym);
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
119 If the memory read fails, return -1 to fallback on another
120 mechanism for retrieving the AUXV.
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
129 if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
130 return TARGET_XFER_E_IO;
132 data_address = extract_typed_address (ptr_buf, ptr_type);
134 /* Possibly still not initialized such as during an inferior
136 if (data_address == 0)
137 return TARGET_XFER_E_IO;
139 data_address += offset;
141 if (writebuf != NULL)
143 if (target_write_memory (data_address, writebuf, len) == 0)
145 *xfered_len = (ULONGEST) len;
146 return TARGET_XFER_OK;
149 return TARGET_XFER_E_IO;
152 /* Stop if trying to read past the existing AUXV block. The final
153 AT_NULL was already returned before. */
155 if (offset >= auxv_pair_size)
157 if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
159 return TARGET_XFER_E_IO;
161 if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
162 return TARGET_XFER_EOF;
167 gdb_assert (block % auxv_pair_size == 0);
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). */
179 block &= -auxv_pair_size;
183 if (target_read_memory (data_address, readbuf, block) != 0)
185 if (block <= auxv_pair_size)
188 block = auxv_pair_size;
192 data_address += block;
195 /* Check terminal AT_NULL. This function is being called
196 indefinitely being extended its READBUF until it returns EOF
199 while (block >= auxv_pair_size)
201 retval += auxv_pair_size;
203 if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
205 *xfered_len = (ULONGEST) retval;
206 return TARGET_XFER_OK;
209 readbuf += auxv_pair_size;
210 block -= auxv_pair_size;
214 *xfered_len = (ULONGEST) retval;
215 return TARGET_XFER_OK;
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. */
221 enum target_xfer_status
222 memory_xfer_auxv (struct target_ops *ops,
223 enum target_object object,
226 const gdb_byte *writebuf,
228 ULONGEST len, ULONGEST *xfered_len)
230 gdb_assert (object == TARGET_OBJECT_AUXV);
231 gdb_assert (readbuf || writebuf);
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.
240 if (current_inferior ()->attach_flag != 0)
242 enum target_xfer_status ret;
244 ret = ld_so_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
245 if (ret != TARGET_XFER_E_IO)
249 return procfs_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
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. */
257 default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
258 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
260 const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch ())
262 const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
263 gdb_byte *ptr = *readptr;
268 if (endptr - ptr < sizeof_auxv_field * 2)
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;
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. */
285 target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
286 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
288 struct target_ops *t;
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);
294 return default_auxv_parse (ops, readptr, endptr, typep, valp);
298 /* Per-inferior data key for auxv. */
299 static const struct inferior_data *auxv_inferior_data;
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. */
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.
314 This function is called when the following events occur: inferior_appeared,
315 inferior_exit and executable_changed. */
318 auxv_inferior_data_cleanup (struct inferior *inf, void *arg)
320 struct auxv_info *info;
322 info = inferior_data (inf, auxv_inferior_data);
327 set_inferior_data (inf, auxv_inferior_data, NULL);
331 /* Invalidate INF's auxv cache. */
334 invalidate_auxv_cache_inf (struct inferior *inf)
336 auxv_inferior_data_cleanup (inf, NULL);
339 /* Invalidate current inferior's auxv cache. */
342 invalidate_auxv_cache (void)
344 invalidate_auxv_cache_inf (current_inferior ());
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. */
351 static struct auxv_info *
352 get_auxv_inferior_data (struct target_ops *ops)
354 struct auxv_info *info;
355 struct inferior *inf = current_inferior ();
357 info = inferior_data (inf, auxv_inferior_data);
360 info = XCNEW (struct auxv_info);
361 info->length = target_read_alloc (ops, TARGET_OBJECT_AUXV,
363 set_inferior_data (inf, auxv_inferior_data, info);
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. */
374 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
379 struct auxv_info *info;
381 info = get_auxv_inferior_data (ops);
386 if (info->length <= 0)
390 switch (target_auxv_parse (ops, &ptr, data + info->length, &type, &val))
392 case 1: /* Here's an entry, check it. */
399 case 0: /* End of the vector. */
401 default: /* Bogosity. */
409 /* Print the contents of the target's AUXV on the specified file. */
411 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
416 struct auxv_info *info;
419 info = get_auxv_inferior_data (ops);
423 if (info->length <= 0)
426 while (target_auxv_parse (ops, &ptr, data + info->length, &type, &val) > 0)
428 const char *name = "???";
429 const char *description = "";
430 enum { dec, hex, str } flavor = hex;
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);
492 fprintf_filtered (file, "%-4s %-20s %-30s ",
493 plongest (type), name, description);
497 fprintf_filtered (file, "%s\n", plongest (val));
500 fprintf_filtered (file, "%s\n", paddress (target_gdbarch (), val));
504 struct value_print_options opts;
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");
524 info_auxv_command (char *cmd, int from_tty)
526 if (! target_has_stack)
527 error (_("The program has no auxiliary information now."));
530 int ents = fprint_target_auxv (gdb_stdout, ¤t_target);
533 error (_("No auxiliary vector found, or failed reading it."));
535 error (_("Auxiliary vector is empty."));
540 extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
543 _initialize_auxv (void)
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."));
549 /* Set an auxv cache per-inferior. */
551 = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
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);