X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgnu-nat.c;h=927ee5c6f17833e7f2ca4d5f6ab0f4a4d5cf035c;hb=e4975d6a9cd8aaf3fb14135b36850964def131d7;hp=cab0c39eb5f81f86c69f034c0b85d7343fb42e94;hpb=fe79276ff1d1ebeed601f3b579f2c80193552b42;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index cab0c39eb5..927ee5c6f1 100644
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -1,6 +1,5 @@
/* Interface GDB to the GNU Hurd.
- Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2006, 2007,
- 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 1992-2016 Free Software Foundation, Inc.
This file is part of GDB.
@@ -19,16 +18,14 @@
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 .
- */
+ along with this program. If not, see . */
+
+#include "defs.h"
#include
-#include
#include
#include
#include
-#include
-#include "gdb_string.h"
#include
#include
@@ -52,7 +49,6 @@
#include
-#include "defs.h"
#include "inferior.h"
#include "symtab.h"
#include "value.h"
@@ -62,7 +58,6 @@
#include "gdbcmd.h"
#include "gdbcore.h"
#include "gdbthread.h"
-#include "gdb_assert.h"
#include "gdb_obstack.h"
#include "gnu-nat.h"
@@ -88,7 +83,7 @@ int gnu_debug_flag = 0;
/* Forward decls */
-struct inf *make_inf ();
+static struct inf *make_inf ();
void inf_clear_wait (struct inf *inf);
void inf_cleanup (struct inf *inf);
void inf_startup (struct inf *inf, int pid);
@@ -97,7 +92,6 @@ void inf_set_pid (struct inf *inf, pid_t pid);
void inf_validate_procs (struct inf *inf);
void inf_steal_exc_ports (struct inf *inf);
void inf_restore_exc_ports (struct inf *inf);
-struct proc *inf_tid_to_proc (struct inf *inf, int tid);
void inf_set_threads_resume_sc (struct inf *inf,
struct proc *run_thread,
int run_others);
@@ -107,7 +101,7 @@ void inf_resume (struct inf *inf);
void inf_set_step_thread (struct inf *inf, struct proc *proc);
void inf_detach (struct inf *inf);
void inf_attach (struct inf *inf, int pid);
-void inf_signal (struct inf *inf, enum target_signal sig);
+void inf_signal (struct inf *inf, enum gdb_signal sig);
void inf_continue (struct inf *inf);
#define inf_debug(_inf, msg, args...) \
@@ -150,17 +144,17 @@ int proc_trace (struct proc *proc, int set);
/* The state passed by an exception message. */
struct exc_state
{
- int exception; /* The exception code */
+ int exception; /* The exception code. */
int code, subcode;
- mach_port_t handler; /* The real exception port to handle this. */
- mach_port_t reply; /* The reply port from the exception call. */
+ mach_port_t handler; /* The real exception port to handle this. */
+ mach_port_t reply; /* The reply port from the exception call. */
};
-/* The results of the last wait an inf did. */
+/* The results of the last wait an inf did. */
struct inf_wait
{
struct target_waitstatus status; /* The status returned to gdb. */
- struct exc_state exc; /* The exception that caused us to return. */
+ struct exc_state exc; /* The exception that caused us to return. */
struct proc *thread; /* The thread in question. */
int suppress; /* Something trivial happened. */
};
@@ -173,17 +167,18 @@ struct inf
struct proc *task; /* The mach task. */
struct proc *threads; /* A linked list of all threads in TASK. */
- /* True if THREADS needn't be validated by querying the task. We assume that
- we and the task in question are the only ones frobbing the thread list,
- so as long as we don't let any code run, we don't have to worry about
- THREADS changing. */
+ /* True if THREADS needn't be validated by querying the task. We
+ assume that we and the task in question are the only ones
+ frobbing the thread list, so as long as we don't let any code
+ run, we don't have to worry about THREADS changing. */
int threads_up_to_date;
- pid_t pid; /* The real system PID. */
+ pid_t pid; /* The real system PID. */
struct inf_wait wait; /* What to return from target_wait. */
- /* One thread proc in INF may be in `single-stepping mode'. This is it. */
+ /* One thread proc in INF may be in `single-stepping mode'. This
+ is it. */
struct proc *step_thread;
/* The thread we think is the signal thread. */
@@ -211,11 +206,11 @@ struct inf
unsigned int no_wait:1;
/* When starting a new inferior, we don't try to validate threads until all
- the proper execs have been done. This is a count of how many execs we
+ the proper execs have been done, which this flag states we still
expect to happen. */
- unsigned pending_execs;
+ unsigned int pending_execs:1;
- /* Fields describing global state */
+ /* Fields describing global state. */
/* The task suspend count used when gdb has control. This is normally 1 to
make things easier for us, but sometimes (like when attaching to vital
@@ -263,7 +258,7 @@ proc_update_sc (struct proc *proc)
proc_debug (proc, "sc: %d --> %d", proc->cur_sc, proc->sc);
if (proc->sc == 0 && proc->state_changed)
- /* Since PROC may start running, we must write back any state changes. */
+ /* Since PROC may start running, we must write back any state changes. */
{
gdb_assert (proc_is_thread (proc));
proc_debug (proc, "storing back changed thread state");
@@ -373,8 +368,9 @@ proc_get_state (struct proc *proc, int will_modify)
{
mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
error_t err =
- thread_get_state (proc->port, THREAD_STATE_FLAVOR,
- (thread_state_t) &proc->state, &state_size);
+ thread_get_state (proc->port, THREAD_STATE_FLAVOR,
+ (thread_state_t) &proc->state, &state_size);
+
proc_debug (proc, "getting thread state");
proc->state_valid = !err;
}
@@ -404,7 +400,7 @@ proc_get_exception_port (struct proc * proc, mach_port_t * port)
error_t
proc_set_exception_port (struct proc * proc, mach_port_t port)
{
- proc_debug (proc, "setting exception port: %d", port);
+ proc_debug (proc, "setting exception port: %lu", port);
if (proc_is_task (proc))
return task_set_exception_port (proc->port, port);
else
@@ -432,8 +428,9 @@ _proc_get_exc_port (struct proc *proc)
return exc_port;
}
-/* Replace PROC's exception port with EXC_PORT, unless it's already been
- done. Stash away any existing exception port so we can restore it later. */
+/* Replace PROC's exception port with EXC_PORT, unless it's already
+ been done. Stash away any existing exception port so we can
+ restore it later. */
void
proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
{
@@ -443,7 +440,7 @@ proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
{
error_t err = 0;
- proc_debug (proc, "inserting exception port: %d", exc_port);
+ proc_debug (proc, "inserting exception port: %lu", exc_port);
if (cur_exc_port != exc_port)
/* Put in our exception port. */
@@ -457,14 +454,14 @@ proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
mach_port_deallocate (mach_task_self (), cur_exc_port);
}
else
- /* Keep a copy of PROC's old exception port so it can be restored. */
+ /* Keep a copy of PROC's old exception port so it can be restored. */
{
if (proc->saved_exc_port)
mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
proc->saved_exc_port = cur_exc_port;
}
- proc_debug (proc, "saved exception port: %d", proc->saved_exc_port);
+ proc_debug (proc, "saved exception port: %lu", proc->saved_exc_port);
if (!err)
proc->exc_port = exc_port;
@@ -513,14 +510,14 @@ proc_trace (struct proc *proc, int set)
thread_state_t state = proc_get_state (proc, 1);
if (!state)
- return 0; /* the thread must be dead. */
+ return 0; /* The thread must be dead. */
proc_debug (proc, "tracing %s", set ? "on" : "off");
if (set)
{
/* XXX We don't get the exception unless the thread has its own
- exception port???? */
+ exception port???? */
if (proc->exc_port == MACH_PORT_NULL)
proc_steal_exc_port (proc, proc->inf->event_port);
THREAD_STATE_SET_TRACED (state);
@@ -542,7 +539,7 @@ make_proc (struct inf *inf, mach_port_t port, int tid)
{
error_t err;
mach_port_t prev_port = MACH_PORT_NULL;
- struct proc *proc = xmalloc (sizeof (struct proc));
+ struct proc *proc = XNEW (struct proc);
proc->port = port;
proc->tid = tid;
@@ -576,11 +573,11 @@ make_proc (struct inf *inf, mach_port_t port, int tid)
MACH_MSG_TYPE_MAKE_SEND_ONCE,
&prev_port);
if (err)
- warning (_("Couldn't request notification for port %d: %s"),
+ warning (_("Couldn't request notification for port %lu: %s"),
port, safe_strerror (err));
else
{
- proc_debug (proc, "notifications to: %d", inf->event_port);
+ proc_debug (proc, "notifications to: %lu", inf->event_port);
if (prev_port != MACH_PORT_NULL)
mach_port_deallocate (mach_task_self (), prev_port);
}
@@ -636,10 +633,10 @@ _proc_free (struct proc *proc)
}
-struct inf *
+static struct inf *
make_inf (void)
{
- struct inf *inf = xmalloc (sizeof (struct inf));
+ struct inf *inf = XNEW (struct inf);
inf->task = 0;
inf->threads = 0;
@@ -749,11 +746,13 @@ inf_set_pid (struct inf *inf, pid_t pid)
else
{
error_t err = proc_pid2task (proc_server, pid, &task_port);
+
if (err)
- error (_("Error getting task for pid %d: %s"), pid, safe_strerror (err));
+ error (_("Error getting task for pid %d: %s"),
+ pid, safe_strerror (err));
}
- inf_debug (inf, "setting task: %d", task_port);
+ inf_debug (inf, "setting task: %lu", task_port);
if (inf->pause_sc)
task_suspend (task_port);
@@ -761,8 +760,8 @@ inf_set_pid (struct inf *inf, pid_t pid)
if (task && task->port != task_port)
{
inf->task = 0;
- inf_validate_procs (inf); /* Trash all the threads. */
- _proc_free (task); /* And the task. */
+ inf_validate_procs (inf); /* Trash all the threads. */
+ _proc_free (task); /* And the task. */
}
if (task_port != MACH_PORT_NULL)
@@ -796,8 +795,8 @@ inf_validate_procinfo (struct inf *inf)
mach_msg_type_number_t pi_len = 0;
int info_flags = 0;
error_t err =
- proc_getprocinfo (proc_server, inf->pid, &info_flags,
- (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
+ proc_getprocinfo (proc_server, inf->pid, &info_flags,
+ (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
if (!err)
{
@@ -805,7 +804,8 @@ inf_validate_procinfo (struct inf *inf)
inf->nomsg = !!(pi->state & PI_NOMSG);
if (inf->nomsg)
inf->traced = !!(pi->state & PI_TRACED);
- vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
+ vm_deallocate (mach_task_self (), (vm_address_t) pi,
+ pi_len * sizeof (*(procinfo_t) 0));
if (noise_len > 0)
vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
}
@@ -845,21 +845,16 @@ inf_validate_task_sc (struct inf *inf)
suspend_count = pi->taskinfo.suspend_count;
- vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
+ vm_deallocate (mach_task_self (), (vm_address_t) pi,
+ pi_len * sizeof (*(procinfo_t) 0));
if (noise_len > 0)
- vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
+ vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
if (inf->task->cur_sc < suspend_count)
{
- int abort;
-
- target_terminal_ours (); /* Allow I/O. */
- abort = !query (_("Pid %d has an additional task suspend count of %d;"
- " clear it? "), inf->pid,
- suspend_count - inf->task->cur_sc);
- target_terminal_inferior (); /* Give it back to the child. */
-
- if (abort)
+ if (!query (_("Pid %d has an additional task suspend count of %d;"
+ " clear it? "), inf->pid,
+ suspend_count - inf->task->cur_sc))
error (_("Additional task suspend count left untouched."));
inf->task->cur_sc = suspend_count;
@@ -870,7 +865,7 @@ inf_validate_task_sc (struct inf *inf)
is. If INF is running, the resume_sc count of INF's threads will
be modified, and the signal thread will briefly be run to change
the trace state. */
-void
+static void
inf_set_traced (struct inf *inf, int on)
{
if (on == inf->traced)
@@ -883,6 +878,7 @@ inf_set_traced (struct inf *inf, int on)
error_t err =
INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
INIT_TRACEMASK, mask));
+
if (err == EIEIO)
{
if (on)
@@ -904,15 +900,15 @@ inf_set_traced (struct inf *inf, int on)
/* Makes all the real suspend count deltas of all the procs in INF
match the desired values. Careful to always do thread/task suspend
counts in the safe order. Returns true if at least one thread is
- thought to be running. */
+ thought to be running. */
int
inf_update_suspends (struct inf *inf)
{
struct proc *task = inf->task;
+
/* We don't have to update INF->threads even though we're iterating over it
because we'll change a thread only if it already has an existing proc
entry. */
-
inf_debug (inf, "updating suspend counts");
if (task)
@@ -970,10 +966,11 @@ inf_tid_to_thread (struct inf *inf, int tid)
}
/* Converts a thread port to a struct proc. */
-struct proc *
+static struct proc *
inf_port_to_thread (struct inf *inf, mach_port_t port)
{
struct proc *thread = inf->threads;
+
while (thread)
if (thread->port == port)
return thread;
@@ -982,6 +979,17 @@ inf_port_to_thread (struct inf *inf, mach_port_t port)
return 0;
}
+/* See gnu-nat.h. */
+
+void
+inf_threads (struct inf *inf, inf_threads_ftype *f, void *arg)
+{
+ struct proc *thread;
+
+ for (thread = inf->threads; thread; thread = thread->next)
+ f (thread, arg);
+}
+
/* Make INF's list of threads be consistent with reality of TASK. */
void
@@ -1000,6 +1008,7 @@ inf_validate_procs (struct inf *inf)
if (task)
{
error_t err = task_threads (task->port, &threads, &num_threads);
+
inf_debug (inf, "fetching threads");
if (err)
/* TASK must be dead. */
@@ -1022,7 +1031,7 @@ inf_validate_procs (struct inf *inf)
struct proc *matched[num_threads + 1];
/* The last thread in INF->threads, so we can add to the end. */
struct proc *last = 0;
- /* The current thread we're considering. */
+ /* The current thread we're considering. */
struct proc *thread = inf->threads;
memset (matched, 0, sizeof (matched));
@@ -1074,9 +1083,9 @@ inf_validate_procs (struct inf *inf)
else
inf->threads = thread;
last = thread;
- proc_debug (thread, "new thread: %d", threads[i]);
+ proc_debug (thread, "new thread: %lu", threads[i]);
- ptid = ptid_build (inf->pid, 0, thread->tid);
+ ptid = ptid_build (inf->pid, thread->tid, 0);
/* Tell GDB's generic thread code. */
@@ -1117,6 +1126,7 @@ inf_set_threads_resume_sc (struct inf *inf,
struct proc *run_thread, int run_others)
{
struct proc *thread;
+
inf_update_procs (inf);
for (thread = inf->threads; thread; thread = thread->next)
if (thread == run_thread)
@@ -1245,7 +1255,7 @@ inf_detach (struct inf *inf)
if (inf->nomsg)
inf_continue (inf);
else
- inf_signal (inf, TARGET_SIGNAL_0);
+ inf_signal (inf, GDB_SIGNAL_0);
}
proc_restore_exc_port (task);
@@ -1277,7 +1287,7 @@ inf_attach (struct inf *inf, int pid)
}
-/* Makes sure that we've got our exception ports entrenched in the process. */
+/* Makes sure that we've got our exception ports entrenched in the process. */
void
inf_steal_exc_ports (struct inf *inf)
{
@@ -1285,7 +1295,7 @@ inf_steal_exc_ports (struct inf *inf)
inf_debug (inf, "stealing exception ports");
- inf_set_step_thread (inf, 0); /* The step thread is special. */
+ inf_set_step_thread (inf, 0); /* The step thread is special. */
proc_steal_exc_port (inf->task, inf->event_port);
for (thread = inf->threads; thread; thread = thread->next)
@@ -1300,7 +1310,7 @@ inf_restore_exc_ports (struct inf *inf)
inf_debug (inf, "restoring exception ports");
- inf_set_step_thread (inf, 0); /* The step thread is special. */
+ inf_set_step_thread (inf, 0); /* The step thread is special. */
proc_restore_exc_port (inf->task);
for (thread = inf->threads; thread; thread = thread->next)
@@ -1312,12 +1322,12 @@ inf_restore_exc_ports (struct inf *inf)
signal 0, will continue it. INF is assumed to be in a paused state, and
the resume_sc's of INF's threads may be affected. */
void
-inf_signal (struct inf *inf, enum target_signal sig)
+inf_signal (struct inf *inf, enum gdb_signal sig)
{
error_t err = 0;
- int host_sig = target_signal_to_host (sig);
+ int host_sig = gdb_signal_to_host (sig);
-#define NAME target_signal_to_name (sig)
+#define NAME gdb_signal_to_name (sig)
if (host_sig >= _NSIG)
/* A mach exception. Exceptions are encoded in the signal space by
@@ -1325,6 +1335,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
extremely large)! */
{
struct inf_wait *w = &inf->wait;
+
if (w->status.kind == TARGET_WAITKIND_STOPPED
&& w->status.value.sig == sig
&& w->thread && !w->thread->aborted)
@@ -1335,8 +1346,9 @@ inf_signal (struct inf *inf, enum target_signal sig)
i.e., we pretend it's global. */
{
struct exc_state *e = &w->exc;
+
inf_debug (inf, "passing through exception:"
- " task = %d, thread = %d, exc = %d"
+ " task = %lu, thread = %lu, exc = %d"
", code = %d, subcode = %d",
w->thread->port, inf->task->port,
e->exception, e->code, e->subcode);
@@ -1375,7 +1387,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
run, and wait for it to get into a reasonable state before we
can continue the rest of the process. When we finally resume the
process the signal we request will be the very first thing that
- happens. */
+ happens. */
{
inf_debug (inf, "sending %s to unstopped process"
" (so resuming signal thread)", NAME);
@@ -1386,7 +1398,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
}
if (err == EIEIO)
- /* Can't do too much... */
+ /* Can't do too much... */
warning (_("Can't deliver signal %s: No signal thread."), NAME);
else if (err)
warning (_("Delivering signal %s: %s"), NAME, safe_strerror (err));
@@ -1431,7 +1443,7 @@ struct inf *gnu_current_inf = 0;
multi-threaded, we don't bother to lock this. */
struct inf *waiting_inf;
-/* Wait for something to happen in the inferior, returning what in STATUS. */
+/* Wait for something to happen in the inferior, returning what in STATUS. */
static ptid_t
gnu_wait (struct target_ops *ops,
ptid_t ptid, struct target_waitstatus *status, int options)
@@ -1475,7 +1487,7 @@ rewait:
if (proc_wait_pid)
/* The proc server is single-threaded, and only allows a single
- outstanding wait request, so we have to cancel the previous one. */
+ outstanding wait request, so we have to cancel the previous one. */
{
inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);
interrupt_operation (proc_server, 0);
@@ -1493,7 +1505,7 @@ rewait:
get any other replies, because it was either from a
different INF, or a different process attached to INF --
and the event port, which is the wait reply port, changes
- when you switch processes. */
+ when you switch processes. */
proc_waits_pending = 1;
}
}
@@ -1559,24 +1571,14 @@ rewait:
while execing. */
{
w->suppress = 1;
- inf_debug (inf, "pending_execs = %d, ignoring minor event",
- inf->pending_execs);
+ inf_debug (inf, "pending_execs, ignoring minor event");
}
else if (kind == TARGET_WAITKIND_STOPPED
- && w->status.value.sig == TARGET_SIGNAL_TRAP)
+ && w->status.value.sig == GDB_SIGNAL_TRAP)
/* Ah hah! A SIGTRAP from the inferior while starting up probably
means we've succesfully completed an exec! */
{
- if (--inf->pending_execs == 0)
- /* We're done! */
- {
-#if 0 /* do we need this? */
- prune_threads (1); /* Get rid of the old shell threads */
- renumber_threads (0); /* Give our threads reasonable names. */
-#endif
- }
- inf_debug (inf, "pending exec completed, pending_execs => %d",
- inf->pending_execs);
+ inf_debug (inf, "one pending exec completed");
}
else if (kind == TARGET_WAITKIND_STOPPED)
/* It's possible that this signal is because of a crashed process
@@ -1601,17 +1603,19 @@ rewait:
thread = inf->wait.thread;
if (thread)
- ptid = ptid_build (inf->pid, 0, thread->tid);
+ ptid = ptid_build (inf->pid, thread->tid, 0);
else if (ptid_equal (ptid, minus_one_ptid))
thread = inf_tid_to_thread (inf, -1);
else
- thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
+ thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
if (!thread || thread->port == MACH_PORT_NULL)
{
/* TID is dead; try and find a new thread. */
if (inf_update_procs (inf) && inf->threads)
- ptid = ptid_build (inf->pid, 0, inf->threads->tid); /* The first available thread. */
+ ptid = ptid_build (inf->pid, inf->threads->tid, 0); /* The first
+ available
+ thread. */
else
ptid = inferior_ptid; /* let wait_for_inferior handle exit case */
}
@@ -1651,7 +1655,7 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
struct proc *thread = inf_port_to_thread (inf, thread_port);
inf_debug (waiting_inf,
- "thread = %d, task = %d, exc = %d, code = %d, subcode = %d",
+ "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
thread_port, task_port, exception, code, subcode);
if (!thread)
@@ -1679,7 +1683,7 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
if (exception == EXC_BREAKPOINT)
/* GDB likes to get SIGTRAP for breakpoints. */
{
- inf->wait.status.value.sig = TARGET_SIGNAL_TRAP;
+ inf->wait.status.value.sig = GDB_SIGNAL_TRAP;
mach_port_deallocate (mach_task_self (), reply_port);
}
else
@@ -1687,19 +1691,19 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
{
if (thread->exc_port == port)
{
- inf_debug (waiting_inf, "Handler is thread exception port <%d>",
+ inf_debug (waiting_inf, "Handler is thread exception port <%lu>",
thread->saved_exc_port);
inf->wait.exc.handler = thread->saved_exc_port;
}
else
{
- inf_debug (waiting_inf, "Handler is task exception port <%d>",
+ inf_debug (waiting_inf, "Handler is task exception port <%lu>",
inf->task->saved_exc_port);
inf->wait.exc.handler = inf->task->saved_exc_port;
gdb_assert (inf->task->exc_port == port);
}
if (inf->wait.exc.handler != MACH_PORT_NULL)
- /* Add a reference to the exception handler. */
+ /* Add a reference to the exception handler. */
mach_port_mod_refs (mach_task_self (),
inf->wait.exc.handler, MACH_PORT_RIGHT_SEND,
1);
@@ -1709,10 +1713,11 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
inf->wait.exc.subcode = subcode;
inf->wait.exc.reply = reply_port;
- /* Exceptions are encoded in the signal space by putting them after
- _NSIG; this assumes they're positive (and not extremely large)! */
+ /* Exceptions are encoded in the signal space by putting
+ them after _NSIG; this assumes they're positive (and not
+ extremely large)! */
inf->wait.status.value.sig =
- target_signal_from_host (_NSIG + exception);
+ gdb_signal_from_host (_NSIG + exception);
}
}
else
@@ -1728,12 +1733,13 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
/* Fill in INF's wait field after a task has died without giving us more
detailed information. */
-void
+static void
inf_task_died_status (struct inf *inf)
{
- warning (_("Pid %d died with unknown exit status, using SIGKILL."), inf->pid);
+ warning (_("Pid %d died with unknown exit status, using SIGKILL."),
+ inf->pid);
inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
- inf->wait.status.value.sig = TARGET_SIGNAL_KILL;
+ inf->wait.status.value.sig = GDB_SIGNAL_KILL;
}
/* Notify server routines. The only real one is dead name notification. */
@@ -1742,7 +1748,7 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
{
struct inf *inf = waiting_inf;
- inf_debug (waiting_inf, "port = %d", dead_port);
+ inf_debug (waiting_inf, "port = %lu", dead_port);
if (inf->task && inf->task->port == dead_port)
{
@@ -1760,6 +1766,7 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
else
{
struct proc *thread = inf_port_to_thread (inf, dead_port);
+
if (thread)
{
proc_debug (thread, "is dead");
@@ -1772,49 +1779,30 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
}
mach_port_deallocate (mach_task_self (), dead_port);
- inf->threads_up_to_date = 0; /* Just in case */
+ inf->threads_up_to_date = 0; /* Just in case. */
return 0;
}
-static error_t
-ill_rpc (char *fun)
-{
- warning (_("illegal rpc: %s"), fun);
- return 0;
-}
-
-error_t
-do_mach_notify_no_senders (mach_port_t notify, mach_port_mscount_t count)
-{
- return ill_rpc ("do_mach_notify_no_senders");
-}
-
-error_t
-do_mach_notify_port_deleted (mach_port_t notify, mach_port_t name)
-{
- return ill_rpc ("do_mach_notify_port_deleted");
-}
-
-error_t
-do_mach_notify_msg_accepted (mach_port_t notify, mach_port_t name)
-{
- return ill_rpc ("do_mach_notify_msg_accepted");
-}
-
-error_t
-do_mach_notify_port_destroyed (mach_port_t notify, mach_port_t name)
-{
- return ill_rpc ("do_mach_notify_port_destroyed");
-}
-
-error_t
-do_mach_notify_send_once (mach_port_t notify)
-{
- return ill_rpc ("do_mach_notify_send_once");
-}
+#define ILL_RPC(fun, ...) \
+ extern kern_return_t fun (__VA_ARGS__); \
+ kern_return_t fun (__VA_ARGS__) \
+ { \
+ warning (_("illegal rpc: %s"), #fun); \
+ return 0; \
+ }
+ILL_RPC (do_mach_notify_no_senders,
+ mach_port_t notify, mach_port_mscount_t count)
+ILL_RPC (do_mach_notify_port_deleted,
+ mach_port_t notify, mach_port_t name)
+ILL_RPC (do_mach_notify_msg_accepted,
+ mach_port_t notify, mach_port_t name)
+ILL_RPC (do_mach_notify_port_destroyed,
+ mach_port_t notify, mach_port_t name)
+ILL_RPC (do_mach_notify_send_once,
+ mach_port_t notify)
/* Process_reply server routines. We only use process_wait_reply. */
@@ -1846,7 +1834,8 @@ S_proc_wait_reply (mach_port_t reply, error_t err,
{
if (err != EINTR)
{
- warning (_("Can't wait for pid %d: %s"), inf->pid, safe_strerror (err));
+ warning (_("Can't wait for pid %d: %s"),
+ inf->pid, safe_strerror (err));
inf->no_wait = 1;
/* Since we can't see the inferior's signals, don't trap them. */
@@ -1870,19 +1859,66 @@ S_proc_wait_reply (mach_port_t reply, error_t err,
return 0;
}
-error_t
-S_proc_setmsgport_reply (mach_port_t reply, error_t err,
- mach_port_t old_msg_port)
-{
- return ill_rpc ("S_proc_setmsgport_reply");
-}
-
-error_t
-S_proc_getmsgport_reply (mach_port_t reply, error_t err, mach_port_t msg_port)
-{
- return ill_rpc ("S_proc_getmsgport_reply");
-}
-
+ILL_RPC (S_proc_setmsgport_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ mach_port_t oldmsgport)
+ILL_RPC (S_proc_getmsgport_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ mach_port_t msgports)
+ILL_RPC (S_proc_pid2task_reply,
+ mach_port_t reply_port, kern_return_t return_code, mach_port_t task)
+ILL_RPC (S_proc_task2pid_reply,
+ mach_port_t reply_port, kern_return_t return_code, pid_t pid)
+ILL_RPC (S_proc_task2proc_reply,
+ mach_port_t reply_port, kern_return_t return_code, mach_port_t proc)
+ILL_RPC (S_proc_proc2task_reply,
+ mach_port_t reply_port, kern_return_t return_code, mach_port_t task)
+ILL_RPC (S_proc_pid2proc_reply,
+ mach_port_t reply_port, kern_return_t return_code, mach_port_t proc)
+ILL_RPC (S_proc_getprocinfo_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ int flags, procinfo_t procinfo, mach_msg_type_number_t procinfoCnt,
+ data_t threadwaits, mach_msg_type_number_t threadwaitsCnt)
+ILL_RPC (S_proc_getprocargs_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ data_t procargs, mach_msg_type_number_t procargsCnt)
+ILL_RPC (S_proc_getprocenv_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ data_t procenv, mach_msg_type_number_t procenvCnt)
+ILL_RPC (S_proc_getloginid_reply,
+ mach_port_t reply_port, kern_return_t return_code, pid_t login_id)
+ILL_RPC (S_proc_getloginpids_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ pidarray_t pids, mach_msg_type_number_t pidsCnt)
+ILL_RPC (S_proc_getlogin_reply,
+ mach_port_t reply_port, kern_return_t return_code, string_t logname)
+ILL_RPC (S_proc_getsid_reply,
+ mach_port_t reply_port, kern_return_t return_code, pid_t sid)
+ILL_RPC (S_proc_getsessionpgids_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ pidarray_t pgidset, mach_msg_type_number_t pgidsetCnt)
+ILL_RPC (S_proc_getsessionpids_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ pidarray_t pidset, mach_msg_type_number_t pidsetCnt)
+ILL_RPC (S_proc_getsidport_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ mach_port_t sessport)
+ILL_RPC (S_proc_getpgrp_reply,
+ mach_port_t reply_port, kern_return_t return_code, pid_t pgrp)
+ILL_RPC (S_proc_getpgrppids_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ pidarray_t pidset, mach_msg_type_number_t pidsetCnt)
+ILL_RPC (S_proc_get_tty_reply,
+ mach_port_t reply_port, kern_return_t return_code, mach_port_t tty)
+ILL_RPC (S_proc_getnports_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ mach_msg_type_number_t nports)
+ILL_RPC (S_proc_is_important_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ boolean_t essential)
+ILL_RPC (S_proc_get_code_reply,
+ mach_port_t reply_port, kern_return_t return_code,
+ vm_address_t start_code, vm_address_t end_code)
/* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
@@ -1899,7 +1935,7 @@ S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err)
server should like). */
{
inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
- inf->wait.status.value.sig = TARGET_SIGNAL_0;
+ inf->wait.status.value.sig = GDB_SIGNAL_0;
}
else if (err)
warning (_("Signal delivery failed: %s"), safe_strerror (err));
@@ -1916,12 +1952,8 @@ S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err)
return 0;
}
-error_t
-S_msg_sig_post_reply (mach_port_t reply, error_t err)
-{
- return ill_rpc ("S_msg_sig_post_reply");
-}
-
+ILL_RPC (S_msg_sig_post_reply,
+ mach_port_t reply, error_t err)
/* Returns the number of messages queued for the receive right PORT. */
static mach_port_msgcount_t
@@ -1929,7 +1961,7 @@ port_msgs_queued (mach_port_t port)
{
struct mach_port_status status;
error_t err =
- mach_port_get_receive_status (mach_task_self (), port, &status);
+ mach_port_get_receive_status (mach_task_self (), port, &status);
if (err)
return 0;
@@ -1952,11 +1984,11 @@ port_msgs_queued (mach_port_t port)
Note that a resume may not `take' if there are pending exceptions/&c
still unprocessed from the last resume we did (any given resume may result
- in multiple events returned by wait).
- */
+ in multiple events returned by wait). */
+
static void
gnu_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum target_signal sig)
+ ptid_t ptid, int step, enum gdb_signal sig)
{
struct proc *step_thread = 0;
int resume_all;
@@ -1967,9 +1999,9 @@ gnu_resume (struct target_ops *ops,
inf_validate_procinfo (inf);
- if (sig != TARGET_SIGNAL_0 || inf->stopped)
+ if (sig != GDB_SIGNAL_0 || inf->stopped)
{
- if (sig == TARGET_SIGNAL_0 && inf->nomsg)
+ if (sig == GDB_SIGNAL_0 && inf->nomsg)
inf_continue (inf);
else
inf_signal (inf, sig);
@@ -1981,12 +2013,12 @@ gnu_resume (struct target_ops *ops,
proc_abort (inf->wait.thread, 1);
warning (_("Aborting %s with unforwarded exception %s."),
proc_string (inf->wait.thread),
- target_signal_to_name (inf->wait.status.value.sig));
+ gdb_signal_to_name (inf->wait.status.value.sig));
}
if (port_msgs_queued (inf->event_port))
/* If there are still messages in our event queue, don't bother resuming
- the process, as we're just going to stop it right away anyway. */
+ the process, as we're just going to stop it right away anyway. */
return;
inf_update_procs (inf);
@@ -1997,14 +2029,16 @@ gnu_resume (struct target_ops *ops,
if (resume_all)
/* Allow all threads to run, except perhaps single-stepping one. */
{
- inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid));
- ptid = inferior_ptid; /* What to step. */
+ inf_debug (inf, "running all threads; tid = %d",
+ ptid_get_pid (inferior_ptid));
+ ptid = inferior_ptid; /* What to step. */
inf_set_threads_resume_sc (inf, 0, 1);
}
else
/* Just allow a single thread to run. */
{
- struct proc *thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
+ struct proc *thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
+
if (!thread)
error (_("Can't run single thread id %s: no such thread!"),
target_pid_to_str (ptid));
@@ -2014,7 +2048,7 @@ gnu_resume (struct target_ops *ops,
if (step)
{
- step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
+ step_thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
if (!step_thread)
warning (_("Can't step thread id %s: no such thread."),
target_pid_to_str (ptid));
@@ -2033,13 +2067,14 @@ static void
gnu_kill_inferior (struct target_ops *ops)
{
struct proc *task = gnu_current_inf->task;
+
if (task)
{
proc_debug (task, "terminating...");
task_terminate (task->port);
inf_set_pid (gnu_current_inf, -1);
}
- target_mourn_inferior ();
+ target_mourn_inferior (inferior_ptid);
}
/* Clean up after the inferior dies. */
@@ -2048,8 +2083,7 @@ gnu_mourn_inferior (struct target_ops *ops)
{
inf_debug (gnu_current_inf, "rip");
inf_detach (gnu_current_inf);
- unpush_target (ops);
- generic_mourn_inferior ();
+ inf_child_mourn_inferior (ops);
}
@@ -2083,7 +2117,7 @@ gnu_create_inferior (struct target_ops *ops,
struct inf *inf = cur_inf ();
int pid;
- void trace_me ()
+ void trace_me (void)
{
/* We're in the child; make this process stop as soon as it execs. */
inf_debug (inf, "tracing self");
@@ -2093,7 +2127,8 @@ gnu_create_inferior (struct target_ops *ops,
inf_debug (inf, "creating inferior");
- pid = fork_inferior (exec_file, allargs, env, trace_me, NULL, NULL, NULL);
+ pid = fork_inferior (exec_file, allargs, env, trace_me,
+ NULL, NULL, NULL, NULL);
/* Attach to the now stopped child, which is actually a shell... */
inf_debug (inf, "attaching to child: %d", pid);
@@ -2102,19 +2137,20 @@ gnu_create_inferior (struct target_ops *ops,
push_target (ops);
- inf->pending_execs = 2;
+ inf->pending_execs = 1;
inf->nomsg = 1;
inf->traced = 1;
/* Now let the child run again, knowing that it will stop
- immediately because of the ptrace. */
+ immediately because of the ptrace. */
inf_resume (inf);
/* We now have thread info. */
thread_change_ptid (inferior_ptid,
- ptid_build (inf->pid, 0, inf_pick_first_thread ()));
+ ptid_build (inf->pid, inf_pick_first_thread (), 0));
- startup_inferior (inf->pending_execs);
+ startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
+ inf->pending_execs = 0;
inf_validate_procinfo (inf);
inf_update_signal_thread (inf);
@@ -2132,19 +2168,16 @@ gnu_create_inferior (struct target_ops *ops,
/* Attach to process PID, then initialize for debugging it
and wait for the trace-trap that results from attaching. */
static void
-gnu_attach (struct target_ops *ops, char *args, int from_tty)
+gnu_attach (struct target_ops *ops, const char *args, int from_tty)
{
int pid;
char *exec_file;
struct inf *inf = cur_inf ();
struct inferior *inferior;
- if (!args)
- error_no_arg (_("process-id to attach"));
-
- pid = atoi (args);
+ pid = parse_pid_to_attach (args);
- if (pid == getpid ()) /* Trying to masturbate? */
+ if (pid == getpid ()) /* Trying to masturbate? */
error (_("I refuse to debug myself!"));
if (from_tty)
@@ -2166,12 +2199,13 @@ gnu_attach (struct target_ops *ops, char *args, int from_tty)
push_target (ops);
- inferior = add_inferior (pid);
+ inferior = current_inferior ();
+ inferior_appeared (inferior, pid);
inferior->attach_flag = 1;
inf_update_procs (inf);
- inferior_ptid = ptid_build (pid, 0, inf_pick_first_thread ());
+ inferior_ptid = ptid_build (pid, inf_pick_first_thread (), 0);
/* We have to initialize the terminal settings now, since the code
below might try to restore them. */
@@ -2184,8 +2218,8 @@ gnu_attach (struct target_ops *ops, char *args, int from_tty)
inf_update_signal_thread (inf);
inf_set_traced (inf, inf->want_signals);
-#if 0 /* Do we need this? */
- renumber_threads (0); /* Give our threads reasonable names. */
+#if 0 /* Do we need this? */
+ renumber_threads (0); /* Give our threads reasonable names. */
#endif
}
@@ -2198,13 +2232,14 @@ gnu_attach (struct target_ops *ops, char *args, int from_tty)
previously attached. It *might* work if the program was
started via fork. */
static void
-gnu_detach (struct target_ops *ops, char *args, int from_tty)
+gnu_detach (struct target_ops *ops, const char *args, int from_tty)
{
int pid;
if (from_tty)
{
char *exec_file = get_exec_file (0);
+
if (exec_file)
printf_unfiltered ("Detaching from program `%s' pid %d\n",
exec_file, gnu_current_inf->pid);
@@ -2220,18 +2255,18 @@ gnu_detach (struct target_ops *ops, char *args, int from_tty)
inferior_ptid = null_ptid;
detach_inferior (pid);
- unpush_target (ops); /* Pop out of handling an inferior */
+ inf_child_maybe_unpush_target (ops);
}
static void
-gnu_terminal_init_inferior (void)
+gnu_terminal_init (struct target_ops *self)
{
gdb_assert (gnu_current_inf);
- terminal_init_inferior_with_pgrp (gnu_current_inf->pid);
+ child_terminal_init_with_pgrp (gnu_current_inf->pid);
}
static void
-gnu_stop (ptid_t ptid)
+gnu_stop (struct target_ops *self, ptid_t ptid)
{
error (_("to_stop target function not implemented"));
}
@@ -2241,29 +2276,30 @@ gnu_thread_alive (struct target_ops *ops, ptid_t ptid)
{
inf_update_procs (gnu_current_inf);
return !!inf_tid_to_thread (gnu_current_inf,
- ptid_get_tid (ptid));
+ ptid_get_lwp (ptid));
}
/* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
gdb's address space. Return 0 on failure; number of bytes read
otherwise. */
-int
-gnu_read_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
+static int
+gnu_read_inferior (task_t task, CORE_ADDR addr, gdb_byte *myaddr, int length)
{
error_t err;
vm_address_t low_address = (vm_address_t) trunc_page (addr);
vm_size_t aligned_length =
(vm_size_t) round_page (addr + length) - low_address;
pointer_t copied;
- int copy_count;
+ mach_msg_type_number_t copy_count;
- /* Get memory from inferior with page aligned addresses */
+ /* Get memory from inferior with page aligned addresses. */
err = vm_read (task, low_address, aligned_length, &copied, ©_count);
if (err)
return 0;
- err = hurd_safe_copyin (myaddr, (void *) (addr - low_address + copied), length);
+ err = hurd_safe_copyin (myaddr, (void *) (addr - low_address + copied),
+ length);
if (err)
{
warning (_("Read from inferior faulted: %s"), safe_strerror (err));
@@ -2272,7 +2308,8 @@ gnu_read_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
err = vm_deallocate (mach_task_self (), copied, copy_count);
if (err)
- warning (_("gnu_read_inferior vm_deallocate failed: %s"), safe_strerror (err));
+ warning (_("gnu_read_inferior vm_deallocate failed: %s"),
+ safe_strerror (err));
return length;
}
@@ -2292,23 +2329,24 @@ struct obstack region_obstack;
/* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
task's address space. */
-int
-gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
+static int
+gnu_write_inferior (task_t task, CORE_ADDR addr,
+ const gdb_byte *myaddr, int length)
{
error_t err = 0;
vm_address_t low_address = (vm_address_t) trunc_page (addr);
vm_size_t aligned_length =
(vm_size_t) round_page (addr + length) - low_address;
pointer_t copied;
- int copy_count;
+ mach_msg_type_number_t copy_count;
int deallocate = 0;
char *errstr = "Bug in gnu_write_inferior";
struct vm_region_list *region_element;
- struct vm_region_list *region_head = (struct vm_region_list *) NULL;
+ struct vm_region_list *region_head = NULL;
- /* Get memory from inferior with page aligned addresses */
+ /* Get memory from inferior with page aligned addresses. */
err = vm_read (task,
low_address,
aligned_length,
@@ -2354,10 +2392,10 @@ gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
&offset);
CHK_GOTO_OUT ("vm_region failed", err);
- /* Check for holes in memory */
+ /* Check for holes in memory. */
if (old_address != region_address)
{
- warning (_("No memory at 0x%x. Nothing written"),
+ warning (_("No memory at 0x%lx. Nothing written"),
old_address);
err = KERN_SUCCESS;
length = 0;
@@ -2366,23 +2404,22 @@ gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
if (!(max_protection & VM_PROT_WRITE))
{
- warning (_("Memory at address 0x%x is unwritable. Nothing written"),
+ warning (_("Memory at address 0x%lx is unwritable. "
+ "Nothing written"),
old_address);
err = KERN_SUCCESS;
length = 0;
goto out;
}
- /* Chain the regions for later use */
- region_element =
- (struct vm_region_list *)
- obstack_alloc (®ion_obstack, sizeof (struct vm_region_list));
+ /* Chain the regions for later use. */
+ region_element = XOBNEW (®ion_obstack, struct vm_region_list);
region_element->protection = protection;
region_element->start = region_address;
region_element->length = region_length;
- /* Chain the regions along with protections */
+ /* Chain the regions along with protections. */
region_element->next = region_head;
region_head = region_element;
@@ -2393,7 +2430,7 @@ gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
/* If things fail after this, we give up.
Somebody is messing up inferior_task's mappings. */
- /* Enable writes to the chained vm regions */
+ /* Enable writes to the chained vm regions. */
for (scan = region_head; scan; scan = scan->next)
{
if (!(scan->protection & VM_PROT_WRITE))
@@ -2413,7 +2450,7 @@ gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
aligned_length);
CHK_GOTO_OUT ("vm_write failed", err);
- /* Set up the original region protections, if they were changed */
+ /* Set up the original region protections, if they were changed. */
for (scan = region_head; scan; scan = scan->next)
{
if (!(scan->protection & VM_PROT_WRITE))
@@ -2448,40 +2485,68 @@ out:
}
-/* Return 0 on failure, number of bytes handled otherwise. TARGET
- is ignored. */
-static int
-gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
- struct mem_attrib *attrib,
- struct target_ops *target)
+
+/* Implement the to_xfer_partial target_ops method for
+ TARGET_OBJECT_MEMORY. */
+
+static enum target_xfer_status
+gnu_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
+ CORE_ADDR memaddr, ULONGEST len, ULONGEST *xfered_len)
{
task_t task = (gnu_current_inf
? (gnu_current_inf->task
? gnu_current_inf->task->port : 0)
: 0);
+ int res;
if (task == MACH_PORT_NULL)
- return 0;
+ return TARGET_XFER_E_IO;
+
+ if (writebuf != NULL)
+ {
+ inf_debug (gnu_current_inf, "writing %s[%s] <-- %s",
+ paddress (target_gdbarch (), memaddr), pulongest (len),
+ host_address_to_string (writebuf));
+ res = gnu_write_inferior (task, memaddr, writebuf, len);
+ }
else
{
- inf_debug (gnu_current_inf, "%s %s[%d] %s %s",
- write ? "writing" : "reading",
- paddress (target_gdbarch, memaddr), len,
- write ? "<--" : "-->", host_address_to_string (myaddr));
- if (write)
- return gnu_write_inferior (task, memaddr, myaddr, len);
- else
- return gnu_read_inferior (task, memaddr, myaddr, len);
+ inf_debug (gnu_current_inf, "reading %s[%s] --> %s",
+ paddress (target_gdbarch (), memaddr), pulongest (len),
+ host_address_to_string (readbuf));
+ res = gnu_read_inferior (task, memaddr, readbuf, len);
+ }
+ gdb_assert (res >= 0);
+ if (res == 0)
+ return TARGET_XFER_E_IO;
+ else
+ {
+ *xfered_len = (ULONGEST) res;
+ return TARGET_XFER_OK;
+ }
+}
+
+/* Target to_xfer_partial implementation. */
+
+static enum target_xfer_status
+gnu_xfer_partial (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
+{
+ switch (object)
+ {
+ case TARGET_OBJECT_MEMORY:
+ return gnu_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
+ default:
+ return TARGET_XFER_E_IO;
}
}
/* Call FUNC on each memory region in the task. */
static int
-gnu_find_memory_regions (int (*func) (CORE_ADDR,
- unsigned long,
- int, int, int,
- void *),
- void *data)
+gnu_find_memory_regions (struct target_ops *self,
+ find_memory_region_ftype func, void *data)
{
error_t err;
task_t task;
@@ -2538,6 +2603,7 @@ gnu_find_memory_regions (int (*func) (CORE_ADDR,
last_protection & VM_PROT_READ,
last_protection & VM_PROT_WRITE,
last_protection & VM_PROT_EXECUTE,
+ 1, /* MODIFIED is unknown, pass it as true. */
data);
last_region_address = region_address;
last_region_end = region_address += region_length;
@@ -2551,6 +2617,7 @@ gnu_find_memory_regions (int (*func) (CORE_ADDR,
last_protection & VM_PROT_READ,
last_protection & VM_PROT_WRITE,
last_protection & VM_PROT_EXECUTE,
+ 1, /* MODIFIED is unknown, pass it as true. */
data);
return 0;
@@ -2562,11 +2629,12 @@ char *
proc_string (struct proc *proc)
{
static char tid_str[80];
+
if (proc_is_task (proc))
- sprintf (tid_str, "process %d", proc->inf->pid);
+ xsnprintf (tid_str, sizeof (tid_str), "process %d", proc->inf->pid);
else
- sprintf (tid_str, "Thread %d.%d",
- proc->inf->pid, proc->tid);
+ xsnprintf (tid_str, sizeof (tid_str), "Thread %d.%d",
+ proc->inf->pid, proc->tid);
return tid_str;
}
@@ -2574,7 +2642,7 @@ static char *
gnu_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
struct inf *inf = gnu_current_inf;
- int tid = ptid_get_tid (ptid);
+ int tid = ptid_get_lwp (ptid);
struct proc *thread = inf_tid_to_thread (inf, tid);
if (thread)
@@ -2582,7 +2650,8 @@ gnu_pid_to_str (struct target_ops *ops, ptid_t ptid)
else
{
static char tid_str[80];
- sprintf (tid_str, "bogus thread id %d", tid);
+
+ xsnprintf (tid_str, sizeof (tid_str), "bogus thread id %d", tid);
return tid_str;
}
}
@@ -2596,18 +2665,14 @@ gnu_target (void)
{
struct target_ops *t = inf_child_target ();
- t->to_shortname = "GNU";
- t->to_longname = "GNU Hurd process";
- t->to_doc = "GNU Hurd process";
-
t->to_attach = gnu_attach;
t->to_attach_no_wait = 1;
t->to_detach = gnu_detach;
t->to_resume = gnu_resume;
t->to_wait = gnu_wait;
- t->deprecated_xfer_memory = gnu_xfer_memory;
+ t->to_xfer_partial = gnu_xfer_partial;
t->to_find_memory_regions = gnu_find_memory_regions;
- t->to_terminal_init = gnu_terminal_init_inferior;
+ t->to_terminal_init = gnu_terminal_init;
t->to_kill = gnu_kill_inferior;
t->to_create_inferior = gnu_create_inferior;
t->to_mourn_inferior = gnu_mourn_inferior;
@@ -2621,8 +2686,8 @@ gnu_target (void)
/* User task commands. */
-struct cmd_list_element *set_task_cmd_list = 0;
-struct cmd_list_element *show_task_cmd_list = 0;
+static struct cmd_list_element *set_task_cmd_list = 0;
+static struct cmd_list_element *show_task_cmd_list = 0;
/* User thread commands. */
/* Commands with a prefix of `set/show thread'. */
@@ -2637,25 +2702,29 @@ struct cmd_list_element *show_thread_default_cmd_list = NULL;
static void
set_thread_cmd (char *args, int from_tty)
{
- printf_unfiltered ("\"set thread\" must be followed by the name of a thread property, or \"default\".\n");
+ printf_unfiltered ("\"set thread\" must be followed by the "
+ "name of a thread property, or \"default\".\n");
}
static void
show_thread_cmd (char *args, int from_tty)
{
- printf_unfiltered ("\"show thread\" must be followed by the name of a thread property, or \"default\".\n");
+ printf_unfiltered ("\"show thread\" must be followed by the "
+ "name of a thread property, or \"default\".\n");
}
static void
set_thread_default_cmd (char *args, int from_tty)
{
- printf_unfiltered ("\"set thread default\" must be followed by the name of a thread property.\n");
+ printf_unfiltered ("\"set thread default\" must be followed "
+ "by the name of a thread property.\n");
}
static void
show_thread_default_cmd (char *args, int from_tty)
{
- printf_unfiltered ("\"show thread default\" must be followed by the name of a thread property.\n");
+ printf_unfiltered ("\"show thread default\" must be followed "
+ "by the name of a thread property.\n");
}
static int
@@ -2665,10 +2734,12 @@ parse_int_arg (char *args, char *cmd_prefix)
{
char *arg_end;
int val = strtoul (args, &arg_end, 10);
+
if (*args && *arg_end == '\0')
return val;
}
- error (_("Illegal argument for \"%s\" command, should be an integer."), cmd_prefix);
+ error (_("Illegal argument for \"%s\" command, should be an integer."),
+ cmd_prefix);
}
static int
@@ -2679,7 +2750,8 @@ _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
else if (strcmp (args, f_val) == 0)
return 0;
else
- error (_("Illegal argument for \"%s\" command, should be \"%s\" or \"%s\"."),
+ error (_("Illegal argument for \"%s\" command, "
+ "should be \"%s\" or \"%s\"."),
cmd_prefix, t_val, f_val);
}
@@ -2699,7 +2771,7 @@ cur_thread (void)
{
struct inf *inf = cur_inf ();
struct proc *thread = inf_tid_to_thread (inf,
- ptid_get_tid (inferior_ptid));
+ ptid_get_lwp (inferior_ptid));
if (!thread)
error (_("No current thread."));
return thread;
@@ -2710,6 +2782,7 @@ static struct inf *
active_inf (void)
{
struct inf *inf = cur_inf ();
+
if (!inf->task)
error (_("No current process."));
return inf;
@@ -2734,6 +2807,7 @@ static void
show_task_pause_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show task pause");
printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
inf->task
@@ -2744,14 +2818,16 @@ show_task_pause_cmd (char *args, int from_tty)
static void
set_task_detach_sc_cmd (char *args, int from_tty)
{
- cur_inf ()->detach_sc = parse_int_arg (args, "set task detach-suspend-count");
+ cur_inf ()->detach_sc = parse_int_arg (args,
+ "set task detach-suspend-count");
}
static void
show_task_detach_sc_cmd (char *args, int from_tty)
{
check_empty (args, "show task detach-suspend-count");
- printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n",
+ printf_unfiltered ("The inferior task will be left with a "
+ "suspend count of %d when detaching.\n",
cur_inf ()->detach_sc);
}
@@ -2760,6 +2836,7 @@ static void
set_thread_default_pause_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
inf->default_thread_pause_sc =
parse_bool_arg (args, "set thread default pause") ? 0 : 1;
}
@@ -2769,6 +2846,7 @@ show_thread_default_pause_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
int sc = inf->default_thread_pause_sc;
+
check_empty (args, "show thread default pause");
printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
sc ? "are" : "aren't",
@@ -2779,6 +2857,7 @@ static void
set_thread_default_run_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
inf->default_thread_run_sc =
parse_bool_arg (args, "set thread default run") ? 0 : 1;
}
@@ -2787,6 +2866,7 @@ static void
show_thread_default_run_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show thread default run");
printf_unfiltered ("New threads %s allowed to run.\n",
inf->default_thread_run_sc == 0 ? "are" : "aren't");
@@ -2824,7 +2904,7 @@ steal_exc_port (struct proc *proc, mach_port_t name)
name, MACH_MSG_TYPE_COPY_SEND,
&port, &port_type);
if (err)
- error (_("Couldn't extract send right %d from inferior: %s"),
+ error (_("Couldn't extract send right %lu from inferior: %s"),
name, safe_strerror (err));
if (proc->saved_exc_port)
@@ -2834,8 +2914,9 @@ steal_exc_port (struct proc *proc, mach_port_t name)
proc->saved_exc_port = port;
if (!proc->exc_port)
- /* If PROC is a thread, we may not have set its exception port before.
- We can't use proc_steal_exc_port because it also sets saved_exc_port. */
+ /* If PROC is a thread, we may not have set its exception port
+ before. We can't use proc_steal_exc_port because it also sets
+ saved_exc_port. */
{
proc->exc_port = proc->inf->event_port;
err = proc_set_exception_port (proc, proc->exc_port);
@@ -2848,6 +2929,7 @@ static void
set_task_exc_port_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
if (!args)
error (_("No argument to \"set task exception-port\" command."));
steal_exc_port (inf->task, parse_and_eval_address (args));
@@ -2863,6 +2945,7 @@ static void
show_stopped_cmd (char *args, int from_tty)
{
struct inf *inf = active_inf ();
+
check_empty (args, "show stopped");
printf_unfiltered ("The inferior process %s stopped.\n",
inf->stopped ? "is" : "isn't");
@@ -2881,11 +2964,13 @@ set_sig_thread_cmd (char *args, int from_tty)
inf->signal_thread = 0;
else
{
- int tid = ptid_get_tid (thread_id_to_pid (atoi (args)));
- if (tid < 0)
- error (_("Thread ID %s not known. Use the \"info threads\" command to\n"
+ ptid_t ptid = thread_id_to_pid (atoi (args));
+
+ if (ptid_equal (ptid, minus_one_ptid))
+ error (_("Thread ID %s not known. "
+ "Use the \"info threads\" command to\n"
"see the IDs of currently known threads."), args);
- inf->signal_thread = inf_tid_to_thread (inf, tid);
+ inf->signal_thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
}
}
@@ -2893,6 +2978,7 @@ static void
show_sig_thread_cmd (char *args, int from_tty)
{
struct inf *inf = active_inf ();
+
check_empty (args, "show signal-thread");
if (inf->signal_thread)
printf_unfiltered ("The signal thread is %s.\n",
@@ -2918,6 +3004,7 @@ static void
show_signals_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show signals");
printf_unfiltered ("The inferior process's signals %s intercepted.\n",
inf->task
@@ -2931,9 +3018,8 @@ set_exceptions_cmd (char *args, int from_tty)
struct inf *inf = cur_inf ();
int val = parse_bool_arg (args, "set exceptions");
- if (inf->task && inf->want_exceptions != val)
- /* Make this take effect immediately in a running process. */
- /* XXX */ ;
+ /* Make this take effect immediately in a running process. */
+ /* XXX */ ;
inf->want_exceptions = val;
}
@@ -2942,6 +3028,7 @@ static void
show_exceptions_cmd (char *args, int from_tty)
{
struct inf *inf = cur_inf ();
+
check_empty (args, "show exceptions");
printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
inf->task
@@ -2998,7 +3085,7 @@ set_noninvasive_cmd (char *args, int from_tty)
static void
-info_port_rights (char *args, mach_port_type_t only)
+info_port_rights (const char *args, mach_port_type_t only)
{
struct inf *inf = active_inf ();
struct value *vmark = value_mark ();
@@ -3011,8 +3098,9 @@ info_port_rights (char *args, mach_port_type_t only)
struct value *val = parse_to_comma_and_eval (&args);
long right = value_as_long (val);
error_t err =
- print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
- stdout);
+ print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
+ stdout);
+
if (err)
error (_("%ld: %s."), right, safe_strerror (err));
}
@@ -3021,8 +3109,8 @@ info_port_rights (char *args, mach_port_type_t only)
/* Print all of them. */
{
error_t err =
- print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
- stdout);
+ print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
+ stdout);
if (err)
error (_("%s."), safe_strerror (err));
}
@@ -3149,7 +3237,8 @@ used to pause individual threads by default instead."),
_("Set the suspend count will leave on the thread when detaching."),
&set_task_cmd_list);
add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
- _("Show the suspend count will leave on the thread when detaching."),
+ _("Show the suspend count will leave "
+ "on the thread when detaching."),
&show_task_cmd_list);
add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\
@@ -3169,21 +3258,16 @@ This is the same as setting `task pause', `exceptions', and\n\
&setlist);
/* Commands to show information about the task's ports. */
- add_cmd ("send-rights", class_info, info_send_rights_cmd,
- _("Show information about the task's send rights"),
- &infolist);
- add_cmd ("receive-rights", class_info, info_recv_rights_cmd,
- _("Show information about the task's receive rights"),
- &infolist);
- add_cmd ("port-rights", class_info, info_port_rights_cmd,
- _("Show information about the task's port rights"),
- &infolist);
- add_cmd ("port-sets", class_info, info_port_sets_cmd,
- _("Show information about the task's port sets"),
- &infolist);
- add_cmd ("dead-names", class_info, info_dead_names_cmd,
- _("Show information about the task's dead names"),
- &infolist);
+ add_info ("send-rights", info_send_rights_cmd,
+ _("Show information about the task's send rights"));
+ add_info ("receive-rights", info_recv_rights_cmd,
+ _("Show information about the task's receive rights"));
+ add_info ("port-rights", info_port_rights_cmd,
+ _("Show information about the task's port rights"));
+ add_info ("port-sets", info_port_sets_cmd,
+ _("Show information about the task's port sets"));
+ add_info ("dead-names", info_dead_names_cmd,
+ _("Show information about the task's dead names"));
add_info_alias ("ports", "port-rights", 1);
add_info_alias ("port", "port-rights", 1);
add_info_alias ("psets", "port-sets", 1);
@@ -3195,6 +3279,7 @@ set_thread_pause_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
int old_sc = thread->pause_sc;
+
thread->pause_sc = parse_bool_arg (args, "set thread pause");
if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0)
/* If the task is currently unsuspended, immediately suspend it,
@@ -3207,6 +3292,7 @@ show_thread_pause_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
int sc = thread->pause_sc;
+
check_empty (args, "show task pause");
printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
proc_string (thread),
@@ -3218,6 +3304,7 @@ static void
set_thread_run_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1;
}
@@ -3225,6 +3312,7 @@ static void
show_thread_run_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
check_empty (args, "show thread run");
printf_unfiltered ("Thread %s %s allowed to run.",
proc_string (thread),
@@ -3242,6 +3330,7 @@ static void
show_thread_detach_sc_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
check_empty (args, "show thread detach-suspend-count");
printf_unfiltered ("Thread %s will be left with a suspend count"
" of %d when detaching.\n",
@@ -3253,6 +3342,7 @@ static void
set_thread_exc_port_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
if (!args)
error (_("No argument to \"set thread exception-port\" command."));
steal_exc_port (thread, parse_and_eval_address (args));
@@ -3263,6 +3353,7 @@ static void
show_thread_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
check_empty (args, "show thread");
show_thread_run_cmd (0, from_tty);
show_thread_pause_cmd (0, from_tty);
@@ -3275,6 +3366,7 @@ static void
thread_takeover_sc_cmd (char *args, int from_tty)
{
struct proc *thread = cur_thread ();
+
thread_basic_info_data_t _info;
thread_basic_info_t info = &_info;
mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
@@ -3356,6 +3448,10 @@ to the thread's initial suspend-count when gdb notices the threads."),
}
+
+/* -Wmissing-prototypes */
+extern initialize_file_ftype _initialize_gnu_nat;
+
void
_initialize_gnu_nat (void)
{
@@ -3379,7 +3475,7 @@ _initialize_gnu_nat (void)
/* When over-writing code on some machines the I-Cache must be flushed
explicitly, because it is not kept coherent by the lazy hardware.
This definitely includes breakpoints, for instance, or else we
- end up looping in mysterious Bpt traps */
+ end up looping in mysterious Bpt traps. */
void
flush_inferior_icache (CORE_ADDR pc, int amount)