1 /* Auxiliary vector support for GDB, the GNU debugger. 2 3 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "target.h" 23 #include "gdbtypes.h" 24 #include "command.h" 25 #include "inferior.h" 26 #include "valprint.h" 27 #include "gdb_assert.h" 28 #include "gdbcore.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 /* Extract the auxiliary vector entry with a_type matching MATCH. 281 Return zero if no such entry was found, or -1 if there was 282 an error getting the information. On success, return 1 after 283 storing the entry's value field in *VALP. */ 284 int 285 target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp) 286 { 287 CORE_ADDR type, val; 288 gdb_byte *data; 289 LONGEST n = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, &data); 290 gdb_byte *ptr = data; 291 292 if (n <= 0) 293 return n; 294 295 while (1) 296 switch (target_auxv_parse (ops, &ptr, data + n, &type, &val)) 297 { 298 case 1: /* Here's an entry, check it. */ 299 if (type == match) 300 { 301 xfree (data); 302 *valp = val; 303 return 1; 304 } 305 break; 306 case 0: /* End of the vector. */ 307 xfree (data); 308 return 0; 309 default: /* Bogosity. */ 310 xfree (data); 311 return -1; 312 } 313 314 /*NOTREACHED*/ 315 } 316 317 318 /* Print the contents of the target's AUXV on the specified file. */ 319 int 320 fprint_target_auxv (struct ui_file *file, struct target_ops *ops) 321 { 322 CORE_ADDR type, val; 323 gdb_byte *data; 324 LONGEST len = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, 325 &data); 326 gdb_byte *ptr = data; 327 int ents = 0; 328 329 if (len <= 0) 330 return len; 331 332 while (target_auxv_parse (ops, &ptr, data + len, &type, &val) > 0) 333 { 334 const char *name = "???"; 335 const char *description = ""; 336 enum { dec, hex, str } flavor = hex; 337 338 switch (type) 339 { 340 #define TAG(tag, text, kind) \ 341 case tag: name = #tag; description = text; flavor = kind; break 342 TAG (AT_NULL, _("End of vector"), hex); 343 TAG (AT_IGNORE, _("Entry should be ignored"), hex); 344 TAG (AT_EXECFD, _("File descriptor of program"), dec); 345 TAG (AT_PHDR, _("Program headers for program"), hex); 346 TAG (AT_PHENT, _("Size of program header entry"), dec); 347 TAG (AT_PHNUM, _("Number of program headers"), dec); 348 TAG (AT_PAGESZ, _("System page size"), dec); 349 TAG (AT_BASE, _("Base address of interpreter"), hex); 350 TAG (AT_FLAGS, _("Flags"), hex); 351 TAG (AT_ENTRY, _("Entry point of program"), hex); 352 TAG (AT_NOTELF, _("Program is not ELF"), dec); 353 TAG (AT_UID, _("Real user ID"), dec); 354 TAG (AT_EUID, _("Effective user ID"), dec); 355 TAG (AT_GID, _("Real group ID"), dec); 356 TAG (AT_EGID, _("Effective group ID"), dec); 357 TAG (AT_CLKTCK, _("Frequency of times()"), dec); 358 TAG (AT_PLATFORM, _("String identifying platform"), str); 359 TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex); 360 TAG (AT_FPUCW, _("Used FPU control word"), dec); 361 TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec); 362 TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec); 363 TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec); 364 TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec); 365 TAG (AT_BASE_PLATFORM, _("String identifying base platform"), str); 366 TAG (AT_RANDOM, _("Address of 16 random bytes"), hex); 367 TAG (AT_EXECFN, _("File name of executable"), str); 368 TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec); 369 TAG (AT_SYSINFO, _("Special system info/entry points"), hex); 370 TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex); 371 TAG (AT_SUN_UID, _("Effective user ID"), dec); 372 TAG (AT_SUN_RUID, _("Real user ID"), dec); 373 TAG (AT_SUN_GID, _("Effective group ID"), dec); 374 TAG (AT_SUN_RGID, _("Real group ID"), dec); 375 TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex); 376 TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex); 377 TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str); 378 TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec); 379 TAG (AT_SUN_PLATFORM, _("Platform name string"), str); 380 TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex); 381 TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec); 382 TAG (AT_SUN_CPU, _("CPU name string"), str); 383 TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex); 384 TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec); 385 TAG (AT_SUN_EXECNAME, 386 _("Canonicalized file name given to execve"), str); 387 TAG (AT_SUN_MMU, _("String for name of MMU module"), str); 388 TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex); 389 TAG (AT_SUN_AUXFLAGS, 390 _("AF_SUN_ flags passed from the kernel"), hex); 391 } 392 393 fprintf_filtered (file, "%-4s %-20s %-30s ", 394 plongest (type), name, description); 395 switch (flavor) 396 { 397 case dec: 398 fprintf_filtered (file, "%s\n", plongest (val)); 399 break; 400 case hex: 401 fprintf_filtered (file, "%s\n", paddress (target_gdbarch, val)); 402 break; 403 case str: 404 { 405 struct value_print_options opts; 406 407 get_user_print_options (&opts); 408 if (opts.addressprint) 409 fprintf_filtered (file, "%s", paddress (target_gdbarch, val)); 410 val_print_string (builtin_type (target_gdbarch)->builtin_char, 411 NULL, val, -1, file, &opts); 412 fprintf_filtered (file, "\n"); 413 } 414 break; 415 } 416 ++ents; 417 if (type == AT_NULL) 418 break; 419 } 420 421 xfree (data); 422 423 return ents; 424 } 425 426 static void 427 info_auxv_command (char *cmd, int from_tty) 428 { 429 if (! target_has_stack) 430 error (_("The program has no auxiliary information now.")); 431 else 432 { 433 int ents = fprint_target_auxv (gdb_stdout, ¤t_target); 434 435 if (ents < 0) 436 error (_("No auxiliary vector found, or failed reading it.")); 437 else if (ents == 0) 438 error (_("Auxiliary vector is empty.")); 439 } 440 } 441 442 443 extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */ 444 445 void 446 _initialize_auxv (void) 447 { 448 add_info ("auxv", info_auxv_command, 449 _("Display the inferior's auxiliary vector.\n\ 450 This is information provided by the operating system at program startup.")); 451 } 452