/* Interface GDB to the GNU Hurd.
- Copyright 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001
- Free Software Foundation, Inc.
+ Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2006, 2007,
+ 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
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, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <ctype.h>
#include <hurd/msg.h>
#include <hurd/msg_request.h>
#include <hurd/process.h>
+/* Defined in <hurd/process.h>, but we need forward declarations from
+ <hurd/process_request.h> as well. */
+#undef _process_user_
#include <hurd/process_request.h>
#include <hurd/signal.h>
#include <hurd/sigpreempt.h>
#include "gdb_obstack.h"
#include "gnu-nat.h"
+#include "inf-child.h"
#include "exc_request_S.h"
#include "notify_S.h"
/* Forward decls */
-extern struct target_ops gnu_ops;
-
struct inf *make_inf ();
void inf_clear_wait (struct inf *inf);
void inf_cleanup (struct inf *inf);
#define inf_debug(_inf, msg, args...) \
do { struct inf *__inf = (_inf); \
- debug ("{inf %d %p}: " msg, __inf->pid, __inf , ##args); } while (0)
+ debug ("{inf %d %s}: " msg, __inf->pid, \
+ host_address_to_string (__inf) , ##args); } while (0)
void proc_abort (struct proc *proc, int force);
struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
{
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;
}
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));
}
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)
{
int abort;
target_terminal_ours (); /* Allow I/O. */
- abort = !query ("Pid %d has an additional task suspend count of %d;"
- " clear it? ", inf->pid,
+ 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. */
error_t err =
INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
INIT_TRACEMASK, mask));
+
if (err == EIEIO)
{
if (on)
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)
inf_port_to_thread (struct inf *inf, mach_port_t port)
{
struct proc *thread = inf->threads;
+
while (thread)
if (thread->port == port)
return thread;
if (task)
{
error_t err = task_threads (task->port, &threads, &num_threads);
+
inf_debug (inf, "fetching threads");
if (err)
/* TASK must be dead. */
proc_debug (thread, "died!");
thread->port = MACH_PORT_NULL;
thread = _proc_free (thread); /* THREAD is dead. */
- (last ? last->next : inf->threads) = thread;
+ if (last)
+ last->next = thread;
+ else
+ inf->threads = thread;
}
}
else
/* THREADS[I] is a thread we don't know about yet! */
{
+ ptid_t ptid;
+
thread = make_proc (inf, threads[i], next_thread_id++);
- (last ? last->next : inf->threads) = thread;
+ if (last)
+ last->next = thread;
+ else
+ inf->threads = thread;
last = thread;
proc_debug (thread, "new thread: %d", threads[i]);
- add_thread (pid_to_ptid (thread->tid)); /* Tell GDB's generic thread code. */
+
+ ptid = ptid_build (inf->pid, 0, thread->tid);
+
+ /* Tell GDB's generic thread code. */
+
+ if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid)))
+ /* This is the first time we're hearing about thread
+ ids, after a fork-child. */
+ thread_change_ptid (inferior_ptid, ptid);
+ else if (inf->pending_execs != 0)
+ /* This is a shell thread. */
+ add_thread_silent (ptid);
+ else
+ add_thread (ptid);
}
}
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)
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)
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"
", code = %d, subcode = %d",
\f
/* The inferior used for all gdb target ops. */
-struct inf *current_inferior = 0;
+struct inf *gnu_current_inf = 0;
/* The inferior being waited for by gnu_wait. Since GDB is decidely not
multi-threaded, we don't bother to lock this. */
/* Wait for something to happen in the inferior, returning what in STATUS. */
static ptid_t
-gnu_wait (ptid_t tid, struct target_waitstatus *status)
+gnu_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status, int options)
{
struct msg
{
} msg;
error_t err;
struct proc *thread;
- struct inf *inf = current_inferior;
+ 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 *);
waiting_inf = inf;
- inf_debug (inf, "waiting for: %d", PIDGET (tid));
+ inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
rewait:
if (proc_wait_pid != inf->pid && !inf->no_wait)
thread = inf->wait.thread;
if (thread)
- tid = pid_to_ptid (thread->tid);
+ ptid = ptid_build (inf->pid, 0, thread->tid);
+ else if (ptid_equal (ptid, minus_one_ptid))
+ thread = inf_tid_to_thread (inf, -1);
else
- thread = inf_tid_to_thread (inf, PIDGET (tid));
+ thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
if (!thread || thread->port == MACH_PORT_NULL)
{
/* TID is dead; try and find a new thread. */
if (inf_update_procs (inf) && inf->threads)
- tid = pid_to_ptid (inf->threads->tid); /* The first available thread. */
+ ptid = ptid_build (inf->pid, 0, inf->threads->tid); /* The first available thread. */
else
- tid = inferior_ptid; /* let wait_for_inferior handle exit case */
+ ptid = inferior_ptid; /* let wait_for_inferior handle exit case */
}
- if (thread && PIDGET (tid) >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS
+ if (thread
+ && !ptid_equal (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
suspend it. */
inf_update_suspends (inf);
}
- inf_debug (inf, "returning tid = %d, status = %s (%d)", PIDGET (tid),
+ 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->value.integer);
- return tid;
+ return ptid;
}
\f
else
{
struct proc *thread = inf_port_to_thread (inf, dead_port);
+
if (thread)
{
proc_debug (thread, "is dead");
{
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;
in multiple events returned by wait).
*/
static void
-gnu_resume (ptid_t tid, int step, enum target_signal sig)
+gnu_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum target_signal sig)
{
struct proc *step_thread = 0;
- struct inf *inf = current_inferior;
+ int resume_all;
+ struct inf *inf = gnu_current_inf;
- inf_debug (inf, "tid = %d, step = %d, sig = %d", PIDGET (tid), step, sig);
+ inf_debug (inf, "ptid = %s, step = %d, sig = %d",
+ target_pid_to_str (ptid), step, sig);
inf_validate_procinfo (inf);
inf_update_procs (inf);
- if (PIDGET (tid) < 0)
+ /* A specific PTID means `step only this process id'. */
+ resume_all = ptid_equal (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));
- tid = inferior_ptid; /* What to step. */
+ 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, PIDGET (tid));
+ struct proc *thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
+
if (!thread)
- error (_("Can't run single thread id %d: no such thread!"));
- inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
+ 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));
inf_set_threads_resume_sc (inf, thread, 0);
}
if (step)
{
- step_thread = inf_tid_to_thread (inf, PIDGET (tid));
+ step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
if (!step_thread)
- warning (_("Can't step thread id %d: no such thread."), PIDGET (tid));
+ warning (_("Can't step thread id %s: no such thread."),
+ target_pid_to_str (ptid));
else
- inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
+ inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
}
if (step_thread != inf->step_thread)
inf_set_step_thread (inf, step_thread);
\f
static void
-gnu_kill_inferior (void)
+gnu_kill_inferior (struct target_ops *ops)
{
- struct proc *task = current_inferior->task;
+ struct proc *task = gnu_current_inf->task;
+
if (task)
{
proc_debug (task, "terminating...");
task_terminate (task->port);
- inf_set_pid (current_inferior, -1);
+ inf_set_pid (gnu_current_inf, -1);
}
target_mourn_inferior ();
}
/* Clean up after the inferior dies. */
static void
-gnu_mourn_inferior (void)
+gnu_mourn_inferior (struct target_ops *ops)
{
- inf_debug (current_inferior, "rip");
- inf_detach (current_inferior);
- unpush_target (&gnu_ops);
+ inf_debug (gnu_current_inf, "rip");
+ inf_detach (gnu_current_inf);
+ unpush_target (ops);
generic_mourn_inferior ();
}
static int
inf_pick_first_thread (void)
{
- if (current_inferior->task && current_inferior->threads)
+ if (gnu_current_inf->task && gnu_current_inf->threads)
/* The first thread. */
- return current_inferior->threads->tid;
+ return gnu_current_inf->threads->tid;
else
/* What may be the next thread. */
return next_thread_id;
static struct inf *
cur_inf (void)
{
- if (!current_inferior)
- current_inferior = make_inf ();
- return current_inferior;
+ if (!gnu_current_inf)
+ gnu_current_inf = make_inf ();
+ return gnu_current_inf;
}
static void
-gnu_create_inferior (char *exec_file, char *allargs, char **env,
+gnu_create_inferior (struct target_ops *ops,
+ char *exec_file, char *allargs, char **env,
int from_tty)
{
struct inf *inf = cur_inf ();
+ int pid;
void trace_me ()
{
if (ptrace (PTRACE_TRACEME) != 0)
error (_("ptrace (PTRACE_TRACEME) failed!"));
}
- void attach_to_child (int pid)
- {
- /* Attach to the now stopped child, which is actually a shell... */
- inf_debug (inf, "attaching to child: %d", pid);
- inf_attach (inf, pid);
+ inf_debug (inf, "creating inferior");
+
+ pid = fork_inferior (exec_file, allargs, env, trace_me, NULL, NULL, NULL);
- attach_flag = 0;
- push_target (&gnu_ops);
+ /* Attach to the now stopped child, which is actually a shell... */
+ inf_debug (inf, "attaching to child: %d", pid);
- inf->pending_execs = 2;
- inf->nomsg = 1;
- inf->traced = 1;
+ inf_attach (inf, pid);
- /* Now let the child run again, knowing that it will stop immediately
- because of the ptrace. */
- inf_resume (inf);
- inferior_ptid = pid_to_ptid (inf_pick_first_thread ());
+ push_target (ops);
- startup_inferior (inf->pending_execs);
- }
+ inf->pending_execs = 2;
+ inf->nomsg = 1;
+ inf->traced = 1;
- inf_debug (inf, "creating inferior");
+ /* Now let the child run again, knowing that it will stop
+ 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 ()));
- fork_inferior (exec_file, allargs, env, trace_me, attach_to_child,
- NULL, NULL);
+ startup_inferior (inf->pending_execs);
inf_validate_procinfo (inf);
inf_update_signal_thread (inf);
inf_steal_exc_ports (inf);
else
inf_restore_exc_ports (inf);
-
- /* Here we go! */
- proceed ((CORE_ADDR) -1, 0, 0);
-}
-
-/* Mark our target-struct as eligible for stray "run" and "attach"
- commands. */
-static int
-gnu_can_run (void)
-{
- return 1;
}
\f
/* Attach to process PID, then initialize for debugging it
and wait for the trace-trap that results from attaching. */
static void
-gnu_attach (char *args, int from_tty)
+gnu_attach (struct target_ops *ops, 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)
inf_debug (inf, "attaching to pid: %d", pid);
inf_attach (inf, pid);
- inf_update_procs (inf);
- inferior_ptid = pid_to_ptid (inf_pick_first_thread ());
+ push_target (ops);
+
+ inferior = current_inferior ();
+ inferior_appeared (inferior, pid);
+ inferior->attach_flag = 1;
+
+ inf_update_procs (inf);
- attach_flag = 1;
- push_target (&gnu_ops);
+ inferior_ptid = ptid_build (pid, 0, inf_pick_first_thread ());
/* We have to initialize the terminal settings now, since the code
below might try to restore them. */
previously attached. It *might* work if the program was
started via fork. */
static void
-gnu_detach (char *args, int from_tty)
+gnu_detach (struct target_ops *ops, 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, current_inferior->pid);
+ exec_file, gnu_current_inf->pid);
else
- printf_unfiltered ("Detaching from pid %d\n", current_inferior->pid);
+ printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid);
gdb_flush (gdb_stdout);
}
- inf_detach (current_inferior);
+ pid = gnu_current_inf->pid;
+
+ inf_detach (gnu_current_inf);
inferior_ptid = null_ptid;
+ detach_inferior (pid);
- unpush_target (&gnu_ops); /* Pop out of handling an inferior */
+ unpush_target (ops); /* Pop out of handling an inferior */
}
\f
static void
gnu_terminal_init_inferior (void)
{
- gdb_assert (current_inferior);
- terminal_init_inferior_with_pgrp (current_inferior->pid);
+ gdb_assert (gnu_current_inf);
+ terminal_init_inferior_with_pgrp (gnu_current_inf->pid);
}
-/* Get ready to modify the registers array. On machines which store
- individual registers, this doesn't need to do anything. On machines
- which store all the registers in one fell swoop, this makes sure
- that registers contains all the registers from the program being
- debugged. */
static void
-gnu_prepare_to_store (void)
-{
-#ifdef CHILD_PREPARE_TO_STORE
- CHILD_PREPARE_TO_STORE ();
-#endif
-}
-
-static void
-gnu_open (char *arg, int from_tty)
-{
- error (_("Use the \"run\" command to start a Unix child process."));
-}
-
-static void
-gnu_stop (void)
+gnu_stop (ptid_t ptid)
{
error (_("to_stop target function not implemented"));
}
-static char *
-gnu_pid_to_exec_file (int pid)
-{
- error (_("to_pid_to_exec_file target function not implemented"));
- return NULL;
-}
-
-
static int
-gnu_thread_alive (ptid_t tid)
+gnu_thread_alive (struct target_ops *ops, ptid_t ptid)
{
- inf_update_procs (current_inferior);
- return !!inf_tid_to_thread (current_inferior, PIDGET (tid));
+ inf_update_procs (gnu_current_inf);
+ return !!inf_tid_to_thread (gnu_current_inf,
+ ptid_get_tid (ptid));
}
\f
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));
deallocate++;
- err = hurd_safe_copyout ((void *) addr - low_address + copied,
+ err = hurd_safe_copyout ((void *) (addr - low_address + copied),
myaddr, length);
CHK_GOTO_OUT ("Write to inferior faulted", err);
/* Return 0 on failure, number of bytes handled otherwise. TARGET
is ignored. */
static int
-gnu_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
struct mem_attrib *attrib,
struct target_ops *target)
{
- task_t task = (current_inferior
- ? (current_inferior->task
- ? current_inferior->task->port : 0)
+ task_t task = (gnu_current_inf
+ ? (gnu_current_inf->task
+ ? gnu_current_inf->task->port : 0)
: 0);
if (task == MACH_PORT_NULL)
return 0;
else
{
- inf_debug (current_inferior, "%s %p[%d] %s %p",
- write ? "writing" : "reading", (void *) memaddr, len,
- write ? "<--" : "-->", myaddr);
+ 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
/* 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 (find_memory_region_ftype func, void *data)
{
error_t err;
task_t task;
vm_address_t region_address, last_region_address, last_region_end;
vm_prot_t last_protection;
- if (current_inferior == 0 || current_inferior->task == 0)
+ if (gnu_current_inf == 0 || gnu_current_inf->task == 0)
return 0;
- task = current_inferior->task->port;
+ task = gnu_current_inf->task->port;
if (task == MACH_PORT_NULL)
return 0;
proc_string (struct proc *proc)
{
static char tid_str[80];
+
if (proc_is_task (proc))
sprintf (tid_str, "process %d", proc->inf->pid);
else
- sprintf (tid_str, "thread %d.%d",
- proc->inf->pid, pid_to_thread_id (MERGEPID (proc->tid, 0)));
+ sprintf (tid_str, "Thread %d.%d",
+ proc->inf->pid, proc->tid);
return tid_str;
}
static char *
-gnu_pid_to_str (ptid_t ptid)
+gnu_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
- struct inf *inf = current_inferior;
- int tid = PIDGET (ptid);
+ struct inf *inf = gnu_current_inf;
+ int tid = ptid_get_tid (ptid);
struct proc *thread = inf_tid_to_thread (inf, tid);
if (thread)
else
{
static char tid_str[80];
+
sprintf (tid_str, "bogus thread id %d", tid);
return tid_str;
}
}
\f
-extern void gnu_store_registers (int regno);
-extern void gnu_fetch_registers (int regno);
+/* Create a prototype generic GNU/Hurd target. The client can
+ override it with local methods. */
-struct target_ops gnu_ops;
+struct target_ops *
+gnu_target (void)
+{
+ struct target_ops *t = inf_child_target ();
-static void
-init_gnu_ops (void)
-{
- gnu_ops.to_shortname = "GNU"; /* to_shortname */
- gnu_ops.to_longname = "GNU Hurd process"; /* to_longname */
- gnu_ops.to_doc = "GNU Hurd process"; /* to_doc */
- gnu_ops.to_open = gnu_open; /* to_open */
- gnu_ops.to_attach = gnu_attach; /* to_attach */
- gnu_ops.to_detach = gnu_detach; /* to_detach */
- gnu_ops.to_resume = gnu_resume; /* to_resume */
- gnu_ops.to_wait = gnu_wait; /* to_wait */
- gnu_ops.to_fetch_registers = gnu_fetch_registers; /* to_fetch_registers */
- gnu_ops.to_store_registers = gnu_store_registers; /* to_store_registers */
- gnu_ops.to_prepare_to_store = gnu_prepare_to_store; /* to_prepare_to_store */
- gnu_ops.deprecated_xfer_memory = gnu_xfer_memory;
- gnu_ops.to_find_memory_regions = gnu_find_memory_regions;
- gnu_ops.to_insert_breakpoint = memory_insert_breakpoint;
- gnu_ops.to_remove_breakpoint = memory_remove_breakpoint;
- gnu_ops.to_terminal_init = gnu_terminal_init_inferior;
- gnu_ops.to_terminal_inferior = terminal_inferior;
- gnu_ops.to_terminal_ours_for_output = terminal_ours_for_output;
- gnu_ops.to_terminal_save_ours = terminal_save_ours;
- gnu_ops.to_terminal_ours = terminal_ours;
- gnu_ops.to_terminal_info = child_terminal_info;
- gnu_ops.to_kill = gnu_kill_inferior; /* to_kill */
- gnu_ops.to_create_inferior = gnu_create_inferior; /* to_create_inferior */
- gnu_ops.to_mourn_inferior = gnu_mourn_inferior; /* to_mourn_inferior */
- gnu_ops.to_can_run = gnu_can_run; /* to_can_run */
- gnu_ops.to_thread_alive = gnu_thread_alive; /* to_thread_alive */
- gnu_ops.to_pid_to_str = gnu_pid_to_str; /* to_pid_to_str */
- gnu_ops.to_stop = gnu_stop; /* to_stop */
- gnu_ops.to_pid_to_exec_file = gnu_pid_to_exec_file; /* to_pid_to_exec_file */
- gnu_ops.to_stratum = process_stratum; /* to_stratum */
- gnu_ops.to_has_all_memory = 1; /* to_has_all_memory */
- gnu_ops.to_has_memory = 1; /* to_has_memory */
- gnu_ops.to_has_stack = 1; /* to_has_stack */
- gnu_ops.to_has_registers = 1; /* to_has_registers */
- gnu_ops.to_has_execution = 1; /* to_has_execution */
- gnu_ops.to_magic = OPS_MAGIC; /* to_magic */
-} /* init_gnu_ops */
+ 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;
+}
\f
/* User task commands. */
{
char *arg_end;
int val = strtoul (args, &arg_end, 10);
+
if (*args && *arg_end == '\0')
return val;
}
cur_thread (void)
{
struct inf *inf = cur_inf ();
- struct proc *thread = inf_tid_to_thread (inf, PIDGET (inferior_ptid));
+ struct proc *thread = inf_tid_to_thread (inf,
+ ptid_get_tid (inferior_ptid));
if (!thread)
error (_("No current thread."));
return thread;
active_inf (void)
{
struct inf *inf = cur_inf ();
+
if (!inf->task)
error (_("No current process."));
return inf;
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
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;
}
{
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",
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;
}
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");
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));
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");
inf->signal_thread = 0;
else
{
- int tid = PIDGET (thread_id_to_pid (atoi (args)));
+ 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);
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",
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
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
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));
}
/* 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));
}
static void
add_task_commands (void)
{
- add_cmd ("pause", class_run, set_thread_default_pause_cmd,
- "Set whether the new threads are suspended while gdb has control.\n\
+ add_cmd ("pause", class_run, set_thread_default_pause_cmd, _("\
+Set whether the new threads are suspended while gdb has control.\n\
This property normally has no effect because the whole task is\n\
suspended, however, that may be disabled with \"set task pause off\".\n\
-The default value is \"off\".",
+The default value is \"off\"."),
&set_thread_default_cmd_list);
- add_cmd ("pause", no_class, show_thread_default_pause_cmd,
- "Show whether new threads are suspended while gdb has control.",
+ add_cmd ("pause", no_class, show_thread_default_pause_cmd, _("\
+Show whether new threads are suspended while gdb has control."),
&show_thread_default_cmd_list);
- add_cmd ("run", class_run, set_thread_default_run_cmd,
- "Set whether new threads are allowed to run \
-(once gdb has noticed them).",
+ add_cmd ("run", class_run, set_thread_default_run_cmd, _("\
+Set whether new threads are allowed to run (once gdb has noticed them)."),
&set_thread_default_cmd_list);
- add_cmd ("run", no_class, show_thread_default_run_cmd,
- "Show whether new threads are allowed to run \
-(once gdb has noticed them).",
+ add_cmd ("run", no_class, show_thread_default_run_cmd, _("\
+Show whether new threads are allowed to run (once gdb has noticed them)."),
&show_thread_default_cmd_list);
add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
- "Set the default detach-suspend-count value for new threads.",
+ _("Set the default detach-suspend-count value for new threads."),
&set_thread_default_cmd_list);
add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
- "Show the default detach-suspend-count value for new threads.",
+ _("Show the default detach-suspend-count value for new threads."),
&show_thread_default_cmd_list);
- add_cmd ("signals", class_run, set_signals_cmd,
- "Set whether the inferior process's signals will be intercepted.\n\
-Mach exceptions (such as breakpoint traps) are not affected.",
+ add_cmd ("signals", class_run, set_signals_cmd, _("\
+Set whether the inferior process's signals will be intercepted.\n\
+Mach exceptions (such as breakpoint traps) are not affected."),
&setlist);
add_alias_cmd ("sigs", "signals", class_run, 1, &setlist);
- add_cmd ("signals", no_class, show_signals_cmd,
- "Show whether the inferior process's signals will be intercepted.",
+ add_cmd ("signals", no_class, show_signals_cmd, _("\
+Show whether the inferior process's signals will be intercepted."),
&showlist);
add_alias_cmd ("sigs", "signals", no_class, 1, &showlist);
- add_cmd ("signal-thread", class_run, set_sig_thread_cmd,
- "Set the thread that gdb thinks is the libc signal thread.\n\
-This thread is run when delivering a signal to a non-stopped process.",
+ add_cmd ("signal-thread", class_run, set_sig_thread_cmd, _("\
+Set the thread that gdb thinks is the libc signal thread.\n\
+This thread is run when delivering a signal to a non-stopped process."),
&setlist);
add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist);
- add_cmd ("signal-thread", no_class, show_sig_thread_cmd,
- "Set the thread that gdb thinks is the libc signal thread.",
+ add_cmd ("signal-thread", no_class, show_sig_thread_cmd, _("\
+Set the thread that gdb thinks is the libc signal thread."),
&showlist);
add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist);
- add_cmd ("stopped", class_run, set_stopped_cmd,
- "Set whether gdb thinks the inferior process is stopped \
-as with SIGSTOP.\n\
-Stopped process will be continued by sending them a signal.",
+ add_cmd ("stopped", class_run, set_stopped_cmd, _("\
+Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
+Stopped process will be continued by sending them a signal."),
&setlist);
- add_cmd ("stopped", no_class, show_signals_cmd,
- "Show whether gdb thinks the inferior process is stopped \
-as with SIGSTOP.",
+ add_cmd ("stopped", no_class, show_stopped_cmd, _("\
+Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
&showlist);
- add_cmd ("exceptions", class_run, set_exceptions_cmd,
- "Set whether exceptions in the inferior process will be trapped.\n\
+ add_cmd ("exceptions", class_run, set_exceptions_cmd, _("\
+Set whether exceptions in the inferior process will be trapped.\n\
When exceptions are turned off, neither breakpoints nor single-stepping\n\
-will work.",
+will work."),
&setlist);
/* Allow `set exc' despite conflict with `set exception-port'. */
add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist);
- add_cmd ("exceptions", no_class, show_exceptions_cmd,
- "Show whether exceptions in the inferior process will be trapped.",
+ add_cmd ("exceptions", no_class, show_exceptions_cmd, _("\
+Show whether exceptions in the inferior process will be trapped."),
&showlist);
add_prefix_cmd ("task", no_class, set_task_cmd,
- "Command prefix for setting task attributes.",
+ _("Command prefix for setting task attributes."),
&set_task_cmd_list, "set task ", 0, &setlist);
add_prefix_cmd ("task", no_class, show_task_cmd,
- "Command prefix for showing task attributes.",
+ _("Command prefix for showing task attributes."),
&show_task_cmd_list, "show task ", 0, &showlist);
- add_cmd ("pause", class_run, set_task_pause_cmd,
- "Set whether the task is suspended while gdb has control.\n\
+ add_cmd ("pause", class_run, set_task_pause_cmd, _("\
+Set whether the task is suspended while gdb has control.\n\
A value of \"on\" takes effect immediately, otherwise nothing happens\n\
until the next time the program is continued.\n\
When setting this to \"off\", \"set thread default pause on\" can be\n\
-used to pause individual threads by default instead.",
+used to pause individual threads by default instead."),
&set_task_cmd_list);
add_cmd ("pause", no_class, show_task_pause_cmd,
- "Show whether the task is suspended while gdb has control.",
+ _("Show whether the task is suspended while gdb has control."),
&show_task_cmd_list);
add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
- "Set the suspend count will leave on the thread when detaching.",
+ _("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,
- "Set the task exception port to which we forward exceptions.\n\
-The argument should be the value of the send right in the task.",
+ add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\
+Set the task exception port to which we forward exceptions.\n\
+The argument should be the value of the send right in the task."),
&set_task_cmd_list);
add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
add_alias_cmd ("exc-port", "exception-port", no_class, 1,
/* A convenient way of turning on all options require to noninvasively
debug running tasks. */
- add_cmd ("noninvasive", no_class, set_noninvasive_cmd,
- "Set task options so that we interfere as little as possible.\n\
+ add_cmd ("noninvasive", no_class, set_noninvasive_cmd, _("\
+Set task options so that we interfere as little as possible.\n\
This is the same as setting `task pause', `exceptions', and\n\
-`signals' to the opposite value.",
+`signals' to the opposite value."),
&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",
+ _("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",
+ _("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",
+ _("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",
+ _("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",
+ _("Show information about the task's dead names"),
&infolist);
add_info_alias ("ports", "port-rights", 1);
add_info_alias ("port", "port-rights", 1);
{
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,
{
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),
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;
}
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),
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",
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));
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);
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;
add_thread_commands (void)
{
add_prefix_cmd ("thread", no_class, set_thread_cmd,
- "Command prefix for setting thread properties.",
+ _("Command prefix for setting thread properties."),
&set_thread_cmd_list, "set thread ", 0, &setlist);
add_prefix_cmd ("default", no_class, show_thread_cmd,
- "Command prefix for setting default thread properties.",
+ _("Command prefix for setting default thread properties."),
&set_thread_default_cmd_list, "set thread default ", 0,
&set_thread_cmd_list);
add_prefix_cmd ("thread", no_class, set_thread_default_cmd,
- "Command prefix for showing thread properties.",
+ _("Command prefix for showing thread properties."),
&show_thread_cmd_list, "show thread ", 0, &showlist);
add_prefix_cmd ("default", no_class, show_thread_default_cmd,
- "Command prefix for showing default thread properties.",
+ _("Command prefix for showing default thread properties."),
&show_thread_default_cmd_list, "show thread default ", 0,
&show_thread_cmd_list);
- add_cmd ("pause", class_run, set_thread_pause_cmd,
- "Set whether the current thread is suspended \
-while gdb has control.\n\
+ add_cmd ("pause", class_run, set_thread_pause_cmd, _("\
+Set whether the current thread is suspended while gdb has control.\n\
A value of \"on\" takes effect immediately, otherwise nothing happens\n\
until the next time the program is continued. This property normally\n\
has no effect because the whole task is suspended, however, that may\n\
be disabled with \"set task pause off\".\n\
-The default value is \"off\".",
+The default value is \"off\"."),
&set_thread_cmd_list);
- add_cmd ("pause", no_class, show_thread_pause_cmd,
- "Show whether the current thread is suspended \
-while gdb has control.",
+ add_cmd ("pause", no_class, show_thread_pause_cmd, _("\
+Show whether the current thread is suspended while gdb has control."),
&show_thread_cmd_list);
add_cmd ("run", class_run, set_thread_run_cmd,
- "Set whether the current thread is allowed to run.",
+ _("Set whether the current thread is allowed to run."),
&set_thread_cmd_list);
add_cmd ("run", no_class, show_thread_run_cmd,
- "Show whether the current thread is allowed to run.",
+ _("Show whether the current thread is allowed to run."),
&show_thread_cmd_list);
- add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd,
- "Set the suspend count will leave on the thread when detaching.\n\
+ add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd, _("\
+Set the suspend count will leave on the thread when detaching.\n\
Note that this is relative to suspend count when gdb noticed the thread;\n\
-use the `thread takeover-suspend-count' to force it to an absolute value.",
+use the `thread takeover-suspend-count' to force it to an absolute value."),
&set_thread_cmd_list);
- add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd,
- "Show the suspend count will leave on the thread when detaching.\n\
+ add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd, _("\
+Show the suspend count will leave on the thread when detaching.\n\
Note that this is relative to suspend count when gdb noticed the thread;\n\
-use the `thread takeover-suspend-count' to force it to an absolute value.",
+use the `thread takeover-suspend-count' to force it to an absolute value."),
&show_thread_cmd_list);
- add_cmd ("exception-port", no_class, set_thread_exc_port_cmd,
- "Set the thread exception port to which we forward exceptions.\n\
+ add_cmd ("exception-port", no_class, set_thread_exc_port_cmd, _("\
+Set the thread exception port to which we forward exceptions.\n\
This overrides the task exception port.\n\
-The argument should be the value of the send right in the task.",
+The argument should be the value of the send right in the task."),
&set_thread_cmd_list);
add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
add_alias_cmd ("exc-port", "exception-port", no_class, 1,
&set_thread_cmd_list);
- add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd,
- "Force the threads absolute suspend-count to be gdb's.\n\
+ add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd, _("\
+Force the threads absolute suspend-count to be gdb's.\n\
Prior to giving this command, gdb's thread suspend-counts are relative\n\
-to the thread's initial suspend-count when gdb notices the threads.",
+to the thread's initial suspend-count when gdb notices the threads."),
&thread_cmd_list);
}
_initialize_gnu_nat (void)
{
proc_server = getproc ();
-
- init_gnu_ops ();
- add_target (&gnu_ops);
add_task_commands ();
add_thread_commands ();
- add_set_cmd ("gnu-debug", class_maintenance,
- var_boolean, (char *) &gnu_debug_flag,
- "Set debugging output for the gnu backend.", &maintenancelist);
+ add_setshow_boolean_cmd ("gnu-nat", class_maintenance,
+ &gnu_debug_flag,
+ _("Set debugging output for the gnu backend."),
+ _("Show debugging output for the gnu backend."),
+ NULL,
+ NULL,
+ NULL,
+ &setdebuglist,
+ &showdebuglist);
}
\f
#ifdef FLUSH_INFERIOR_CACHE
vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
error_t ret;
- ret = vm_machine_attribute (current_inferior->task->port,
+ ret = vm_machine_attribute (gnu_current_inf->task->port,
pc,
amount,
MATTR_CACHE,
projects / binutils-gdb.git / blobdiff