1 /* Auxiliary vector support for GDB, the GNU debugger.
3 Copyright (C) 2004-2015 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/>. */
28 #include "filestuff.h"
32 #include "elf/common.h"
38 /* Implement the to_xfer_partial target_ops method. This function
39 handles access via /proc/PID/auxv, which is a common method for
42 static enum target_xfer_status
43 procfs_xfer_auxv (gdb_byte *readbuf,
44 const gdb_byte *writebuf,
53 pathname = xstrprintf ("/proc/%d/auxv", ptid_get_pid (inferior_ptid));
54 fd = gdb_open_cloexec (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY, 0);
57 return TARGET_XFER_E_IO;
59 if (offset != (ULONGEST) 0
60 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
62 else if (readbuf != NULL)
63 l = read (fd, readbuf, (size_t) len);
65 l = write (fd, writebuf, (size_t) len);
70 return TARGET_XFER_E_IO;
72 return TARGET_XFER_EOF;
75 *xfered_len = (ULONGEST) l;
76 return TARGET_XFER_OK;
80 /* This function handles access via ld.so's symbol `_dl_auxv'. */
82 static enum target_xfer_status
83 ld_so_xfer_auxv (gdb_byte *readbuf,
84 const gdb_byte *writebuf,
86 ULONGEST len, ULONGEST *xfered_len)
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 = (gdb_byte *) alloca (ptr_size);
97 msym = lookup_minimal_symbol ("_dl_auxv", NULL, NULL);
98 if (msym.minsym == NULL)
99 return TARGET_XFER_E_IO;
101 if (MSYMBOL_SIZE (msym.minsym) != ptr_size)
102 return TARGET_XFER_E_IO;
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. */
108 pointer_address = BMSYMBOL_VALUE_ADDRESS (msym);
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
120 If the memory read fails, return -1 to fallback on another
121 mechanism for retrieving the AUXV.
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
130 if (target_read_memory (pointer_address, ptr_buf, ptr_size) != 0)
131 return TARGET_XFER_E_IO;
133 data_address = extract_typed_address (ptr_buf, ptr_type);
135 /* Possibly still not initialized such as during an inferior
137 if (data_address == 0)
138 return TARGET_XFER_E_IO;
140 data_address += offset;
142 if (writebuf != NULL)
144 if (target_write_memory (data_address, writebuf, len) == 0)
146 *xfered_len = (ULONGEST) len;
147 return TARGET_XFER_OK;
150 return TARGET_XFER_E_IO;
153 /* Stop if trying to read past the existing AUXV block. The final
154 AT_NULL was already returned before. */
156 if (offset >= auxv_pair_size)
158 if (target_read_memory (data_address - auxv_pair_size, ptr_buf,
160 return TARGET_XFER_E_IO;
162 if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
163 return TARGET_XFER_EOF;
168 gdb_assert (block % auxv_pair_size == 0);
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). */
180 block &= -auxv_pair_size;
184 if (target_read_memory (data_address, readbuf, block) != 0)
186 if (block <= auxv_pair_size)
189 block = auxv_pair_size;
193 data_address += block;
196 /* Check terminal AT_NULL. This function is being called
197 indefinitely being extended its READBUF until it returns EOF
200 while (block >= auxv_pair_size)
202 retval += auxv_pair_size;
204 if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
206 *xfered_len = (ULONGEST) retval;
207 return TARGET_XFER_OK;
210 readbuf += auxv_pair_size;
211 block -= auxv_pair_size;
215 *xfered_len = (ULONGEST) retval;
216 return TARGET_XFER_OK;
219 /* Implement the to_xfer_partial target_ops method for
220 TARGET_OBJECT_AUXV. It handles access to AUXV. */
222 enum target_xfer_status
223 memory_xfer_auxv (struct target_ops *ops,
224 enum target_object object,
227 const gdb_byte *writebuf,
229 ULONGEST len, ULONGEST *xfered_len)
231 gdb_assert (object == TARGET_OBJECT_AUXV);
232 gdb_assert (readbuf || writebuf);
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.
241 if (current_inferior ()->attach_flag != 0)
243 enum target_xfer_status ret;
245 ret = ld_so_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
246 if (ret != TARGET_XFER_E_IO)
250 return procfs_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
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. */
258 default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
259 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
261 const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch ())
263 const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
264 gdb_byte *ptr = *readptr;
269 if (endptr - ptr < sizeof_auxv_field * 2)
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;
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. */
286 target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
287 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
289 struct gdbarch *gdbarch = target_gdbarch();
291 if (gdbarch_auxv_parse_p (gdbarch))
292 return gdbarch_auxv_parse (gdbarch, readptr, endptr, typep, valp);
294 return current_target.to_auxv_parse (¤t_target, readptr, endptr,
299 /* Per-inferior data key for auxv. */
300 static const struct inferior_data *auxv_inferior_data;
302 /* Auxiliary Vector information structure. This is used by GDB
303 for caching purposes for each inferior. This helps reduce the
304 overhead of transfering data from a remote target to the local host. */
311 /* Handles the cleanup of the auxv cache for inferior INF. ARG is ignored.
312 Frees whatever allocated space there is to be freed and sets INF's auxv cache
313 data pointer to NULL.
315 This function is called when the following events occur: inferior_appeared,
316 inferior_exit and executable_changed. */
319 auxv_inferior_data_cleanup (struct inferior *inf, void *arg)
321 struct auxv_info *info;
323 info = inferior_data (inf, auxv_inferior_data);
328 set_inferior_data (inf, auxv_inferior_data, NULL);
332 /* Invalidate INF's auxv cache. */
335 invalidate_auxv_cache_inf (struct inferior *inf)
337 auxv_inferior_data_cleanup (inf, NULL);
340 /* Invalidate current inferior's auxv cache. */
343 invalidate_auxv_cache (void)
345 invalidate_auxv_cache_inf (current_inferior ());
348 /* Fetch the auxv object from inferior INF. If auxv is cached already,
349 return a pointer to the cache. If not, fetch the auxv object from the
350 target and cache it. This function always returns a valid INFO pointer. */
352 static struct auxv_info *
353 get_auxv_inferior_data (struct target_ops *ops)
355 struct auxv_info *info;
356 struct inferior *inf = current_inferior ();
358 info = inferior_data (inf, auxv_inferior_data);
361 info = XCNEW (struct auxv_info);
362 info->length = target_read_alloc (ops, TARGET_OBJECT_AUXV,
364 set_inferior_data (inf, auxv_inferior_data, info);
370 /* Extract the auxiliary vector entry with a_type matching MATCH.
371 Return zero if no such entry was found, or -1 if there was
372 an error getting the information. On success, return 1 after
373 storing the entry's value field in *VALP. */
375 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
380 struct auxv_info *info;
382 info = get_auxv_inferior_data (ops);
387 if (info->length <= 0)
391 switch (target_auxv_parse (ops, &ptr, data + info->length, &type, &val))
393 case 1: /* Here's an entry, check it. */
400 case 0: /* End of the vector. */
402 default: /* Bogosity. */
410 /* Print the contents of the target's AUXV on the specified file. */
412 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
417 struct auxv_info *info;
420 info = get_auxv_inferior_data (ops);
424 if (info->length <= 0)
427 while (target_auxv_parse (ops, &ptr, data + info->length, &type, &val) > 0)
429 const char *name = "???";
430 const char *description = "";
431 enum { dec, hex, str } flavor = hex;
435 #define TAG(tag, text, kind) \
436 case tag: name = #tag; description = text; flavor = kind; break
437 TAG (AT_NULL, _("End of vector"), hex);
438 TAG (AT_IGNORE, _("Entry should be ignored"), hex);
439 TAG (AT_EXECFD, _("File descriptor of program"), dec);
440 TAG (AT_PHDR, _("Program headers for program"), hex);
441 TAG (AT_PHENT, _("Size of program header entry"), dec);
442 TAG (AT_PHNUM, _("Number of program headers"), dec);
443 TAG (AT_PAGESZ, _("System page size"), dec);
444 TAG (AT_BASE, _("Base address of interpreter"), hex);
445 TAG (AT_FLAGS, _("Flags"), hex);
446 TAG (AT_ENTRY, _("Entry point of program"), hex);
447 TAG (AT_NOTELF, _("Program is not ELF"), dec);
448 TAG (AT_UID, _("Real user ID"), dec);
449 TAG (AT_EUID, _("Effective user ID"), dec);
450 TAG (AT_GID, _("Real group ID"), dec);
451 TAG (AT_EGID, _("Effective group ID"), dec);
452 TAG (AT_CLKTCK, _("Frequency of times()"), dec);
453 TAG (AT_PLATFORM, _("String identifying platform"), str);
454 TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
455 TAG (AT_FPUCW, _("Used FPU control word"), dec);
456 TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
457 TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
458 TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
459 TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
460 TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str);
461 TAG (AT_RANDOM, _("Address of 16 random bytes"), hex);
462 TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), hex);
463 TAG (AT_EXECFN, _("File name of executable"), str);
464 TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
465 TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
466 TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
467 TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"), hex);
468 TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), hex);
469 TAG (AT_L2_CACHESHAPE, _("L2 cache information"), hex);
470 TAG (AT_L3_CACHESHAPE, _("L3 cache information"), hex);
471 TAG (AT_SUN_UID, _("Effective user ID"), dec);
472 TAG (AT_SUN_RUID, _("Real user ID"), dec);
473 TAG (AT_SUN_GID, _("Effective group ID"), dec);
474 TAG (AT_SUN_RGID, _("Real group ID"), dec);
475 TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
476 TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
477 TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
478 TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
479 TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
480 TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
481 TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
482 TAG (AT_SUN_CPU, _("CPU name string"), str);
483 TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
484 TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
485 TAG (AT_SUN_EXECNAME,
486 _("Canonicalized file name given to execve"), str);
487 TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
488 TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
489 TAG (AT_SUN_AUXFLAGS,
490 _("AF_SUN_ flags passed from the kernel"), hex);
493 fprintf_filtered (file, "%-4s %-20s %-30s ",
494 plongest (type), name, description);
498 fprintf_filtered (file, "%s\n", plongest (val));
501 fprintf_filtered (file, "%s\n", paddress (target_gdbarch (), val));
505 struct value_print_options opts;
507 get_user_print_options (&opts);
508 if (opts.addressprint)
509 fprintf_filtered (file, "%s ", paddress (target_gdbarch (), val));
510 val_print_string (builtin_type (target_gdbarch ())->builtin_char,
511 NULL, val, -1, file, &opts);
512 fprintf_filtered (file, "\n");
525 info_auxv_command (char *cmd, int from_tty)
527 if (! target_has_stack)
528 error (_("The program has no auxiliary information now."));
531 int ents = fprint_target_auxv (gdb_stdout, ¤t_target);
534 error (_("No auxiliary vector found, or failed reading it."));
536 error (_("Auxiliary vector is empty."));
541 extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
544 _initialize_auxv (void)
546 add_info ("auxv", info_auxv_command,
547 _("Display the inferior's auxiliary vector.\n\
548 This is information provided by the operating system at program startup."));
550 /* Set an auxv cache per-inferior. */
552 = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
554 /* Observers used to invalidate the auxv cache when needed. */
555 observer_attach_inferior_exit (invalidate_auxv_cache_inf);
556 observer_attach_inferior_appeared (invalidate_auxv_cache_inf);
557 observer_attach_executable_changed (invalidate_auxv_cache);