1 /* Auxiliary vector support for GDB, the GNU debugger.
3 Copyright (C) 2004-2018 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/>. */
27 #include "observable.h"
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 (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 target_stack->auxv_parse (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. */
306 gdb::optional<gdb::byte_vector> data;
309 /* Handles the cleanup of the auxv cache for inferior INF. ARG is ignored.
310 Frees whatever allocated space there is to be freed and sets INF's auxv cache
311 data pointer to NULL.
313 This function is called when the following events occur: inferior_appeared,
314 inferior_exit and executable_changed. */
317 auxv_inferior_data_cleanup (struct inferior *inf, void *arg)
319 struct auxv_info *info;
321 info = (struct auxv_info *) inferior_data (inf, auxv_inferior_data);
325 set_inferior_data (inf, auxv_inferior_data, NULL);
329 /* Invalidate INF's auxv cache. */
332 invalidate_auxv_cache_inf (struct inferior *inf)
334 auxv_inferior_data_cleanup (inf, NULL);
337 /* Invalidate current inferior's auxv cache. */
340 invalidate_auxv_cache (void)
342 invalidate_auxv_cache_inf (current_inferior ());
345 /* Fetch the auxv object from inferior INF. If auxv is cached already,
346 return a pointer to the cache. If not, fetch the auxv object from the
347 target and cache it. This function always returns a valid INFO pointer. */
349 static struct auxv_info *
350 get_auxv_inferior_data (struct target_ops *ops)
352 struct auxv_info *info;
353 struct inferior *inf = current_inferior ();
355 info = (struct auxv_info *) inferior_data (inf, auxv_inferior_data);
358 info = new auxv_info;
359 info->data = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL);
360 set_inferior_data (inf, auxv_inferior_data, info);
366 /* Extract the auxiliary vector entry with a_type matching MATCH.
367 Return zero if no such entry was found, or -1 if there was
368 an error getting the information. On success, return 1 after
369 storing the entry's value field in *VALP. */
371 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
374 auxv_info *info = get_auxv_inferior_data (ops);
379 gdb_byte *data = info->data->data ();
380 gdb_byte *ptr = data;
381 size_t len = info->data->size ();
384 switch (target_auxv_parse (&ptr, data + len, &type, &val))
386 case 1: /* Here's an entry, check it. */
393 case 0: /* End of the vector. */
395 default: /* Bogosity. */
403 /* Print the description of a single AUXV entry on the specified file. */
406 fprint_auxv_entry (struct ui_file *file, const char *name,
407 const char *description, enum auxv_format format,
408 CORE_ADDR type, CORE_ADDR val)
410 fprintf_filtered (file, ("%-4s %-20s %-30s "),
411 plongest (type), name, description);
414 case AUXV_FORMAT_DEC:
415 fprintf_filtered (file, ("%s\n"), plongest (val));
417 case AUXV_FORMAT_HEX:
418 fprintf_filtered (file, ("%s\n"), paddress (target_gdbarch (), val));
420 case AUXV_FORMAT_STR:
422 struct value_print_options opts;
424 get_user_print_options (&opts);
425 if (opts.addressprint)
426 fprintf_filtered (file, ("%s "), paddress (target_gdbarch (), val));
427 val_print_string (builtin_type (target_gdbarch ())->builtin_char,
428 NULL, val, -1, file, &opts);
429 fprintf_filtered (file, ("\n"));
435 /* The default implementation of gdbarch_print_auxv_entry. */
438 default_print_auxv_entry (struct gdbarch *gdbarch, struct ui_file *file,
439 CORE_ADDR type, CORE_ADDR val)
441 const char *name = "???";
442 const char *description = "";
443 enum auxv_format format = AUXV_FORMAT_HEX;
447 #define TAG(tag, text, kind) \
448 case tag: name = #tag; description = text; format = kind; break
449 TAG (AT_NULL, _("End of vector"), AUXV_FORMAT_HEX);
450 TAG (AT_IGNORE, _("Entry should be ignored"), AUXV_FORMAT_HEX);
451 TAG (AT_EXECFD, _("File descriptor of program"), AUXV_FORMAT_DEC);
452 TAG (AT_PHDR, _("Program headers for program"), AUXV_FORMAT_HEX);
453 TAG (AT_PHENT, _("Size of program header entry"), AUXV_FORMAT_DEC);
454 TAG (AT_PHNUM, _("Number of program headers"), AUXV_FORMAT_DEC);
455 TAG (AT_PAGESZ, _("System page size"), AUXV_FORMAT_DEC);
456 TAG (AT_BASE, _("Base address of interpreter"), AUXV_FORMAT_HEX);
457 TAG (AT_FLAGS, _("Flags"), AUXV_FORMAT_HEX);
458 TAG (AT_ENTRY, _("Entry point of program"), AUXV_FORMAT_HEX);
459 TAG (AT_NOTELF, _("Program is not ELF"), AUXV_FORMAT_DEC);
460 TAG (AT_UID, _("Real user ID"), AUXV_FORMAT_DEC);
461 TAG (AT_EUID, _("Effective user ID"), AUXV_FORMAT_DEC);
462 TAG (AT_GID, _("Real group ID"), AUXV_FORMAT_DEC);
463 TAG (AT_EGID, _("Effective group ID"), AUXV_FORMAT_DEC);
464 TAG (AT_CLKTCK, _("Frequency of times()"), AUXV_FORMAT_DEC);
465 TAG (AT_PLATFORM, _("String identifying platform"), AUXV_FORMAT_STR);
466 TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"),
468 TAG (AT_FPUCW, _("Used FPU control word"), AUXV_FORMAT_DEC);
469 TAG (AT_DCACHEBSIZE, _("Data cache block size"), AUXV_FORMAT_DEC);
470 TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), AUXV_FORMAT_DEC);
471 TAG (AT_UCACHEBSIZE, _("Unified cache block size"), AUXV_FORMAT_DEC);
472 TAG (AT_IGNOREPPC, _("Entry should be ignored"), AUXV_FORMAT_DEC);
473 TAG (AT_BASE_PLATFORM, _("String identifying base platform"),
475 TAG (AT_RANDOM, _("Address of 16 random bytes"), AUXV_FORMAT_HEX);
476 TAG (AT_HWCAP2, _("Extension of AT_HWCAP"), AUXV_FORMAT_HEX);
477 TAG (AT_EXECFN, _("File name of executable"), AUXV_FORMAT_STR);
478 TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), AUXV_FORMAT_DEC);
479 TAG (AT_SYSINFO, _("Special system info/entry points"), AUXV_FORMAT_HEX);
480 TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"),
482 TAG (AT_L1I_CACHESHAPE, _("L1 Instruction cache information"),
484 TAG (AT_L1D_CACHESHAPE, _("L1 Data cache information"), AUXV_FORMAT_HEX);
485 TAG (AT_L2_CACHESHAPE, _("L2 cache information"), AUXV_FORMAT_HEX);
486 TAG (AT_L3_CACHESHAPE, _("L3 cache information"), AUXV_FORMAT_HEX);
487 TAG (AT_SUN_UID, _("Effective user ID"), AUXV_FORMAT_DEC);
488 TAG (AT_SUN_RUID, _("Real user ID"), AUXV_FORMAT_DEC);
489 TAG (AT_SUN_GID, _("Effective group ID"), AUXV_FORMAT_DEC);
490 TAG (AT_SUN_RGID, _("Real group ID"), AUXV_FORMAT_DEC);
491 TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), AUXV_FORMAT_HEX);
492 TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"),
494 TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"),
496 TAG (AT_SUN_LPAGESZ, _("Large pagesize"), AUXV_FORMAT_DEC);
497 TAG (AT_SUN_PLATFORM, _("Platform name string"), AUXV_FORMAT_STR);
498 TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"),
500 TAG (AT_SUN_IFLUSH, _("Should flush icache?"), AUXV_FORMAT_DEC);
501 TAG (AT_SUN_CPU, _("CPU name string"), AUXV_FORMAT_STR);
502 TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), AUXV_FORMAT_HEX);
503 TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"),
505 TAG (AT_SUN_EXECNAME,
506 _("Canonicalized file name given to execve"), AUXV_FORMAT_STR);
507 TAG (AT_SUN_MMU, _("String for name of MMU module"), AUXV_FORMAT_STR);
508 TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"),
510 TAG (AT_SUN_AUXFLAGS,
511 _("AF_SUN_ flags passed from the kernel"), AUXV_FORMAT_HEX);
514 fprint_auxv_entry (file, name, description, format, type, val);
517 /* Print the contents of the target's AUXV on the specified file. */
520 fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
522 struct gdbarch *gdbarch = target_gdbarch ();
525 auxv_info *info = get_auxv_inferior_data (ops);
530 gdb_byte *data = info->data->data ();
531 gdb_byte *ptr = data;
532 size_t len = info->data->size ();
534 while (target_auxv_parse (&ptr, data + len, &type, &val) > 0)
536 gdbarch_print_auxv_entry (gdbarch, file, type, val);
546 info_auxv_command (const char *cmd, int from_tty)
548 if (! target_has_stack)
549 error (_("The program has no auxiliary information now."));
552 int ents = fprint_target_auxv (gdb_stdout, target_stack);
555 error (_("No auxiliary vector found, or failed reading it."));
557 error (_("Auxiliary vector is empty."));
562 _initialize_auxv (void)
564 add_info ("auxv", info_auxv_command,
565 _("Display the inferior's auxiliary vector.\n\
566 This is information provided by the operating system at program startup."));
568 /* Set an auxv cache per-inferior. */
570 = register_inferior_data_with_cleanup (NULL, auxv_inferior_data_cleanup);
572 /* Observers used to invalidate the auxv cache when needed. */
573 gdb::observers::inferior_exit.attach (invalidate_auxv_cache_inf);
574 gdb::observers::inferior_appeared.attach (invalidate_auxv_cache_inf);
575 gdb::observers::executable_changed.attach (invalidate_auxv_cache);