/* Interface GDB to the GNU Hurd.
- Copyright (C) 1992, 1995-2001, 2006-2012 Free Software Foundation,
- Inc.
+ Copyright (C) 1992-2019 Free Software Foundation, Inc.
This file is part of GDB.
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/>.
- */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
-#include <ctype.h>
-#include <errno.h>
-#include <limits.h>
-#include <setjmp.h>
-#include <signal.h>
-#include <stdio.h>
-#include "gdb_string.h"
-#include <sys/ptrace.h>
+/* Include this first, to pick up the <mach.h> 'thread_info' diversion. */
+#include "gnu-nat.h"
+/* Mach/Hurd headers are not yet ready for C++ compilation. */
+extern "C"
+{
#include <mach.h>
#include <mach_error.h>
#include <mach/exception.h>
#include <hurd/sigpreempt.h>
#include <portinfo.h>
+}
#include "defs.h"
+
+#include <ctype.h>
+#include <limits.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <sys/ptrace.h>
+#include <elf.h>
+#include <link.h>
+
#include "inferior.h"
#include "symtab.h"
#include "value.h"
#include "language.h"
#include "target.h"
-#include "gdb_wait.h"
+#include "common/gdb_wait.h"
#include "gdbcmd.h"
#include "gdbcore.h"
#include "gdbthread.h"
-#include "gdb_assert.h"
#include "gdb_obstack.h"
+#include "tid-parse.h"
+#include "nat/fork-inferior.h"
-#include "gnu-nat.h"
#include "inf-child.h"
+/* MIG stubs are not yet ready for C++ compilation. */
+extern "C"
+{
#include "exc_request_S.h"
#include "notify_S.h"
#include "process_reply_S.h"
#include "msg_reply_S.h"
#include "exc_request_U.h"
#include "msg_U.h"
+}
static process_t proc_server = MACH_PORT_NULL;
/* 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);
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);
struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
struct proc *_proc_free (struct proc *proc);
int proc_update_sc (struct proc *proc);
-error_t proc_get_exception_port (struct proc *proc, mach_port_t * port);
-error_t proc_set_exception_port (struct proc *proc, mach_port_t port);
+kern_return_t proc_get_exception_port (struct proc *proc, mach_port_t * port);
+kern_return_t proc_set_exception_port (struct proc *proc, mach_port_t port);
static mach_port_t _proc_get_exc_port (struct proc *proc);
void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port);
void proc_restore_exc_port (struct proc *proc);
afterwards). This effects INF's threads' resume_sc count. */
#define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
(inf_set_threads_resume_sc_for_signal_thread (inf) \
- ? ({ error_t __e; \
+ ? ({ kern_return_t __e; \
inf_resume (inf); \
__e = INF_MSGPORT_RPC (inf, rpc_expr); \
inf_suspend (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. */
if (!proc->state_valid)
{
mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
- error_t err =
+ kern_return_t err =
thread_get_state (proc->port, THREAD_STATE_FLAVOR,
(thread_state_t) &proc->state, &state_size);
\f
/* Set PORT to PROC's exception port. */
-error_t
+kern_return_t
proc_get_exception_port (struct proc * proc, mach_port_t * port)
{
if (proc_is_task (proc))
}
/* Set PROC's exception port to PORT. */
-error_t
+kern_return_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
_proc_get_exc_port (struct proc *proc)
{
mach_port_t exc_port;
- error_t err = proc_get_exception_port (proc, &exc_port);
+ kern_return_t err = proc_get_exception_port (proc, &exc_port);
if (err)
/* PROC must be dead. */
if (cur_exc_port)
{
- error_t err = 0;
+ kern_return_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. */
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;
if (cur_exc_port)
{
- error_t err = 0;
+ kern_return_t err = 0;
proc_debug (proc, "restoring real exception port");
struct proc *
make_proc (struct inf *inf, mach_port_t port, int tid)
{
- error_t err;
+ kern_return_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;
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);
}
}
\f
-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;
void
inf_startup (struct inf *inf, int pid)
{
- error_t err;
+ kern_return_t err;
inf_debug (inf, "startup: pid = %d", pid);
task_port = MACH_PORT_NULL;
else
{
- error_t err = proc_pid2task (proc_server, pid, &task_port);
+ kern_return_t err = proc_pid2task (proc_server, pid, &task_port);
if (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);
struct procinfo *pi;
mach_msg_type_number_t pi_len = 0;
int info_flags = 0;
- error_t err =
+ kern_return_t err =
proc_getprocinfo (proc_server, inf->pid, &info_flags,
(procinfo_t *) &pi, &pi_len, &noise, &noise_len);
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);
}
mach_msg_type_number_t pi_len = 0;
int info_flags = PI_FETCH_TASKINFO;
int suspend_count = -1;
- error_t err;
+ kern_return_t err;
retry:
err = proc_getprocinfo (proc_server, inf->pid, &info_flags,
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;
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)
/* Make it take effect immediately. */
{
sigset_t mask = on ? ~(sigset_t) 0 : 0;
- error_t err =
+ kern_return_t err =
INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
INIT_TRACEMASK, mask));
}
/* 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;
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);
+}
+
\f
/* Make INF's list of threads be consistent with reality of TASK. */
void
if (task)
{
- error_t err = task_threads (task->port, &threads, &num_threads);
+ kern_return_t err = task_threads (task->port, &threads, &num_threads);
inf_debug (inf, "fetching threads");
if (err)
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_t (inf->pid, thread->tid, 0);
/* Tell GDB's generic thread code. */
- if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid)))
+ if (inferior_ptid == ptid_t (inf->pid))
/* This is the first time we're hearing about thread
ids, after a fork-child. */
thread_change_ptid (inferior_ptid, ptid);
void
inf_signal (struct inf *inf, enum gdb_signal sig)
{
- error_t err = 0;
+ kern_return_t err = 0;
int host_sig = gdb_signal_to_host (sig);
#define NAME gdb_signal_to_name (sig)
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);
inf_continue (struct inf *inf)
{
process_t proc;
- error_t err = proc_pid2proc (proc_server, inf->pid, &proc);
+ kern_return_t err = proc_pid2proc (proc_server, inf->pid, &proc);
if (!err)
{
multi-threaded, we don't bother to lock this. */
struct inf *waiting_inf;
+/* MIG stubs are not yet ready for C++ compilation. */
+extern "C" int exc_server (mach_msg_header_t *, mach_msg_header_t *);
+extern "C" int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
+extern "C" int notify_server (mach_msg_header_t *, mach_msg_header_t *);
+extern "C" int process_reply_server (mach_msg_header_t *, mach_msg_header_t *);
+
/* 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)
+
+ptid_t
+gnu_nat_target::wait (ptid_t ptid, struct target_waitstatus *status,
+ int options)
{
struct msg
{
mach_msg_type_t type;
int data[8000];
} msg;
- error_t err;
+ kern_return_t err;
struct proc *thread;
struct inf *inf = gnu_current_inf;
- extern int exc_server (mach_msg_header_t *, mach_msg_header_t *);
- extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
- extern int notify_server (mach_msg_header_t *, mach_msg_header_t *);
- extern int process_reply_server (mach_msg_header_t *, mach_msg_header_t *);
-
gdb_assert (inf->task);
if (!inf->threads && !inf->pending_execs)
waiting_inf = inf;
- inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
+ inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid).c_str ());
rewait:
if (proc_wait_pid != inf->pid && !inf->no_wait)
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 == 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
thread = inf->wait.thread;
if (thread)
- ptid = ptid_build (inf->pid, 0, thread->tid);
- else if (ptid_equal (ptid, minus_one_ptid))
+ ptid = ptid_t (inf->pid, thread->tid, 0);
+ else if (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.lwp ());
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
+ ptid = ptid_t (inf->pid, inf->threads->tid, 0); /* The first
available
thread. */
else
}
if (thread
- && !ptid_equal (ptid, minus_one_ptid)
+ && ptid != minus_one_ptid
&& status->kind != TARGET_WAITKIND_SPURIOUS
&& inf->pause_sc == 0 && thread->pause_sc == 0)
/* If something actually happened to THREAD, make sure we
inf_update_suspends (inf);
}
- inf_debug (inf, "returning ptid = %s, status = %s (%d)",
- target_pid_to_str (ptid),
- status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
- : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
- : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
- : status->kind == TARGET_WAITKIND_LOADED ? "LOADED"
- : status->kind == TARGET_WAITKIND_SPURIOUS ? "SPURIOUS"
- : "?",
- status->value.integer);
+ inf_debug (inf, "returning ptid = %s, %s",
+ target_pid_to_str (ptid).c_str (),
+ target_waitstatus_to_string (status).c_str ());
return ptid;
}
\f
/* The rpc handler called by exc_server. */
-error_t
+kern_return_t
S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
thread_t thread_port, task_t task_port,
int exception, int code, int subcode)
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)
{
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);
\f
/* 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."),
}
/* Notify server routines. The only real one is dead name notification. */
-error_t
+kern_return_t
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)
{
}
\f
-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)
\f
/* Process_reply server routines. We only use process_wait_reply. */
-error_t
-S_proc_wait_reply (mach_port_t reply, error_t err,
+kern_return_t
+S_proc_wait_reply (mach_port_t reply, kern_return_t err,
int status, int sigcode, rusage_t rusage, pid_t pid)
{
struct inf *inf = waiting_inf;
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, mach_msg_type_name_t msgportsPoly)
+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, mach_msg_type_name_t procPoly)
+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, mach_msg_type_name_t procPoly)
+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)
\f
/* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
-error_t
-S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err)
+kern_return_t
+S_msg_sig_post_untraced_reply (mach_port_t reply, kern_return_t err)
{
struct inf *inf = waiting_inf;
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, kern_return_t err)
\f
/* Returns the number of messages queued for the receive right PORT. */
static mach_port_msgcount_t
port_msgs_queued (mach_port_t port)
{
struct mach_port_status status;
- error_t err =
+ kern_return_t err =
mach_port_get_receive_status (mach_task_self (), port, &status);
if (err)
still unprocessed from the last resume we did (any given resume may result
in multiple events returned by wait). */
-static void
-gnu_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum gdb_signal sig)
+void
+gnu_nat_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
{
struct proc *step_thread = 0;
int resume_all;
struct inf *inf = gnu_current_inf;
inf_debug (inf, "ptid = %s, step = %d, sig = %d",
- target_pid_to_str (ptid), step, sig);
+ target_pid_to_str (ptid).c_str (), step, sig);
inf_validate_procinfo (inf);
inf_update_procs (inf);
/* A specific PTID means `step only this process id'. */
- resume_all = ptid_equal (ptid, minus_one_ptid);
+ resume_all = ptid == minus_one_ptid;
if (resume_all)
/* Allow all threads to run, except perhaps single-stepping one. */
{
- inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid));
+ inf_debug (inf, "running all threads; tid = %d",
+ inferior_ptid.pid ());
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.lwp ());
if (!thread)
error (_("Can't run single thread id %s: no such thread!"),
- target_pid_to_str (ptid));
- inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));
+ target_pid_to_str (ptid).c_str ());
+ inf_debug (inf, "running one thread: %s",
+ target_pid_to_str (ptid).c_str ());
inf_set_threads_resume_sc (inf, thread, 0);
}
if (step)
{
- step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
+ step_thread = inf_tid_to_thread (inf, ptid.lwp ());
if (!step_thread)
warning (_("Can't step thread id %s: no such thread."),
- target_pid_to_str (ptid));
+ target_pid_to_str (ptid).c_str ());
else
- inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
+ inf_debug (inf, "stepping thread: %s",
+ target_pid_to_str (ptid).c_str ());
}
if (step_thread != inf->step_thread)
inf_set_step_thread (inf, step_thread);
}
\f
-static void
-gnu_kill_inferior (struct target_ops *ops)
+void
+gnu_nat_target::kill ()
{
struct proc *task = gnu_current_inf->task;
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. */
-static void
-gnu_mourn_inferior (struct target_ops *ops)
+void
+gnu_nat_target::mourn_inferior ()
{
inf_debug (gnu_current_inf, "rip");
inf_detach (gnu_current_inf);
- unpush_target (ops);
- generic_mourn_inferior ();
+ inf_child_target::mourn_inferior ();
}
\f
}
static void
-gnu_create_inferior (struct target_ops *ops,
- char *exec_file, char *allargs, char **env,
- int from_tty)
+gnu_ptrace_me (void)
{
+ /* We're in the child; make this process stop as soon as it execs. */
struct inf *inf = cur_inf ();
- int pid;
+ inf_debug (inf, "tracing self");
+ if (ptrace (PTRACE_TRACEME) != 0)
+ trace_start_error_with_name ("ptrace");
+}
- void trace_me ()
- {
- /* We're in the child; make this process stop as soon as it execs. */
- inf_debug (inf, "tracing self");
- if (ptrace (PTRACE_TRACEME) != 0)
- error (_("ptrace (PTRACE_TRACEME) failed!"));
- }
+void
+gnu_nat_target::create_inferior (const char *exec_file,
+ const std::string &allargs,
+ char **env,
+ int from_tty)
+{
+ struct inf *inf = cur_inf ();
+ int pid;
inf_debug (inf, "creating inferior");
- pid = fork_inferior (exec_file, allargs, env, trace_me,
+ pid = fork_inferior (exec_file, allargs, env, gnu_ptrace_me,
NULL, NULL, NULL, NULL);
+ /* We have something that executes now. We'll be running through
+ the shell at this point (if startup-with-shell is true), but the
+ pid shouldn't change. */
+ add_thread_silent (ptid_t (pid));
+
/* Attach to the now stopped child, which is actually a shell... */
inf_debug (inf, "attaching to child: %d", pid);
inf_attach (inf, pid);
- push_target (ops);
+ push_target (this);
- inf->pending_execs = 2;
+ inf->pending_execs = 1;
inf->nomsg = 1;
inf->traced = 1;
/* We now have thread info. */
thread_change_ptid (inferior_ptid,
- ptid_build (inf->pid, 0, inf_pick_first_thread ()));
+ ptid_t (inf->pid, inf_pick_first_thread (), 0));
+
+ gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
- startup_inferior (inf->pending_execs);
+ inf->pending_execs = 0;
+ /* Get rid of the old shell threads. */
+ prune_threads ();
inf_validate_procinfo (inf);
inf_update_signal_thread (inf);
\f
/* 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)
+void
+gnu_nat_target::attach (const char *args, int from_tty)
{
int pid;
char *exec_file;
exec_file, pid);
else
printf_unfiltered ("Attaching to pid %d\n", pid);
-
- gdb_flush (gdb_stdout);
}
inf_debug (inf, "attaching to pid: %d", pid);
inf_attach (inf, pid);
- push_target (ops);
+ push_target (this);
inferior = current_inferior ();
inferior_appeared (inferior, pid);
inf_update_procs (inf);
- inferior_ptid = ptid_build (pid, 0, inf_pick_first_thread ());
+ inferior_ptid = ptid_t (pid, inf_pick_first_thread (), 0);
/* We have to initialize the terminal settings now, since the code
below might try to restore them. */
- target_terminal_init ();
+ target_terminal::init ();
/* If the process was stopped before we attached, make it continue the next
time the user does a continue. */
to work, it may be necessary for the process to have been
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)
+void
+gnu_nat_target::detach (inferior *inf, int from_tty)
{
int pid;
exec_file, gnu_current_inf->pid);
else
printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid);
- gdb_flush (gdb_stdout);
}
pid = gnu_current_inf->pid;
inf_detach (gnu_current_inf);
inferior_ptid = null_ptid;
- detach_inferior (pid);
+ detach_inferior (find_inferior_pid (pid));
- unpush_target (ops); /* Pop out of handling an inferior. */
+ maybe_unpush_target ();
}
\f
-static void
-gnu_terminal_init_inferior (void)
-{
- gdb_assert (gnu_current_inf);
- terminal_init_inferior_with_pgrp (gnu_current_inf->pid);
-}
-static void
-gnu_stop (ptid_t ptid)
+void
+gnu_nat_target::stop (ptid_t ptid)
{
- error (_("to_stop target function not implemented"));
+ error (_("stop target function not implemented"));
}
-static int
-gnu_thread_alive (struct target_ops *ops, ptid_t ptid)
+bool
+gnu_nat_target::thread_alive (ptid_t ptid)
{
inf_update_procs (gnu_current_inf);
return !!inf_tid_to_thread (gnu_current_inf,
- ptid_get_tid (ptid));
+ ptid.lwp ());
}
\f
/* 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;
+ kern_return_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. */
err = vm_read (task, low_address, aligned_length, &copied, ©_count);
/* 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;
+ kern_return_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;
int deallocate = 0;
- char *errstr = "Bug in gnu_write_inferior";
+ const 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. */
err = vm_read (task,
/* 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;
if (!(max_protection & VM_PROT_WRITE))
{
- warning (_("Memory at address 0x%x is unwritable. "
+ warning (_("Memory at address 0x%lx is unwritable. "
"Nothing written"),
old_address);
err = KERN_SUCCESS;
}
/* Chain the regions for later use. */
- region_element =
- (struct vm_region_list *)
- obstack_alloc (®ion_obstack, sizeof (struct vm_region_list));
+ region_element = XOBNEW (®ion_obstack, struct vm_region_list);
region_element->protection = protection;
region_element->start = region_address;
}
\f
-/* 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;
+ }
+}
+
+/* GNU does not have auxv, but we can at least fake the AT_ENTRY entry for PIE
+ binaries. */
+static enum target_xfer_status
+gnu_xfer_auxv (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);
+ process_t proc;
+ int res;
+ kern_return_t err;
+ vm_address_t entry;
+ ElfW(auxv_t) auxv[2];
+
+ if (task == MACH_PORT_NULL)
+ return TARGET_XFER_E_IO;
+ if (writebuf != NULL)
+ return TARGET_XFER_E_IO;
+
+ if (memaddr == sizeof (auxv))
+ return TARGET_XFER_EOF;
+ if (memaddr > sizeof (auxv))
+ return TARGET_XFER_E_IO;
+
+ err = proc_task2proc (proc_server, task, &proc);
+ if (err != 0)
+ return TARGET_XFER_E_IO;
+
+ /* Get entry from proc server. */
+ err = proc_get_entry (proc, &entry);
+ if (err != 0)
+ return TARGET_XFER_E_IO;
+
+ /* Fake auxv entry. */
+ auxv[0].a_type = AT_ENTRY;
+ auxv[0].a_un.a_val = entry;
+ auxv[1].a_type = AT_NULL;
+ auxv[1].a_un.a_val = 0;
+
+ inf_debug (gnu_current_inf, "reading auxv %s[%s] --> %s",
+ paddress (target_gdbarch (), memaddr), pulongest (len),
+ host_address_to_string (readbuf));
+
+ if (memaddr + len > sizeof (auxv))
+ len = sizeof (auxv) - memaddr;
+
+ memcpy (readbuf, (gdb_byte *) &auxv + memaddr, len);
+ *xfered_len = len;
+
+ return TARGET_XFER_OK;
+}
+
+/* Target to_xfer_partial implementation. */
+
+enum target_xfer_status
+gnu_nat_target::xfer_partial (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);
+ case TARGET_OBJECT_AUXV:
+ return gnu_xfer_auxv (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 (find_memory_region_ftype func, void *data)
+
+int
+gnu_nat_target::find_memory_regions (find_memory_region_ftype func,
+ void *data)
{
- error_t err;
+ kern_return_t err;
task_t task;
vm_address_t region_address, last_region_address, last_region_end;
vm_prot_t last_protection;
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;
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;
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;
}
-static char *
-gnu_pid_to_str (struct target_ops *ops, ptid_t ptid)
+std::string
+gnu_nat_target::pid_to_str (ptid_t ptid)
{
struct inf *inf = gnu_current_inf;
- int tid = ptid_get_tid (ptid);
+ int tid = ptid.lwp ();
struct proc *thread = inf_tid_to_thread (inf, tid);
if (thread)
return proc_string (thread);
else
- {
- static char tid_str[80];
-
- sprintf (tid_str, "bogus thread id %d", tid);
- return tid_str;
- }
-}
-
-\f
-/* Create a prototype generic GNU/Hurd target. The client can
- override it with local methods. */
-
-struct target_ops *
-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_find_memory_regions = gnu_find_memory_regions;
- t->to_terminal_init = gnu_terminal_init_inferior;
- t->to_kill = gnu_kill_inferior;
- t->to_create_inferior = gnu_create_inferior;
- t->to_mourn_inferior = gnu_mourn_inferior;
- t->to_thread_alive = gnu_thread_alive;
- t->to_pid_to_str = gnu_pid_to_str;
- t->to_stop = gnu_stop;
-
- return t;
+ return string_printf ("bogus thread id %d", tid);
}
\f
/* 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'. */
struct cmd_list_element *show_thread_default_cmd_list = NULL;
static void
-set_thread_cmd (char *args, int from_tty)
+set_thread_cmd (const char *args, int from_tty)
{
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)
+show_thread_cmd (const char *args, int from_tty)
{
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)
+set_thread_default_cmd (const char *args, int from_tty)
{
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)
+show_thread_default_cmd (const char *args, int from_tty)
{
printf_unfiltered ("\"show thread default\" must be followed "
"by the name of a thread property.\n");
}
static int
-parse_int_arg (char *args, char *cmd_prefix)
+parse_int_arg (const char *args, const char *cmd_prefix)
{
if (args)
{
}
static int
-_parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
+_parse_bool_arg (const char *args, const char *t_val, const char *f_val,
+ const char *cmd_prefix)
{
if (!args || strcmp (args, t_val) == 0)
return 1;
_parse_bool_arg (args, "on", "off", cmd_prefix)
static void
-check_empty (char *args, char *cmd_prefix)
+check_empty (const char *args, const char *cmd_prefix)
{
if (args)
error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix, args);
{
struct inf *inf = cur_inf ();
struct proc *thread = inf_tid_to_thread (inf,
- ptid_get_tid (inferior_ptid));
+ inferior_ptid.lwp ());
if (!thread)
error (_("No current thread."));
return thread;
\f
static void
-set_task_pause_cmd (char *args, int from_tty)
+set_task_pause_cmd (int arg, int from_tty)
{
struct inf *inf = cur_inf ();
int old_sc = inf->pause_sc;
- inf->pause_sc = parse_bool_arg (args, "set task pause");
+ inf->pause_sc = arg;
if (old_sc == 0 && inf->pause_sc != 0)
/* If the task is currently unsuspended, immediately suspend it,
}
static void
-show_task_pause_cmd (char *args, int from_tty)
+set_task_pause_cmd (const char *args, int from_tty)
+{
+ set_task_pause_cmd (parse_bool_arg (args, "set task pause"), from_tty);
+}
+
+static void
+show_task_pause_cmd (const char *args, int from_tty)
{
struct inf *inf = cur_inf ();
}
static void
-set_task_detach_sc_cmd (char *args, int from_tty)
+set_task_detach_sc_cmd (const char *args, int from_tty)
{
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)
+show_task_detach_sc_cmd (const char *args, int from_tty)
{
check_empty (args, "show task detach-suspend-count");
printf_unfiltered ("The inferior task will be left with a "
\f
static void
-set_thread_default_pause_cmd (char *args, int from_tty)
+set_thread_default_pause_cmd (const char *args, int from_tty)
{
struct inf *inf = cur_inf ();
}
static void
-show_thread_default_pause_cmd (char *args, int from_tty)
+show_thread_default_pause_cmd (const char *args, int from_tty)
{
struct inf *inf = cur_inf ();
int sc = inf->default_thread_pause_sc;
}
static void
-set_thread_default_run_cmd (char *args, int from_tty)
+set_thread_default_run_cmd (const char *args, int from_tty)
{
struct inf *inf = cur_inf ();
}
static void
-show_thread_default_run_cmd (char *args, int from_tty)
+show_thread_default_run_cmd (const char *args, int from_tty)
{
struct inf *inf = cur_inf ();
}
static void
-set_thread_default_detach_sc_cmd (char *args, int from_tty)
+set_thread_default_detach_sc_cmd (const char *args, int from_tty)
{
cur_inf ()->default_thread_detach_sc =
parse_int_arg (args, "set thread default detach-suspend-count");
}
static void
-show_thread_default_detach_sc_cmd (char *args, int from_tty)
+show_thread_default_detach_sc_cmd (const char *args, int from_tty)
{
check_empty (args, "show thread default detach-suspend-count");
printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
static void
steal_exc_port (struct proc *proc, mach_port_t name)
{
- error_t err;
+ kern_return_t err;
mach_port_t port;
mach_msg_type_name_t port_type;
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)
}
static void
-set_task_exc_port_cmd (char *args, int from_tty)
+set_task_exc_port_cmd (const char *args, int from_tty)
{
struct inf *inf = cur_inf ();
}
static void
-set_stopped_cmd (char *args, int from_tty)
+set_stopped_cmd (const char *args, int from_tty)
{
cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped");
}
static void
-show_stopped_cmd (char *args, int from_tty)
+show_stopped_cmd (const char *args, int from_tty)
{
struct inf *inf = active_inf ();
}
static void
-set_sig_thread_cmd (char *args, int from_tty)
+set_sig_thread_cmd (const char *args, int from_tty)
{
struct inf *inf = cur_inf ();
if (!args || (!isdigit (*args) && strcmp (args, "none") != 0))
error (_("Illegal argument to \"set signal-thread\" command.\n"
- "Should be an integer thread ID, or `none'."));
+ "Should be a thread ID, or \"none\"."));
if (strcmp (args, "none") == 0)
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"
- "see the IDs of currently known threads."), args);
- inf->signal_thread = inf_tid_to_thread (inf, tid);
+ struct thread_info *tp = parse_thread_id (args, NULL);
+ inf->signal_thread = inf_tid_to_thread (inf, tp->ptid.lwp ());
}
}
static void
-show_sig_thread_cmd (char *args, int from_tty)
+show_sig_thread_cmd (const char *args, int from_tty)
{
struct inf *inf = active_inf ();
\f
static void
-set_signals_cmd (char *args, int from_tty)
+set_signals_cmd (int arg, int from_tty)
{
struct inf *inf = cur_inf ();
- inf->want_signals = parse_bool_arg (args, "set signals");
+ inf->want_signals = arg;
if (inf->task && inf->want_signals != inf->traced)
/* Make this take effect immediately in a running process. */
}
static void
-show_signals_cmd (char *args, int from_tty)
+set_signals_cmd (const char *args, int from_tty)
+{
+ set_signals_cmd(parse_bool_arg (args, "set signals"), from_tty);
+}
+
+static void
+show_signals_cmd (const char *args, int from_tty)
{
struct inf *inf = cur_inf ();
}
static void
-set_exceptions_cmd (char *args, int from_tty)
+set_exceptions_cmd (int arg, 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;
+ inf->want_exceptions = arg;
}
static void
-show_exceptions_cmd (char *args, int from_tty)
+set_exceptions_cmd (const char *args, int from_tty)
+{
+ set_exceptions_cmd (parse_bool_arg (args, "set exceptions"), from_tty);
+}
+
+static void
+show_exceptions_cmd (const char *args, int from_tty)
{
struct inf *inf = cur_inf ();
\f
static void
-set_task_cmd (char *args, int from_tty)
+set_task_cmd (const char *args, int from_tty)
{
printf_unfiltered ("\"set task\" must be followed by the name"
" of a task property.\n");
}
static void
-show_task_cmd (char *args, int from_tty)
+show_task_cmd (const char *args, int from_tty)
{
struct inf *inf = cur_inf ();
\f
static void
-set_noninvasive_cmd (char *args, int from_tty)
+set_noninvasive_cmd (const char *args, int from_tty)
{
/* Invert the sense of the arg for each component. */
- char *inv_args = parse_bool_arg (args, "set noninvasive") ? "off" : "on";
+ int inv_arg = parse_bool_arg (args, "set noninvasive") ? 0 : 1;
- set_task_pause_cmd (inv_args, from_tty);
- set_signals_cmd (inv_args, from_tty);
- set_exceptions_cmd (inv_args, from_tty);
+ set_task_pause_cmd (inv_arg, from_tty);
+ set_signals_cmd (inv_arg, from_tty);
+ set_exceptions_cmd (inv_arg, from_tty);
}
\f
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 ();
}
static void
-info_send_rights_cmd (char *args, int from_tty)
+info_send_rights_cmd (const char *args, int from_tty)
{
info_port_rights (args, MACH_PORT_TYPE_SEND);
}
static void
-info_recv_rights_cmd (char *args, int from_tty)
+info_recv_rights_cmd (const char *args, int from_tty)
{
info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
}
static void
-info_port_sets_cmd (char *args, int from_tty)
+info_port_sets_cmd (const char *args, int from_tty)
{
info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
}
static void
-info_dead_names_cmd (char *args, int from_tty)
+info_dead_names_cmd (const char *args, int from_tty)
{
info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
}
static void
-info_port_rights_cmd (char *args, int from_tty)
+info_port_rights_cmd (const char *args, int from_tty)
{
info_port_rights (args, ~0);
}
&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);
\f
static void
-set_thread_pause_cmd (char *args, int from_tty)
+set_thread_pause_cmd (const char *args, int from_tty)
{
struct proc *thread = cur_thread ();
int old_sc = thread->pause_sc;
}
static void
-show_thread_pause_cmd (char *args, int from_tty)
+show_thread_pause_cmd (const char *args, int from_tty)
{
struct proc *thread = cur_thread ();
int sc = thread->pause_sc;
}
static void
-set_thread_run_cmd (char *args, int from_tty)
+set_thread_run_cmd (const char *args, int from_tty)
{
struct proc *thread = cur_thread ();
}
static void
-show_thread_run_cmd (char *args, int from_tty)
+show_thread_run_cmd (const char *args, int from_tty)
{
struct proc *thread = cur_thread ();
}
static void
-set_thread_detach_sc_cmd (char *args, int from_tty)
+set_thread_detach_sc_cmd (const char *args, int from_tty)
{
cur_thread ()->detach_sc = parse_int_arg (args,
"set thread detach-suspend-count");
}
static void
-show_thread_detach_sc_cmd (char *args, int from_tty)
+show_thread_detach_sc_cmd (const char *args, int from_tty)
{
struct proc *thread = cur_thread ();
}
static void
-set_thread_exc_port_cmd (char *args, int from_tty)
+set_thread_exc_port_cmd (const char *args, int from_tty)
{
struct proc *thread = cur_thread ();
#endif
static void
-thread_takeover_sc_cmd (char *args, int from_tty)
+thread_takeover_sc_cmd (const 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;
- error_t err =
- thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len);
+ kern_return_t err
+ = mach_thread_info (thread->port, THREAD_BASIC_INFO,
+ (int *) &info, &info_len);
if (err)
error (("%s."), safe_strerror (err));
thread->sc = info->suspend_count;
&thread_cmd_list);
}
-\f
void
_initialize_gnu_nat (void)
{
flush_inferior_icache (CORE_ADDR pc, int amount)
{
vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
- error_t ret;
+ kern_return_t ret;
ret = vm_machine_attribute (gnu_current_inf->task->port,
pc,
projects / binutils.git / blobdiff