[deliverable/binutils-gdb.git] / gdb / auxv.c

/* Auxiliary vector support for GDB, the GNU debugger.

   Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "target.h"
#include "gdbtypes.h"
#include "command.h"
#include "inferior.h"
#include "valprint.h"
#include "gdb_assert.h"

#include "auxv.h"
#include "elf/common.h"

#include <unistd.h>
#include <fcntl.h>


/* This function is called like a to_xfer_partial hook,
   but must be called with TARGET_OBJECT_AUXV.
   It handles access via /proc/PID/auxv, which is the common method.
   This function is appropriate for doing:
	   #define NATIVE_XFER_AUXV	procfs_xfer_auxv
   for a native target that uses inftarg.c's child_xfer_partial hook.  */

LONGEST
procfs_xfer_auxv (struct target_ops *ops,
		  int /* enum target_object */ object,
		  const char *annex,
		  gdb_byte *readbuf,
		  const gdb_byte *writebuf,
		  ULONGEST offset,
		  LONGEST len)
{
  char *pathname;
  int fd;
  LONGEST n;

  gdb_assert (object == TARGET_OBJECT_AUXV);
  gdb_assert (readbuf || writebuf);

  pathname = xstrprintf ("/proc/%d/auxv", PIDGET (inferior_ptid));
  fd = open (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY);
  xfree (pathname);
  if (fd < 0)
    return -1;

  if (offset != (ULONGEST) 0
      && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
    n = -1;
  else if (readbuf != NULL)
    n = read (fd, readbuf, len);
  else
    n = write (fd, writebuf, len);

  (void) close (fd);

  return n;
}

/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
   Return 0 if *READPTR is already at the end of the buffer.
   Return -1 if there is insufficient buffer for a whole entry.
   Return 1 if an entry was read into *TYPEP and *VALP.  */
int
target_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
		   gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{
  const int sizeof_auxv_field = TYPE_LENGTH (builtin_type_void_data_ptr);
  gdb_byte *ptr = *readptr;

  if (endptr == ptr)
    return 0;

  if (endptr - ptr < sizeof_auxv_field * 2)
    return -1;

  *typep = extract_unsigned_integer (ptr, sizeof_auxv_field);
  ptr += sizeof_auxv_field;
  *valp = extract_unsigned_integer (ptr, sizeof_auxv_field);
  ptr += sizeof_auxv_field;

  *readptr = ptr;
  return 1;
}

/* Extract the auxiliary vector entry with a_type matching MATCH.
   Return zero if no such entry was found, or -1 if there was
   an error getting the information.  On success, return 1 after
   storing the entry's value field in *VALP.  */
int
target_auxv_search (struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
{
  CORE_ADDR type, val;
  gdb_byte *data;
  LONGEST n = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, &data);
  gdb_byte *ptr = data;
  int ents = 0;

  if (n <= 0)
    return n;

  while (1)
    switch (target_auxv_parse (ops, &ptr, data + n, &type, &val))
      {
      case 1:			/* Here's an entry, check it.  */
	if (type == match)
	  {
	    xfree (data);
	    *valp = val;
	    return 1;
	  }
	break;
      case 0:			/* End of the vector.  */
	xfree (data);
	return 0;
      default:			/* Bogosity.  */
	xfree (data);
	return -1;
      }

  /*NOTREACHED*/
}


/* Print the contents of the target's AUXV on the specified file. */
int
fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
{
  CORE_ADDR type, val;
  gdb_byte *data;
  LONGEST len = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL,
				   &data);
  gdb_byte *ptr = data;
  int ents = 0;

  if (len <= 0)
    return len;

  while (target_auxv_parse (ops, &ptr, data + len, &type, &val) > 0)
    {
      extern int addressprint;
      const char *name = "???";
      const char *description = "";
      enum { dec, hex, str } flavor = hex;

      switch (type)
	{
#define TAG(tag, text, kind) \
	case tag: name = #tag; description = text; flavor = kind; break
	  TAG (AT_NULL, _("End of vector"), hex);
	  TAG (AT_IGNORE, _("Entry should be ignored"), hex);
	  TAG (AT_EXECFD, _("File descriptor of program"), dec);
	  TAG (AT_PHDR, _("Program headers for program"), hex);
	  TAG (AT_PHENT, _("Size of program header entry"), dec);
	  TAG (AT_PHNUM, _("Number of program headers"), dec);
	  TAG (AT_PAGESZ, _("System page size"), dec);
	  TAG (AT_BASE, _("Base address of interpreter"), hex);
	  TAG (AT_FLAGS, _("Flags"), hex);
	  TAG (AT_ENTRY, _("Entry point of program"), hex);
	  TAG (AT_NOTELF, _("Program is not ELF"), dec);
	  TAG (AT_UID, _("Real user ID"), dec);
	  TAG (AT_EUID, _("Effective user ID"), dec);
	  TAG (AT_GID, _("Real group ID"), dec);
	  TAG (AT_EGID, _("Effective group ID"), dec);
	  TAG (AT_CLKTCK, _("Frequency of times()"), dec);
	  TAG (AT_PLATFORM, _("String identifying platform"), str);
	  TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
	  TAG (AT_FPUCW, _("Used FPU control word"), dec);
	  TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
	  TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
	  TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
	  TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
	  TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
	  TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
	  TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
	  TAG (AT_SUN_UID, _("Effective user ID"), dec);
	  TAG (AT_SUN_RUID, _("Real user ID"), dec);
	  TAG (AT_SUN_GID, _("Effective group ID"), dec);
	  TAG (AT_SUN_RGID, _("Real group ID"), dec);
	  TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
	  TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
	  TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
	  TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
	  TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
	  TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
	  TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
	  TAG (AT_SUN_CPU, _("CPU name string"), str);
	  TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
	  TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
	  TAG (AT_SUN_EXECNAME,
	       _("Canonicalized file name given to execve"), str);
	  TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
	  TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
	  TAG (AT_SUN_AUXFLAGS,
	       _("AF_SUN_ flags passed from the kernel"), hex);
	}

      fprintf_filtered (file, "%-4s %-20s %-30s ",
			paddr_d (type), name, description);
      switch (flavor)
	{
	case dec:
	  fprintf_filtered (file, "%s\n", paddr_d (val));
	  break;
	case hex:
	  fprintf_filtered (file, "0x%s\n", paddr_nz (val));
	  break;
	case str:
	  if (addressprint)
	    fprintf_filtered (file, "0x%s", paddr_nz (val));
	  val_print_string (val, -1, 1, file);
	  fprintf_filtered (file, "\n");
	  break;
	}
      ++ents;
    }

  xfree (data);

  return ents;
}

static void
info_auxv_command (char *cmd, int from_tty)
{
  if (! target_has_stack)
    error (_("The program has no auxiliary information now."));
  else
    {
      int ents = fprint_target_auxv (gdb_stdout, &current_target);
      if (ents < 0)
	error (_("No auxiliary vector found, or failed reading it."));
      else if (ents == 0)
	error (_("Auxiliary vector is empty."));
    }
}


extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */

void
_initialize_auxv (void)
{
  add_info ("auxv", info_auxv_command,
	    _("Display the inferior's auxiliary vector.\n\
This is information provided by the operating system at program startup."));
}
Commit	Line	Data
14ed0a8b RM	1	/* Auxiliary vector support for GDB, the GNU debugger.
14ed0a8b RM	2
9b254dd1	3	Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
14ed0a8b RM	4
	5	This file is part of GDB.
	6
	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
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
14ed0a8b RM	10	(at your option) any later version.
	11
	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.
	16
	17	You should have received a copy of the GNU General Public License
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
14ed0a8b RM	19
	20	#include "defs.h"
	21	#include "target.h"
	22	#include "gdbtypes.h"
	23	#include "command.h"
	24	#include "inferior.h"
	25	#include "valprint.h"
	26	#include "gdb_assert.h"
	27
	28	#include "auxv.h"
	29	#include "elf/common.h"
	30
	31	#include <unistd.h>
	32	#include <fcntl.h>
	33
	34
	35	/* This function is called like a to_xfer_partial hook,
	36	but must be called with TARGET_OBJECT_AUXV.
	37	It handles access via /proc/PID/auxv, which is the common method.
	38	This function is appropriate for doing:
	39	#define NATIVE_XFER_AUXV procfs_xfer_auxv
	40	for a native target that uses inftarg.c's child_xfer_partial hook. */
	41
	42	LONGEST
	43	procfs_xfer_auxv (struct target_ops *ops,
	44	int /* enum target_object */ object,
	45	const char *annex,
36aa5e41 AC	46	gdb_byte *readbuf,
36aa5e41 AC	47	const gdb_byte *writebuf,
14ed0a8b RM	48	ULONGEST offset,
	49	LONGEST len)
	50	{
	51	char *pathname;
	52	int fd;
	53	LONGEST n;
	54
	55	gdb_assert (object == TARGET_OBJECT_AUXV);
	56	gdb_assert (readbuf \|\| writebuf);
	57
	58	pathname = xstrprintf ("/proc/%d/auxv", PIDGET (inferior_ptid));
	59	fd = open (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY);
	60	xfree (pathname);
	61	if (fd < 0)
	62	return -1;
	63
	64	if (offset != (ULONGEST) 0
	65	&& lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
	66	n = -1;
	67	else if (readbuf != NULL)
	68	n = read (fd, readbuf, len);
	69	else
	70	n = write (fd, writebuf, len);
	71
	72	(void) close (fd);
	73
	74	return n;
	75	}
	76
14ed0a8b RM	77	/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
	78	Return 0 if *READPTR is already at the end of the buffer.
	79	Return -1 if there is insufficient buffer for a whole entry.
	80	Return 1 if an entry was read into TYPEP and VALP. */
	81	int
36aa5e41 AC	82	target_auxv_parse (struct target_ops ops, gdb_byte *readptr,
36aa5e41 AC	83	gdb_byte endptr, CORE_ADDR typep, CORE_ADDR *valp)
14ed0a8b RM	84	{
14ed0a8b RM	85	const int sizeof_auxv_field = TYPE_LENGTH (builtin_type_void_data_ptr);
36aa5e41	86	gdb_byte ptr = readptr;
14ed0a8b RM	87
	88	if (endptr == ptr)
	89	return 0;
	90
	91	if (endptr - ptr < sizeof_auxv_field * 2)
	92	return -1;
	93
	94	*typep = extract_unsigned_integer (ptr, sizeof_auxv_field);
	95	ptr += sizeof_auxv_field;
	96	*valp = extract_unsigned_integer (ptr, sizeof_auxv_field);
	97	ptr += sizeof_auxv_field;
	98
	99	*readptr = ptr;
	100	return 1;
	101	}
	102
	103	/* Extract the auxiliary vector entry with a_type matching MATCH.
	104	Return zero if no such entry was found, or -1 if there was
	105	an error getting the information. On success, return 1 after
	106	storing the entry's value field in VALP. /
	107	int
	108	target_auxv_search (struct target_ops ops, CORE_ADDR match, CORE_ADDR valp)
	109	{
	110	CORE_ADDR type, val;
36aa5e41	111	gdb_byte *data;
13547ab6	112	LONGEST n = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL, &data);
36aa5e41	113	gdb_byte *ptr = data;
14ed0a8b RM	114	int ents = 0;
	115
	116	if (n <= 0)
	117	return n;
	118
	119	while (1)
	120	switch (target_auxv_parse (ops, &ptr, data + n, &type, &val))
	121	{
	122	case 1: /* Here's an entry, check it. */
	123	if (type == match)
	124	{
	125	xfree (data);
	126	*valp = val;
	127	return 1;
	128	}
	129	break;
	130	case 0: /* End of the vector. */
	131	xfree (data);
	132	return 0;
	133	default: /* Bogosity. */
	134	xfree (data);
	135	return -1;
	136	}
	137
	138	/NOTREACHED/
	139	}
	140
	141
	142	/* Print the contents of the target's AUXV on the specified file. */
	143	int
	144	fprint_target_auxv (struct ui_file file, struct target_ops ops)
	145	{
	146	CORE_ADDR type, val;
36aa5e41	147	gdb_byte *data;
13547ab6 DJ	148	LONGEST len = target_read_alloc (ops, TARGET_OBJECT_AUXV, NULL,
13547ab6 DJ	149	&data);
36aa5e41	150	gdb_byte *ptr = data;
14ed0a8b RM	151	int ents = 0;
	152
	153	if (len <= 0)
	154	return len;
	155
	156	while (target_auxv_parse (ops, &ptr, data + len, &type, &val) > 0)
	157	{
	158	extern int addressprint;
	159	const char *name = "???";
	160	const char *description = "";
	161	enum { dec, hex, str } flavor = hex;
	162
	163	switch (type)
	164	{
	165	#define TAG(tag, text, kind) \
	166	case tag: name = #tag; description = text; flavor = kind; break
edefbb7c AC	167	TAG (AT_NULL, _("End of vector"), hex);
	168	TAG (AT_IGNORE, _("Entry should be ignored"), hex);
	169	TAG (AT_EXECFD, _("File descriptor of program"), dec);
	170	TAG (AT_PHDR, _("Program headers for program"), hex);
	171	TAG (AT_PHENT, _("Size of program header entry"), dec);
	172	TAG (AT_PHNUM, _("Number of program headers"), dec);
	173	TAG (AT_PAGESZ, _("System page size"), dec);
	174	TAG (AT_BASE, _("Base address of interpreter"), hex);
	175	TAG (AT_FLAGS, _("Flags"), hex);
	176	TAG (AT_ENTRY, _("Entry point of program"), hex);
	177	TAG (AT_NOTELF, _("Program is not ELF"), dec);
	178	TAG (AT_UID, _("Real user ID"), dec);
	179	TAG (AT_EUID, _("Effective user ID"), dec);
	180	TAG (AT_GID, _("Real group ID"), dec);
	181	TAG (AT_EGID, _("Effective group ID"), dec);
	182	TAG (AT_CLKTCK, _("Frequency of times()"), dec);
	183	TAG (AT_PLATFORM, _("String identifying platform"), str);
	184	TAG (AT_HWCAP, _("Machine-dependent CPU capability hints"), hex);
	185	TAG (AT_FPUCW, _("Used FPU control word"), dec);
	186	TAG (AT_DCACHEBSIZE, _("Data cache block size"), dec);
	187	TAG (AT_ICACHEBSIZE, _("Instruction cache block size"), dec);
	188	TAG (AT_UCACHEBSIZE, _("Unified cache block size"), dec);
	189	TAG (AT_IGNOREPPC, _("Entry should be ignored"), dec);
	190	TAG (AT_SYSINFO, _("Special system info/entry points"), hex);
	191	TAG (AT_SYSINFO_EHDR, _("System-supplied DSO's ELF header"), hex);
	192	TAG (AT_SECURE, _("Boolean, was exec setuid-like?"), dec);
	193	TAG (AT_SUN_UID, _("Effective user ID"), dec);
	194	TAG (AT_SUN_RUID, _("Real user ID"), dec);
	195	TAG (AT_SUN_GID, _("Effective group ID"), dec);
	196	TAG (AT_SUN_RGID, _("Real group ID"), dec);
	197	TAG (AT_SUN_LDELF, _("Dynamic linker's ELF header"), hex);
	198	TAG (AT_SUN_LDSHDR, _("Dynamic linker's section headers"), hex);
	199	TAG (AT_SUN_LDNAME, _("String giving name of dynamic linker"), str);
	200	TAG (AT_SUN_LPAGESZ, _("Large pagesize"), dec);
	201	TAG (AT_SUN_PLATFORM, _("Platform name string"), str);
	202	TAG (AT_SUN_HWCAP, _("Machine-dependent CPU capability hints"), hex);
	203	TAG (AT_SUN_IFLUSH, _("Should flush icache?"), dec);
	204	TAG (AT_SUN_CPU, _("CPU name string"), str);
	205	TAG (AT_SUN_EMUL_ENTRY, _("COFF entry point address"), hex);
	206	TAG (AT_SUN_EMUL_EXECFD, _("COFF executable file descriptor"), dec);
14ed0a8b	207	TAG (AT_SUN_EXECNAME,
edefbb7c AC	208	_("Canonicalized file name given to execve"), str);
	209	TAG (AT_SUN_MMU, _("String for name of MMU module"), str);
	210	TAG (AT_SUN_LDDATA, _("Dynamic linker's data segment address"), hex);
77d49ac6 MK	211	TAG (AT_SUN_AUXFLAGS,
77d49ac6 MK	212	_("AF_SUN_ flags passed from the kernel"), hex);
14ed0a8b RM	213	}
	214
	215	fprintf_filtered (file, "%-4s %-20s %-30s ",
	216	paddr_d (type), name, description);
	217	switch (flavor)
	218	{
	219	case dec:
	220	fprintf_filtered (file, "%s\n", paddr_d (val));
	221	break;
	222	case hex:
	223	fprintf_filtered (file, "0x%s\n", paddr_nz (val));
	224	break;
	225	case str:
	226	if (addressprint)
	227	fprintf_filtered (file, "0x%s", paddr_nz (val));
	228	val_print_string (val, -1, 1, file);
	229	fprintf_filtered (file, "\n");
	230	break;
	231	}
	232	++ents;
	233	}
	234
	235	xfree (data);
	236
	237	return ents;
	238	}
	239
	240	static void
	241	info_auxv_command (char *cmd, int from_tty)
	242	{
14ed0a8b	243	if (! target_has_stack)
edefbb7c	244	error (_("The program has no auxiliary information now."));
14ed0a8b RM	245	else
	246	{
	247	int ents = fprint_target_auxv (gdb_stdout, &current_target);
	248	if (ents < 0)
edefbb7c	249	error (_("No auxiliary vector found, or failed reading it."));
14ed0a8b	250	else if (ents == 0)
edefbb7c	251	error (_("Auxiliary vector is empty."));
14ed0a8b RM	252	}
	253	}
	254
	255
	256	extern initialize_file_ftype _initialize_auxv; /* -Wmissing-prototypes; */
	257
	258	void
	259	_initialize_auxv (void)
	260	{
	261	add_info ("auxv", info_auxv_command,
edefbb7c AC	262	_("Display the inferior's auxiliary vector.\n\
edefbb7c AC	263	This is information provided by the operating system at program startup."));
14ed0a8b	264	}