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"
33 #include "elf/common.h"
39 /* Implement the to_xfer_partial target_ops method. This function
40 handles access via /proc/PID/auxv, which is a common method for
43 static enum target_xfer_status
44 procfs_xfer_auxv (gdb_byte
*readbuf
,
45 const gdb_byte
*writebuf
,
54 pathname
= xstrprintf ("/proc/%d/auxv", ptid_get_pid (inferior_ptid
));
55 fd
= gdb_open_cloexec (pathname
, writebuf
!= NULL
? O_WRONLY
: O_RDONLY
, 0);
58 return TARGET_XFER_E_IO
;
60 if (offset
!= (ULONGEST
) 0
61 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
63 else if (readbuf
!= NULL
)
64 l
= read (fd
, readbuf
, (size_t) len
);
66 l
= write (fd
, writebuf
, (size_t) len
);
71 return TARGET_XFER_E_IO
;
73 return TARGET_XFER_EOF
;
76 *xfered_len
= (ULONGEST
) l
;
77 return TARGET_XFER_OK
;
81 /* This function handles access via ld.so's symbol `_dl_auxv'. */
83 static enum target_xfer_status
84 ld_so_xfer_auxv (gdb_byte
*readbuf
,
85 const gdb_byte
*writebuf
,
87 ULONGEST len
, ULONGEST
*xfered_len
)
89 struct bound_minimal_symbol msym
;
90 CORE_ADDR data_address
, pointer_address
;
91 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
92 size_t ptr_size
= TYPE_LENGTH (ptr_type
);
93 size_t auxv_pair_size
= 2 * ptr_size
;
94 gdb_byte
*ptr_buf
= alloca (ptr_size
);
98 msym
= lookup_minimal_symbol ("_dl_auxv", NULL
, NULL
);
99 if (msym
.minsym
== NULL
)
100 return TARGET_XFER_E_IO
;
102 if (MSYMBOL_SIZE (msym
.minsym
) != ptr_size
)
103 return TARGET_XFER_E_IO
;
105 /* POINTER_ADDRESS is a location where the `_dl_auxv' variable
106 resides. DATA_ADDRESS is the inferior value present in
107 `_dl_auxv', therefore the real inferior AUXV address. */
109 pointer_address
= BMSYMBOL_VALUE_ADDRESS (msym
);
111 /* The location of the _dl_auxv symbol may no longer be correct if
112 ld.so runs at a different address than the one present in the
113 file. This is very common case - for unprelinked ld.so or with a
114 PIE executable. PIE executable forces random address even for
115 libraries already being prelinked to some address. PIE
116 executables themselves are never prelinked even on prelinked
117 systems. Prelinking of a PIE executable would block their
118 purpose of randomizing load of everything including the
121 If the memory read fails, return -1 to fallback on another
122 mechanism for retrieving the AUXV.
124 In most cases of a PIE running under valgrind there is no way to
125 find out the base addresses of any of ld.so, executable or AUXV
126 as everything is randomized and /proc information is not relevant
127 for the virtual executable running under valgrind. We think that
128 we might need a valgrind extension to make it work. This is PR
131 if (target_read_memory (pointer_address
, ptr_buf
, ptr_size
) != 0)
132 return TARGET_XFER_E_IO
;
134 data_address
= extract_typed_address (ptr_buf
, ptr_type
);
136 /* Possibly still not initialized such as during an inferior
138 if (data_address
== 0)
139 return TARGET_XFER_E_IO
;
141 data_address
+= offset
;
143 if (writebuf
!= NULL
)
145 if (target_write_memory (data_address
, writebuf
, len
) == 0)
147 *xfered_len
= (ULONGEST
) len
;
148 return TARGET_XFER_OK
;
151 return TARGET_XFER_E_IO
;
154 /* Stop if trying to read past the existing AUXV block. The final
155 AT_NULL was already returned before. */
157 if (offset
>= auxv_pair_size
)
159 if (target_read_memory (data_address
- auxv_pair_size
, ptr_buf
,
161 return TARGET_XFER_E_IO
;
163 if (extract_typed_address (ptr_buf
, ptr_type
) == AT_NULL
)
164 return TARGET_XFER_EOF
;
169 gdb_assert (block
% auxv_pair_size
== 0);
176 /* Reading sizes smaller than AUXV_PAIR_SIZE is not supported.
177 Tails unaligned to AUXV_PAIR_SIZE will not be read during a
178 call (they should be completed during next read with
179 new/extended buffer). */
181 block
&= -auxv_pair_size
;
185 if (target_read_memory (data_address
, readbuf
, block
) != 0)
187 if (block
<= auxv_pair_size
)
190 block
= auxv_pair_size
;
194 data_address
+= block
;
197 /* Check terminal AT_NULL. This function is being called
198 indefinitely being extended its READBUF until it returns EOF
201 while (block
>= auxv_pair_size
)
203 retval
+= auxv_pair_size
;
205 if (extract_typed_address (readbuf
, ptr_type
) == AT_NULL
)
207 *xfered_len
= (ULONGEST
) retval
;
208 return TARGET_XFER_OK
;
211 readbuf
+= auxv_pair_size
;
212 block
-= auxv_pair_size
;
216 *xfered_len
= (ULONGEST
) retval
;
217 return TARGET_XFER_OK
;
220 /* Implement the to_xfer_partial target_ops method for
221 TARGET_OBJECT_AUXV. It handles access to AUXV. */
223 enum target_xfer_status
224 memory_xfer_auxv (struct target_ops
*ops
,
225 enum target_object object
,
228 const gdb_byte
*writebuf
,
230 ULONGEST len
, ULONGEST
*xfered_len
)
232 gdb_assert (object
== TARGET_OBJECT_AUXV
);
233 gdb_assert (readbuf
|| writebuf
);
235 /* ld_so_xfer_auxv is the only function safe for virtual
236 executables being executed by valgrind's memcheck. Using
237 ld_so_xfer_auxv during inferior startup is problematic, because
238 ld.so symbol tables have not yet been relocated. So GDB uses
239 this function only when attaching to a process.
242 if (current_inferior ()->attach_flag
!= 0)
244 enum target_xfer_status ret
;
246 ret
= ld_so_xfer_auxv (readbuf
, writebuf
, offset
, len
, xfered_len
);
247 if (ret
!= TARGET_XFER_E_IO
)
251 return procfs_xfer_auxv (readbuf
, writebuf
, offset
, len
, xfered_len
);
254 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
255 Return 0 if *READPTR is already at the end of the buffer.
256 Return -1 if there is insufficient buffer for a whole entry.
257 Return 1 if an entry was read into *TYPEP and *VALP. */
259 default_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
260 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
262 const int sizeof_auxv_field
= gdbarch_ptr_bit (target_gdbarch ())
264 const enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
265 gdb_byte
*ptr
= *readptr
;
270 if (endptr
- ptr
< sizeof_auxv_field
* 2)
273 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
274 ptr
+= sizeof_auxv_field
;
275 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
276 ptr
+= sizeof_auxv_field
;
282 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
283 Return 0 if *READPTR is already at the end of the buffer.
284 Return -1 if there is insufficient buffer for a whole entry.
285 Return 1 if an entry was read into *TYPEP and *VALP. */
287 target_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
288 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
290 return current_target
.to_auxv_parse (¤t_target
, readptr
, endptr
,
295 /* Per-inferior data key for auxv. */
296 static const struct inferior_data
*auxv_inferior_data
;
298 /* Auxiliary Vector information structure. This is used by GDB
299 for caching purposes for each inferior. This helps reduce the
300 overhead of transfering data from a remote target to the local host. */
307 /* Handles the cleanup of the auxv cache for inferior INF. ARG is ignored.
308 Frees whatever allocated space there is to be freed and sets INF's auxv cache
309 data pointer to NULL.
311 This function is called when the following events occur: inferior_appeared,
312 inferior_exit and executable_changed. */
315 auxv_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
317 struct auxv_info
*info
;
319 info
= inferior_data (inf
, auxv_inferior_data
);
324 set_inferior_data (inf
, auxv_inferior_data
, NULL
);
328 /* Invalidate INF's auxv cache. */
331 invalidate_auxv_cache_inf (struct inferior
*inf
)
333 auxv_inferior_data_cleanup (inf
, NULL
);
336 /* Invalidate current inferior's auxv cache. */
339 invalidate_auxv_cache (void)
341 invalidate_auxv_cache_inf (current_inferior ());
344 /* Fetch the auxv object from inferior INF. If auxv is cached already,
345 return a pointer to the cache. If not, fetch the auxv object from the
346 target and cache it. This function always returns a valid INFO pointer. */
348 static struct auxv_info
*
349 get_auxv_inferior_data (struct target_ops
*ops
)
351 struct auxv_info
*info
;
352 struct inferior
*inf
= current_inferior ();
354 info
= inferior_data (inf
, auxv_inferior_data
);
357 info
= XCNEW (struct auxv_info
);
358 info
->length
= target_read_alloc (ops
, TARGET_OBJECT_AUXV
,
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
)
376 struct auxv_info
*info
;
378 info
= get_auxv_inferior_data (ops
);
383 if (info
->length
<= 0)
387 switch (target_auxv_parse (ops
, &ptr
, data
+ info
->length
, &type
, &val
))
389 case 1: /* Here's an entry, check it. */
396 case 0: /* End of the vector. */
398 default: /* Bogosity. */
406 /* Print the contents of the target's AUXV on the specified file. */
408 fprint_target_auxv (struct ui_file
*file
, struct target_ops
*ops
)
413 struct auxv_info
*info
;
416 info
= get_auxv_inferior_data (ops
);
420 if (info
->length
<= 0)
423 while (target_auxv_parse (ops
, &ptr
, data
+ info
->length
, &type
, &val
) > 0)
425 const char *name
= "???";
426 const char *description
= "";
427 enum { dec
, hex
, str
} flavor
= hex
;
431 #define TAG(tag, text, kind) \
432 case tag: name = #tag; description = text; flavor = kind; break
433 TAG (AT_NULL
, _("End of vector"), hex
);
434 TAG (AT_IGNORE
, _("Entry should be ignored"), hex
);
435 TAG (AT_EXECFD
, _("File descriptor of program"), dec
);
436 TAG (AT_PHDR
, _("Program headers for program"), hex
);
437 TAG (AT_PHENT
, _("Size of program header entry"), dec
);
438 TAG (AT_PHNUM
, _("Number of program headers"), dec
);
439 TAG (AT_PAGESZ
, _("System page size"), dec
);
440 TAG (AT_BASE
, _("Base address of interpreter"), hex
);
441 TAG (AT_FLAGS
, _("Flags"), hex
);
442 TAG (AT_ENTRY
, _("Entry point of program"), hex
);
443 TAG (AT_NOTELF
, _("Program is not ELF"), dec
);
444 TAG (AT_UID
, _("Real user ID"), dec
);
445 TAG (AT_EUID
, _("Effective user ID"), dec
);
446 TAG (AT_GID
, _("Real group ID"), dec
);
447 TAG (AT_EGID
, _("Effective group ID"), dec
);
448 TAG (AT_CLKTCK
, _("Frequency of times()"), dec
);
449 TAG (AT_PLATFORM
, _("String identifying platform"), str
);
450 TAG (AT_HWCAP
, _("Machine-dependent CPU capability hints"), hex
);
451 TAG (AT_FPUCW
, _("Used FPU control word"), dec
);
452 TAG (AT_DCACHEBSIZE
, _("Data cache block size"), dec
);
453 TAG (AT_ICACHEBSIZE
, _("Instruction cache block size"), dec
);
454 TAG (AT_UCACHEBSIZE
, _("Unified cache block size"), dec
);
455 TAG (AT_IGNOREPPC
, _("Entry should be ignored"), dec
);
456 TAG (AT_BASE_PLATFORM
, _("String identifying base platform"), str
);
457 TAG (AT_RANDOM
, _("Address of 16 random bytes"), hex
);
458 TAG (AT_HWCAP2
, _("Extension of AT_HWCAP"), hex
);
459 TAG (AT_EXECFN
, _("File name of executable"), str
);
460 TAG (AT_SECURE
, _("Boolean, was exec setuid-like?"), dec
);
461 TAG (AT_SYSINFO
, _("Special system info/entry points"), hex
);
462 TAG (AT_SYSINFO_EHDR
, _("System-supplied DSO's ELF header"), hex
);
463 TAG (AT_L1I_CACHESHAPE
, _("L1 Instruction cache information"), hex
);
464 TAG (AT_L1D_CACHESHAPE
, _("L1 Data cache information"), hex
);
465 TAG (AT_L2_CACHESHAPE
, _("L2 cache information"), hex
);
466 TAG (AT_L3_CACHESHAPE
, _("L3 cache information"), hex
);
467 TAG (AT_SUN_UID
, _("Effective user ID"), dec
);
468 TAG (AT_SUN_RUID
, _("Real user ID"), dec
);
469 TAG (AT_SUN_GID
, _("Effective group ID"), dec
);
470 TAG (AT_SUN_RGID
, _("Real group ID"), dec
);
471 TAG (AT_SUN_LDELF
, _("Dynamic linker's ELF header"), hex
);
472 TAG (AT_SUN_LDSHDR
, _("Dynamic linker's section headers"), hex
);
473 TAG (AT_SUN_LDNAME
, _("String giving name of dynamic linker"), str
);
474 TAG (AT_SUN_LPAGESZ
, _("Large pagesize"), dec
);
475 TAG (AT_SUN_PLATFORM
, _("Platform name string"), str
);
476 TAG (AT_SUN_HWCAP
, _("Machine-dependent CPU capability hints"), hex
);
477 TAG (AT_SUN_IFLUSH
, _("Should flush icache?"), dec
);
478 TAG (AT_SUN_CPU
, _("CPU name string"), str
);
479 TAG (AT_SUN_EMUL_ENTRY
, _("COFF entry point address"), hex
);
480 TAG (AT_SUN_EMUL_EXECFD
, _("COFF executable file descriptor"), dec
);
481 TAG (AT_SUN_EXECNAME
,
482 _("Canonicalized file name given to execve"), str
);
483 TAG (AT_SUN_MMU
, _("String for name of MMU module"), str
);
484 TAG (AT_SUN_LDDATA
, _("Dynamic linker's data segment address"), hex
);
485 TAG (AT_SUN_AUXFLAGS
,
486 _("AF_SUN_ flags passed from the kernel"), hex
);
489 fprintf_filtered (file
, "%-4s %-20s %-30s ",
490 plongest (type
), name
, description
);
494 fprintf_filtered (file
, "%s\n", plongest (val
));
497 fprintf_filtered (file
, "%s\n", paddress (target_gdbarch (), val
));
501 struct value_print_options opts
;
503 get_user_print_options (&opts
);
504 if (opts
.addressprint
)
505 fprintf_filtered (file
, "%s ", paddress (target_gdbarch (), val
));
506 val_print_string (builtin_type (target_gdbarch ())->builtin_char
,
507 NULL
, val
, -1, file
, &opts
);
508 fprintf_filtered (file
, "\n");
521 info_auxv_command (char *cmd
, int from_tty
)
523 if (! target_has_stack
)
524 error (_("The program has no auxiliary information now."));
527 int ents
= fprint_target_auxv (gdb_stdout
, ¤t_target
);
530 error (_("No auxiliary vector found, or failed reading it."));
532 error (_("Auxiliary vector is empty."));
537 extern initialize_file_ftype _initialize_auxv
; /* -Wmissing-prototypes; */
540 _initialize_auxv (void)
542 add_info ("auxv", info_auxv_command
,
543 _("Display the inferior's auxiliary vector.\n\
544 This is information provided by the operating system at program startup."));
546 /* Set an auxv cache per-inferior. */
548 = register_inferior_data_with_cleanup (NULL
, auxv_inferior_data_cleanup
);
550 /* Observers used to invalidate the auxv cache when needed. */
551 observer_attach_inferior_exit (invalidate_auxv_cache_inf
);
552 observer_attach_inferior_appeared (invalidate_auxv_cache_inf
);
553 observer_attach_executable_changed (invalidate_auxv_cache
);