/* Low level Unix child interface to ptrace, for GDB when running under Unix.
- Copyright 1988, 89, 90, 91, 92, 93, 94, 95, 96, 1998
+ Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
+ 1999, 2000, 2001
Free Software Foundation, Inc.
This file is part of GDB.
#include "inferior.h"
#include "target.h"
#include "gdb_string.h"
-#include "wait.h"
+#include "regcache.h"
+
+#include "gdb_wait.h"
+
#include "command.h"
#ifdef USG
#endif
#include <sys/param.h>
-#include <sys/dir.h>
+#include "gdb_dirent.h"
#include <signal.h>
#include <sys/ioctl.h>
#endif /* !FETCH_INFERIOR_REGISTERS */
#if !defined (CHILD_XFER_MEMORY)
-static void udot_info PARAMS ((char *, int));
+static void udot_info (char *, int);
#endif
#if !defined (FETCH_INFERIOR_REGISTERS)
-static void fetch_register PARAMS ((int));
-static void store_register PARAMS ((int));
+static void fetch_register (int);
+static void store_register (int);
+#endif
+
+/*
+ * Some systems (Linux) may have threads implemented as pseudo-processes,
+ * in which case we may be tracing more than one process at a time.
+ * In that case, inferior_pid will contain the main process ID and the
+ * individual thread (process) id mashed together. These macros are
+ * used to separate them out. The definitions may be overridden in tm.h
+ *
+ * NOTE: default definitions here are for systems with no threads.
+ * Useful definitions MUST be provided in tm.h
+ */
+
+#if !defined (PIDGET) /* Default definition for PIDGET/TIDGET. */
+#define PIDGET(PID) PID
+#define TIDGET(PID) 0
#endif
-void _initialize_kernel_u_addr PARAMS ((void));
-void _initialize_infptrace PARAMS ((void));
+void _initialize_kernel_u_addr (void);
+void _initialize_infptrace (void);
\f
/* This function simply calls ptrace with the given arguments.
It exists so that all calls to ptrace are isolated in this
machine-dependent file. */
int
-call_ptrace (request, pid, addr, data)
- int request, pid;
- PTRACE_ARG3_TYPE addr;
- int data;
+call_ptrace (int request, int pid, PTRACE_ARG3_TYPE addr, int data)
{
int pt_status = 0;
if (request == PT_SETTRC)
{
errno = 0;
- pt_status = ptrace (PT_SETTRC, pid, addr, data
-#if defined (FIVE_ARG_PTRACE)
+#if !defined (FIVE_ARG_PTRACE)
+ pt_status = ptrace (PT_SETTRC, pid, addr, data);
+#else
/* Deal with HPUX 8.0 braindamage. We never use the
calls which require the fifth argument. */
- ,0
+ pt_status = ptrace (PT_SETTRC, pid, addr, data, 0);
#endif
- );
-
if (errno)
perror_with_name ("ptrace");
#if 0
saved_errno = errno;
errno = 0;
#endif
- pt_status = ptrace (request, pid, addr, data
-#if defined (FIVE_ARG_PTRACE)
+#if !defined (FIVE_ARG_PTRACE)
+ pt_status = ptrace (request, pid, addr, data);
+#else
/* Deal with HPUX 8.0 braindamage. We never use the
calls which require the fifth argument. */
- ,0
+ pt_status = ptrace (request, pid, addr, data, 0);
#endif
- );
+
#if 0
if (errno)
printf (" [errno = %d]", errno);
hook before returning. */
int
-ptrace_wait (pid, status)
- int pid;
- int *status;
+ptrace_wait (int pid, int *status)
{
int wstate;
}
void
-kill_inferior ()
+kill_inferior (void)
{
int status;
If SIGNAL is nonzero, give it that signal. */
void
-child_resume (pid, step, signal)
- int pid;
- int step;
- enum target_signal signal;
+child_resume (int pid, int step, enum target_signal signal)
{
errno = 0;
if (step)
{
- if (SOFTWARE_SINGLE_STEP_P)
- abort (); /* Make sure this doesn't happen. */
+ if (SOFTWARE_SINGLE_STEP_P ())
+ internal_error (__FILE__, __LINE__, "failed internal consistency check"); /* Make sure this doesn't happen. */
else
ptrace (PT_STEP, pid, (PTRACE_ARG3_TYPE) 1,
target_signal_to_host (signal));
target_signal_to_host (signal));
if (errno)
- perror_with_name ("ptrace");
+ {
+ perror_with_name ("ptrace");
+ }
}
#endif /* CHILD_RESUME */
\f
#ifdef ATTACH_DETACH
/* Start debugging the process whose number is PID. */
int
-attach (pid)
- int pid;
+attach (int pid)
{
errno = 0;
ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0);
SIGNAL = 0 means just continue it. */
void
-detach (signal)
- int signal;
+detach (int signal)
{
errno = 0;
ptrace (PT_DETACH, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
#endif /* KERNEL_U_ADDR_BSD. */
void
-_initialize_kernel_u_addr ()
+_initialize_kernel_u_addr (void)
{
#if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
struct nlist names[2];
if (nlist ("/vmunix", names) == 0)
kernel_u_addr = names[0].n_value;
else
- fatal ("Unable to get kernel u area address.");
+ internal_error (__FILE__, __LINE__,
+ "Unable to get kernel u area address.");
#endif /* KERNEL_U_ADDR_BSD. */
}
/* Fetch one register. */
static void
-fetch_register (regno)
- int regno;
+fetch_register (int regno)
{
/* This isn't really an address. But ptrace thinks of it as one. */
CORE_ADDR regaddr;
register int i;
unsigned int offset; /* Offset of registers within the u area. */
char buf[MAX_REGISTER_RAW_SIZE];
+ int tid;
if (CANNOT_FETCH_REGISTER (regno))
{
return;
}
+ /* Overload thread id onto process id */
+ if ((tid = TIDGET (inferior_pid)) == 0)
+ tid = inferior_pid; /* no thread id, just use process id */
+
offset = U_REGS_OFFSET;
regaddr = register_addr (regno, offset);
for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
- *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, inferior_pid,
- (PTRACE_ARG3_TYPE) regaddr, 0);
+ *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid,
+ (PTRACE_ARG3_TYPE) regaddr, 0);
regaddr += sizeof (PTRACE_XFER_TYPE);
if (errno != 0)
{
- sprintf (mess, "reading register %s (#%d)", REGISTER_NAME (regno), regno);
+ sprintf (mess, "reading register %s (#%d)",
+ REGISTER_NAME (regno), regno);
perror_with_name (mess);
}
}
Otherwise, REGNO specifies which register (so we can save time). */
void
-fetch_inferior_registers (regno)
- int regno;
+fetch_inferior_registers (int regno)
{
if (regno >= 0)
{
}
else
{
- for (regno = 0; regno < ARCH_NUM_REGS; regno++)
+ for (regno = 0; regno < NUM_REGS; regno++)
{
fetch_register (regno);
}
/* Store one register. */
static void
-store_register (regno)
- int regno;
+store_register (int regno)
{
/* This isn't really an address. But ptrace thinks of it as one. */
CORE_ADDR regaddr;
char mess[128]; /* For messages */
register int i;
unsigned int offset; /* Offset of registers within the u area. */
+ int tid;
if (CANNOT_STORE_REGISTER (regno))
{
return;
}
+ /* Overload thread id onto process id */
+ if ((tid = TIDGET (inferior_pid)) == 0)
+ tid = inferior_pid; /* no thread id, just use process id */
+
offset = U_REGS_OFFSET;
regaddr = register_addr (regno, offset);
for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
- ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
+ ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,
*(PTRACE_XFER_TYPE *) & registers[REGISTER_BYTE (regno) + i]);
regaddr += sizeof (PTRACE_XFER_TYPE);
if (errno != 0)
{
- sprintf (mess, "writing register %s (#%d)", REGISTER_NAME (regno), regno);
+ sprintf (mess, "writing register %s (#%d)",
+ REGISTER_NAME (regno), regno);
perror_with_name (mess);
}
}
Otherwise, REGNO specifies which register (so we can save time). */
void
-store_inferior_registers (regno)
- int regno;
+store_inferior_registers (int regno)
{
if (regno >= 0)
{
}
else
{
- for (regno = 0; regno < ARCH_NUM_REGS; regno++)
+ for (regno = 0; regno < NUM_REGS; regno++)
{
store_register (regno);
}
/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
to debugger memory starting at MYADDR. Copy to inferior if
- WRITE is nonzero.
+ WRITE is nonzero. TARGET is ignored.
Returns the length copied, which is either the LEN argument or zero.
This xfer function does not do partial moves, since child_ops
anyway. */
int
-child_xfer_memory (memaddr, myaddr, len, write, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
- struct target_ops *target; /* ignored */
+child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct mem_attrib *attrib ATTRIBUTE_UNUSED,
+ struct target_ops *target)
{
register int i;
/* Round starting address down to longword boundary. */
if (addr != memaddr || len < (int) sizeof (PTRACE_XFER_TYPE))
{
/* Need part of initial word -- fetch it. */
- buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
- 0);
+ buffer[0] = ptrace (PT_READ_I, PIDGET (inferior_pid),
+ (PTRACE_ARG3_TYPE) addr, 0);
}
if (count > 1) /* FIXME, avoid if even boundary */
{
- buffer[count - 1]
- = ptrace (PT_READ_I, inferior_pid,
+ buffer[count - 1]
+ = ptrace (PT_READ_I, PIDGET (inferior_pid),
((PTRACE_ARG3_TYPE)
(addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))),
0);
for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
- ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
- buffer[i]);
+ ptrace (PT_WRITE_D, PIDGET (inferior_pid),
+ (PTRACE_ARG3_TYPE) addr, buffer[i]);
if (errno)
{
/* Using the appropriate one (I or D) is necessary for
Gould NP1, at least. */
errno = 0;
- ptrace (PT_WRITE_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
- buffer[i]);
+ ptrace (PT_WRITE_I, PIDGET (inferior_pid),
+ (PTRACE_ARG3_TYPE) addr, buffer[i]);
}
if (errno)
return 0;
for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
- buffer[i] = ptrace (PT_READ_I, inferior_pid,
+ buffer[i] = ptrace (PT_READ_I, PIDGET (inferior_pid),
(PTRACE_ARG3_TYPE) addr, 0);
if (errno)
return 0;
\f
static void
-udot_info (dummy1, dummy2)
- char *dummy1;
- int dummy2;
+udot_info (char *dummy1, int dummy2)
{
#if defined (KERNEL_U_SIZE)
int udot_off; /* Offset into user struct */
\f
void
-_initialize_infptrace ()
+_initialize_infptrace (void)
{
#if !defined (CHILD_XFER_MEMORY)
add_info ("udot", udot_info,
projects / deliverable / binutils-gdb.git / blobdiff