X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fnto-procfs.c;h=b328dfa99bfb19ab851917242d16520c6c0a3434;hb=132f8e032c8e82980c12d861089da561fc4dda35;hp=256b0f9e060a88afcb5c369684829fd39db64419;hpb=6c95b8df7fef5273da71c34775918c554aae0ea8;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/nto-procfs.c b/gdb/nto-procfs.c index 256b0f9e06..b328dfa99b 100644 --- a/gdb/nto-procfs.c +++ b/gdb/nto-procfs.c @@ -1,7 +1,7 @@ /* Machine independent support for QNX Neutrino /proc (process file system) - for GDB. Written by Colin Burgess at QNX Software Systems Limited. + for GDB. Written by Colin Burgess at QNX Software Systems Limited. - Copyright (C) 2003, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. + Copyright (C) 2003-2014 Free Software Foundation, Inc. Contributed by QNX Software Systems Ltd. @@ -28,11 +28,11 @@ #include #include #include -#include "gdb_dirent.h" +#include #include #include "exceptions.h" -#include "gdb_string.h" +#include #include "gdbcore.h" #include "inferior.h" #include "target.h" @@ -42,13 +42,12 @@ #include "command.h" #include "regcache.h" #include "solib.h" +#include "inf-child.h" #define NULL_PID 0 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\ _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY) -static struct target_ops procfs_ops; - int ctl_fd; static void (*ofunc) (); @@ -57,25 +56,20 @@ static procfs_run run; static void procfs_open (char *, int); -static int procfs_can_run (void); - -static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int, - struct mem_attrib *attrib, - struct target_ops *); - -static void notice_signals (void); - -static void init_procfs_ops (void); - static ptid_t do_attach (ptid_t ptid); -static int procfs_can_use_hw_breakpoint (int, int, int); +static int procfs_can_use_hw_breakpoint (struct target_ops *self, + int, int, int); -static int procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type); +static int procfs_insert_hw_watchpoint (struct target_ops *self, + CORE_ADDR addr, int len, int type, + struct expression *cond); -static int procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type); +static int procfs_remove_hw_watchpoint (struct target_ops *self, + CORE_ADDR addr, int len, int type, + struct expression *cond); -static int procfs_stopped_by_watchpoint (void); +static int procfs_stopped_by_watchpoint (struct target_ops *ops); /* These two globals are only ever set in procfs_open(), but are referenced elsewhere. 'nto_procfs_node' is a flag used to say @@ -197,7 +191,7 @@ procfs_open (char *arg, int from_tty) { if (sysinfo->type != nto_map_arch_to_cputype (gdbarch_bfd_arch_info - (target_gdbarch)->arch_name)) + (target_gdbarch ())->arch_name)) error (_("Invalid target CPU.")); } } @@ -312,7 +306,7 @@ update_thread_private_data (struct thread_info *new_thread, #endif /* _NTO_VERSION */ } -void +static void procfs_find_new_threads (struct target_ops *ops) { procfs_status status; @@ -401,7 +395,7 @@ procfs_pidlist (char *args, int from_tty) } while (pid == 0); - /* Open the procfs path. */ + /* Open the procfs path. */ fd = open (buf, O_RDONLY); if (fd == -1) { @@ -576,14 +570,14 @@ procfs_meminfo (char *args, int from_tty) printme.text.addr); printf_filtered ("\t\tflags=%08x\n", printme.text.flags); printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr); - printf_filtered ("\t\toffset=%016llx\n", printme.text.offset); + printf_filtered ("\t\toffset=%s\n", phex (printme.text.offset, 8)); if (printme.data.size) { printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size, printme.data.addr); printf_filtered ("\t\tflags=%08x\n", printme.data.flags); printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr); - printf_filtered ("\t\toffset=%016llx\n", printme.data.offset); + printf_filtered ("\t\toffset=%s\n", phex (printme.data.offset, 8)); } printf_filtered ("\tdev=0x%x\n", printme.dev); printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino); @@ -603,13 +597,6 @@ procfs_files_info (struct target_ops *ignore) target_pid_to_str (inferior_ptid), nto_procfs_path); } -/* Mark our target-struct as eligible for stray "run" and "attach" commands. */ -static int -procfs_can_run (void) -{ - return 1; -} - /* Attach to process PID, then initialize for debugging it. */ static void procfs_attach (struct target_ops *ops, char *args, int from_tty) @@ -618,10 +605,7 @@ procfs_attach (struct target_ops *ops, char *args, int from_tty) int pid; struct inferior *inf; - if (!args) - error_no_arg (_("process-id to attach")); - - pid = atoi (args); + pid = parse_pid_to_attach (args); if (pid == getpid ()) error (_("Attaching GDB to itself is not a good idea...")); @@ -650,10 +634,10 @@ procfs_attach (struct target_ops *ops, char *args, int from_tty) } static void -procfs_post_attach (pid_t pid) +procfs_post_attach (struct target_ops *self, pid_t pid) { if (exec_bfd) - solib_create_inferior_hook (); + solib_create_inferior_hook (0); } static ptid_t @@ -663,7 +647,8 @@ do_attach (ptid_t ptid) struct sigevent event; char path[PATH_MAX]; - snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path, PIDGET (ptid)); + snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path, + ptid_get_pid (ptid)); ctl_fd = open (path, O_RDWR); if (ctl_fd == -1) error (_("Couldn't open proc file %s, error %d (%s)"), path, errno, @@ -681,9 +666,9 @@ do_attach (ptid_t ptid) if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK && status.flags & _DEBUG_FLAG_STOPPED) - SignalKill (nto_node (), PIDGET (ptid), 0, SIGCONT, 0, 0); + SignalKill (nto_node (), ptid_get_pid (ptid), 0, SIGCONT, 0, 0); nto_init_solib_absolute_prefix (); - return ptid_build (PIDGET (ptid), 0, status.tid); + return ptid_build (ptid_get_pid (ptid), 0, status.tid); } /* Ask the user what to do when an interrupt is received. */ @@ -696,7 +681,7 @@ interrupt_query (void) Give up (and stop debugging it)? "))) { target_mourn_inferior (); - deprecated_throw_reason (RETURN_QUIT); + quit (); } target_terminal_inferior (); @@ -734,7 +719,7 @@ procfs_wait (struct target_ops *ops, if (ptid_equal (inferior_ptid, null_ptid)) { ourstatus->kind = TARGET_WAITKIND_STOPPED; - ourstatus->value.sig = TARGET_SIGNAL_0; + ourstatus->value.sig = GDB_SIGNAL_0; exit_signo = 0; return null_ptid; } @@ -754,13 +739,13 @@ procfs_wait (struct target_ops *ops, if (status.flags & _DEBUG_FLAG_SSTEP) { ourstatus->kind = TARGET_WAITKIND_STOPPED; - ourstatus->value.sig = TARGET_SIGNAL_TRAP; + ourstatus->value.sig = GDB_SIGNAL_TRAP; } /* Was it a breakpoint? */ else if (status.flags & _DEBUG_FLAG_TRACE) { ourstatus->kind = TARGET_WAITKIND_STOPPED; - ourstatus->value.sig = TARGET_SIGNAL_TRAP; + ourstatus->value.sig = GDB_SIGNAL_TRAP; } else if (status.flags & _DEBUG_FLAG_ISTOP) { @@ -769,7 +754,7 @@ procfs_wait (struct target_ops *ops, case _DEBUG_WHY_SIGNALLED: ourstatus->kind = TARGET_WAITKIND_STOPPED; ourstatus->value.sig = - target_signal_from_host (status.info.si_signo); + gdb_signal_from_host (status.info.si_signo); exit_signo = 0; break; case _DEBUG_WHY_FAULTED: @@ -782,7 +767,7 @@ procfs_wait (struct target_ops *ops, else { ourstatus->value.sig = - target_signal_from_host (status.info.si_signo); + gdb_signal_from_host (status.info.si_signo); exit_signo = ourstatus->value.sig; } break; @@ -791,7 +776,7 @@ procfs_wait (struct target_ops *ops, { int waitval = 0; - waitpid (PIDGET (inferior_ptid), &waitval, WNOHANG); + waitpid (ptid_get_pid (inferior_ptid), &waitval, WNOHANG); if (exit_signo) { /* Abnormal death. */ @@ -811,7 +796,7 @@ procfs_wait (struct target_ops *ops, case _DEBUG_WHY_REQUESTED: /* We are assuming a requested stop is due to a SIGINT. */ ourstatus->kind = TARGET_WAITKIND_STOPPED; - ourstatus->value.sig = TARGET_SIGNAL_INT; + ourstatus->value.sig = GDB_SIGNAL_INT; exit_signo = 0; break; } @@ -847,30 +832,44 @@ procfs_fetch_registers (struct target_ops *ops, nto_supply_altregset (regcache, (char *) ®.altreg); } -/* Copy LEN bytes to/from inferior's memory starting at MEMADDR - from/to debugger memory starting at MYADDR. Copy from inferior - if DOWRITE is zero or to inferior if DOWRITE is nonzero. +/* Helper for procfs_xfer_partial that handles memory transfers. + Arguments are like target_xfer_partial. */ - Returns the length copied, which is either the LEN argument or - zero. This xfer function does not do partial moves, since procfs_ops - doesn't allow memory operations to cross below us in the target stack - anyway. */ -static int -procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite, - struct mem_attrib *attrib, struct target_ops *target) +static enum target_xfer_status +procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf, + ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len) { - int nbytes = 0; + int nbytes; + + if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr) + return TARGET_XFER_E_IO; + + if (writebuf != NULL) + nbytes = write (ctl_fd, writebuf, len); + else + nbytes = read (ctl_fd, readbuf, len); + if (nbytes <= 0) + return TARGET_XFER_E_IO; + *xfered_len = nbytes; + return TARGET_XFER_OK; +} + +/* Target to_xfer_partial implementation. */ - if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr) +static enum target_xfer_status +procfs_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) { - if (dowrite) - nbytes = write (ctl_fd, myaddr, len); - else - nbytes = read (ctl_fd, myaddr, len); - if (nbytes < 0) - nbytes = 0; + case TARGET_OBJECT_MEMORY: + return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len); + default: + return ops->beneath->to_xfer_partial (ops->beneath, object, annex, + readbuf, writebuf, offset, len); } - return (nbytes); } /* Take a program previously attached to and detaches it. @@ -878,7 +877,7 @@ procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite, on signals, etc. We'd better not have left any breakpoints in the program or it'll die when it hits one. */ static void -procfs_detach (struct target_ops *ops, char *args, int from_tty) +procfs_detach (struct target_ops *ops, const char *args, int from_tty) { int siggnal = 0; int pid; @@ -896,7 +895,7 @@ procfs_detach (struct target_ops *ops, char *args, int from_tty) siggnal = atoi (args); if (siggnal) - SignalKill (nto_node (), PIDGET (inferior_ptid), 0, siggnal, 0, 0); + SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, siggnal, 0, 0); close (ctl_fd); ctl_fd = -1; @@ -905,7 +904,7 @@ procfs_detach (struct target_ops *ops, char *args, int from_tty) inferior_ptid = null_ptid; detach_inferior (pid); init_thread_list (); - unpush_target (&procfs_ops); /* Pop out of handling an inferior. */ + unpush_target (ops); /* Pop out of handling an inferior. */ } static int @@ -923,21 +922,21 @@ procfs_breakpoint (CORE_ADDR addr, int type, int size) } static int -procfs_insert_breakpoint (struct gdbarch *gdbarch, +procfs_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) { return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0); } static int -procfs_remove_breakpoint (struct gdbarch *gdbarch, +procfs_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) { return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1); } static int -procfs_insert_hw_breakpoint (struct gdbarch *gdbarch, +procfs_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) { return procfs_breakpoint (bp_tgt->placed_address, @@ -945,7 +944,8 @@ procfs_insert_hw_breakpoint (struct gdbarch *gdbarch, } static int -procfs_remove_hw_breakpoint (struct gdbarch *gdbarch, +procfs_remove_hw_breakpoint (struct target_ops *self, + struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) { return procfs_breakpoint (bp_tgt->placed_address, @@ -954,7 +954,7 @@ procfs_remove_hw_breakpoint (struct gdbarch *gdbarch, static void procfs_resume (struct target_ops *ops, - ptid_t ptid, int step, enum target_signal signo) + ptid_t ptid, int step, enum gdb_signal signo) { int signal_to_pass; procfs_status status; @@ -984,23 +984,21 @@ procfs_resume (struct target_ops *ops, run.flags |= _DEBUG_RUN_ARM; - sigemptyset (&run.trace); - notice_signals (); - signal_to_pass = target_signal_to_host (signo); + signal_to_pass = gdb_signal_to_host (signo); if (signal_to_pass) { devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0); - signal_to_pass = target_signal_to_host (signo); + signal_to_pass = gdb_signal_to_host (signo); if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED)) { if (signal_to_pass != status.info.si_signo) { - SignalKill (nto_node (), PIDGET (inferior_ptid), 0, + SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, signal_to_pass, 0, 0); run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG; } - else /* Let it kill the program without telling us. */ + else /* Let it kill the program without telling us. */ sigdelset (&run.trace, signal_to_pass); } } @@ -1010,7 +1008,7 @@ procfs_resume (struct target_ops *ops, errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0); if (errno != EOK) { - perror ("run error!\n"); + perror (_("run error!\n")); return; } } @@ -1020,12 +1018,12 @@ procfs_mourn_inferior (struct target_ops *ops) { if (!ptid_equal (inferior_ptid, null_ptid)) { - SignalKill (nto_node (), PIDGET (inferior_ptid), 0, SIGKILL, 0, 0); + SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, SIGKILL, 0, 0); close (ctl_fd); } inferior_ptid = null_ptid; init_thread_list (); - unpush_target (&procfs_ops); + unpush_target (ops); generic_mourn_inferior (); } @@ -1214,11 +1212,11 @@ procfs_create_inferior (struct target_ops *ops, char *exec_file, if (exec_bfd != NULL || (symfile_objfile != NULL && symfile_objfile->obfd != NULL)) - solib_create_inferior_hook (); + solib_create_inferior_hook (0); } static void -procfs_stop (ptid_t ptid) +procfs_stop (struct target_ops *self, ptid_t ptid) { devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0); } @@ -1229,13 +1227,6 @@ procfs_kill_inferior (struct target_ops *ops) target_mourn_inferior (); } -/* Store register REGNO, or all registers if REGNO == -1, from the contents - of REGISTERS. */ -static void -procfs_prepare_to_store (struct regcache *regcache) -{ -} - /* Fill buf with regset and return devctl cmd to do the setting. Return -1 if we fail to get the regset. Store size of regset in regsize. */ static int @@ -1333,34 +1324,24 @@ procfs_store_registers (struct target_ops *ops, } } +/* Set list of signals to be handled in the target. */ + static void -notice_signals (void) +procfs_pass_signals (struct target_ops *self, + int numsigs, unsigned char *pass_signals) { int signo; + sigfillset (&run.trace); + for (signo = 1; signo < NSIG; signo++) { - if (signal_stop_state (target_signal_from_host (signo)) == 0 - && signal_print_state (target_signal_from_host (signo)) == 0 - && signal_pass_state (target_signal_from_host (signo)) == 1) - sigdelset (&run.trace, signo); - else - sigaddset (&run.trace, signo); + int target_signo = gdb_signal_from_host (signo); + if (target_signo < numsigs && pass_signals[target_signo]) + sigdelset (&run.trace, signo); } } -/* When the user changes the state of gdb's signal handling via the - "handle" command, this function gets called to see if any change - in the /proc interface is required. It is also called internally - by other /proc interface functions to initialize the state of - the traced signal set. */ -static void -procfs_notice_signals (ptid_t ptid) -{ - sigemptyset (&run.trace); - notice_signals (); -} - static struct tidinfo * procfs_thread_info (pid_t pid, short tid) { @@ -1368,7 +1349,7 @@ procfs_thread_info (pid_t pid, short tid) return NULL; } -char * +static char * procfs_pid_to_str (struct target_ops *ops, ptid_t ptid) { static char buf[1024]; @@ -1389,56 +1370,70 @@ procfs_pid_to_str (struct target_ops *ops, ptid_t ptid) return buf; } +/* to_can_run implementation for "target procfs". Note this really + means "can this target be the default run target", which there can + be only one, and we make it be "target native" like other ports. + "target procfs " wouldn't make sense as default run target, as + it needs . */ + +static int +procfs_can_run (struct target_ops *self) +{ + return 0; +} + +/* "target procfs". */ +static struct target_ops nto_procfs_ops; + +/* Create the "native" and "procfs" targets. */ + static void -init_procfs_ops (void) +init_procfs_targets (void) { - procfs_ops.to_shortname = "procfs"; - procfs_ops.to_longname = "QNX Neutrino procfs child process"; - procfs_ops.to_doc = - "QNX Neutrino procfs child process (started by the \"run\" command).\n\ - target procfs "; - procfs_ops.to_open = procfs_open; - procfs_ops.to_attach = procfs_attach; - procfs_ops.to_post_attach = procfs_post_attach; - procfs_ops.to_detach = procfs_detach; - procfs_ops.to_resume = procfs_resume; - procfs_ops.to_wait = procfs_wait; - procfs_ops.to_fetch_registers = procfs_fetch_registers; - procfs_ops.to_store_registers = procfs_store_registers; - procfs_ops.to_prepare_to_store = procfs_prepare_to_store; - procfs_ops.deprecated_xfer_memory = procfs_xfer_memory; - procfs_ops.to_files_info = procfs_files_info; - procfs_ops.to_insert_breakpoint = procfs_insert_breakpoint; - procfs_ops.to_remove_breakpoint = procfs_remove_breakpoint; - procfs_ops.to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint; - procfs_ops.to_insert_hw_breakpoint = procfs_insert_hw_breakpoint; - procfs_ops.to_remove_hw_breakpoint = procfs_remove_breakpoint; - procfs_ops.to_insert_watchpoint = procfs_insert_hw_watchpoint; - procfs_ops.to_remove_watchpoint = procfs_remove_hw_watchpoint; - procfs_ops.to_stopped_by_watchpoint = procfs_stopped_by_watchpoint; - procfs_ops.to_terminal_init = terminal_init_inferior; - procfs_ops.to_terminal_inferior = terminal_inferior; - procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output; - procfs_ops.to_terminal_ours = terminal_ours; - procfs_ops.to_terminal_info = child_terminal_info; - procfs_ops.to_kill = procfs_kill_inferior; - procfs_ops.to_create_inferior = procfs_create_inferior; - procfs_ops.to_mourn_inferior = procfs_mourn_inferior; - procfs_ops.to_can_run = procfs_can_run; - procfs_ops.to_notice_signals = procfs_notice_signals; - procfs_ops.to_thread_alive = procfs_thread_alive; - procfs_ops.to_find_new_threads = procfs_find_new_threads; - procfs_ops.to_pid_to_str = procfs_pid_to_str; - procfs_ops.to_stop = procfs_stop; - procfs_ops.to_stratum = process_stratum; - procfs_ops.to_has_all_memory = default_child_has_all_memory; - procfs_ops.to_has_memory = default_child_has_memory; - procfs_ops.to_has_stack = default_child_has_stack; - procfs_ops.to_has_registers = default_child_has_registers; - procfs_ops.to_has_execution = default_child_has_execution; - procfs_ops.to_magic = OPS_MAGIC; - procfs_ops.to_have_continuable_watchpoint = 1; - procfs_ops.to_extra_thread_info = nto_extra_thread_info; + struct target_ops *t = inf_child_target (); + + /* Leave to_shortname as "native". */ + t->to_longname = "QNX Neutrino local process"; + t->to_doc = "QNX Neutrino local process (started by the \"run\" command)."; + t->to_open = procfs_open; + t->to_attach = procfs_attach; + t->to_post_attach = procfs_post_attach; + t->to_detach = procfs_detach; + t->to_resume = procfs_resume; + t->to_wait = procfs_wait; + t->to_fetch_registers = procfs_fetch_registers; + t->to_store_registers = procfs_store_registers; + t->to_xfer_partial = procfs_xfer_partial; + t->to_files_info = procfs_files_info; + t->to_insert_breakpoint = procfs_insert_breakpoint; + t->to_remove_breakpoint = procfs_remove_breakpoint; + t->to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint; + t->to_insert_hw_breakpoint = procfs_insert_hw_breakpoint; + t->to_remove_hw_breakpoint = procfs_remove_hw_breakpoint; + t->to_insert_watchpoint = procfs_insert_hw_watchpoint; + t->to_remove_watchpoint = procfs_remove_hw_watchpoint; + t->to_stopped_by_watchpoint = procfs_stopped_by_watchpoint; + t->to_kill = procfs_kill_inferior; + t->to_create_inferior = procfs_create_inferior; + t->to_mourn_inferior = procfs_mourn_inferior; + t->to_pass_signals = procfs_pass_signals; + t->to_thread_alive = procfs_thread_alive; + t->to_find_new_threads = procfs_find_new_threads; + t->to_pid_to_str = procfs_pid_to_str; + t->to_stop = procfs_stop; + t->to_have_continuable_watchpoint = 1; + t->to_extra_thread_info = nto_extra_thread_info; + + /* Register "target native". This is the default run target. */ + add_target (t); + + /* Register "target procfs ". */ + nto_procfs_ops = *t; + nto_procfs_ops.to_shortname = "procfs"; + nto_procfs_ops.to_can_run = procfs_can_run; + t->to_longname = "QNX Neutrino local or remote process"; + t->to_doc = "QNX Neutrino process. target procfs "; + add_target (&nto_procfs_ops); } #define OSTYPE_NTO 1 @@ -1448,8 +1443,7 @@ _initialize_procfs (void) { sigset_t set; - init_procfs_ops (); - add_target (&procfs_ops); + init_procfs_targets (); /* We use SIGUSR1 to gain control after we block waiting for a process. We use sigwaitevent to wait. */ @@ -1457,8 +1451,8 @@ _initialize_procfs (void) sigaddset (&set, SIGUSR1); sigprocmask (SIG_BLOCK, &set, NULL); - /* Set up trace and fault sets, as gdb expects them. */ - sigemptyset (&run.trace); + /* Initially, make sure all signals are reported. */ + sigfillset (&run.trace); /* Stuff some information. */ nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags; @@ -1495,32 +1489,37 @@ procfs_hw_watchpoint (int addr, int len, int type) errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0); if (errno != EOK) { - perror ("Failed to set hardware watchpoint"); + perror (_("Failed to set hardware watchpoint")); return -1; } return 0; } static int -procfs_can_use_hw_breakpoint (int type, int cnt, int othertype) +procfs_can_use_hw_breakpoint (struct target_ops *self, + int type, int cnt, int othertype) { return 1; } static int -procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type) +procfs_remove_hw_watchpoint (struct target_ops *self, + CORE_ADDR addr, int len, int type, + struct expression *cond) { return procfs_hw_watchpoint (addr, -1, type); } static int -procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type) +procfs_insert_hw_watchpoint (struct target_ops *self, + CORE_ADDR addr, int len, int type, + struct expression *cond) { return procfs_hw_watchpoint (addr, len, type); } static int -procfs_stopped_by_watchpoint (void) +procfs_stopped_by_watchpoint (struct target_ops *ops) { return 0; }