X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fnto-procfs.c;h=728d6f3a76d9f0b8e81b58ad63749a9a383f8839;hb=976411d6b6aa5cae05259eb92b87a04262052e09;hp=21a14cd353b7960fec3df17b1aafe71e1d5919ad;hpb=97c4411662ebaae1d51ff328632f26c82a3bda89;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/nto-procfs.c b/gdb/nto-procfs.c index 21a14cd353..728d6f3a76 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,42 +42,34 @@ #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) (); 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 +/* These two globals are only ever set in procfs_open_1, but are referenced elsewhere. 'nto_procfs_node' is a flag used to say whether we are local, or we should get the current node descriptor for the remote QNX node. */ @@ -109,12 +101,12 @@ procfs_is_nto_target (bfd *abfd) return GDB_OSABI_QNXNTO; } -/* This is called when we call 'target procfs ' from the (gdb) prompt. - For QNX6 (nto), the only valid arg will be a QNX node string, - eg: "/net/some_node". If arg is not a valid QNX node, we will - default to local. */ +/* This is called when we call 'target native' or 'target procfs + ' from the (gdb) prompt. For QNX6 (nto), the only valid arg + will be a QNX node string, eg: "/net/some_node". If arg is not a + valid QNX node, we will default to local. */ static void -procfs_open (char *arg, int from_tty) +procfs_open_1 (struct target_ops *ops, char *arg, int from_tty) { char *nodestr; char *endstr; @@ -123,6 +115,9 @@ procfs_open (char *arg, int from_tty) procfs_sysinfo *sysinfo; struct cleanup *cleanups; + /* Offer to kill previous inferiors before opening this target. */ + target_preopen (from_tty); + nto_is_nto_target = procfs_is_nto_target; /* Set the default node used for spawning to this one, @@ -197,12 +192,14 @@ procfs_open (char *arg, int from_tty) { if (sysinfo->type != nto_map_arch_to_cputype (gdbarch_bfd_arch_info - (current_gdbarch)->arch_name)) + (target_gdbarch ())->arch_name)) error (_("Invalid target CPU.")); } } } do_cleanups (cleanups); + + inf_child_open_target (ops, arg, from_tty); printf_filtered ("Debugging using %s\n", nto_procfs_path); } @@ -220,33 +217,131 @@ static int procfs_thread_alive (struct target_ops *ops, ptid_t ptid) { pid_t tid; + pid_t pid; + procfs_status status; + int err; tid = ptid_get_tid (ptid); - if (devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0) == EOK) - return 1; - return 0; + pid = ptid_get_pid (ptid); + + if (kill (pid, 0) == -1) + return 0; + + status.tid = tid; + if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS, + &status, sizeof (status), 0)) != EOK) + return 0; + + /* Thread is alive or dead but not yet joined, + or dead and there is an alive (or dead unjoined) thread with + higher tid. + + If the tid is not the same as requested, requested tid is dead. */ + return (status.tid == tid) && (status.state != STATE_DEAD); } -void +static void +update_thread_private_data_name (struct thread_info *new_thread, + const char *newname) +{ + int newnamelen; + struct private_thread_info *pti; + + gdb_assert (newname != NULL); + gdb_assert (new_thread != NULL); + newnamelen = strlen (newname); + if (!new_thread->private) + { + new_thread->private = xmalloc (offsetof (struct private_thread_info, + name) + + newnamelen + 1); + memcpy (new_thread->private->name, newname, newnamelen + 1); + } + else if (strcmp (newname, new_thread->private->name) != 0) + { + /* Reallocate if neccessary. */ + int oldnamelen = strlen (new_thread->private->name); + + if (oldnamelen < newnamelen) + new_thread->private = xrealloc (new_thread->private, + offsetof (struct private_thread_info, + name) + + newnamelen + 1); + memcpy (new_thread->private->name, newname, newnamelen + 1); + } +} + +static void +update_thread_private_data (struct thread_info *new_thread, + pthread_t tid, int state, int flags) +{ + struct private_thread_info *pti; + procfs_info pidinfo; + struct _thread_name *tn; + procfs_threadctl tctl; + +#if _NTO_VERSION > 630 + gdb_assert (new_thread != NULL); + + if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo, + sizeof(pidinfo), 0) != EOK) + return; + + memset (&tctl, 0, sizeof (tctl)); + tctl.cmd = _NTO_TCTL_NAME; + tn = (struct _thread_name *) (&tctl.data); + + /* Fetch name for the given thread. */ + tctl.tid = tid; + tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn); + tn->new_name_len = -1; /* Getting, not setting. */ + if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK) + tn->name_buf[0] = '\0'; + + tn->name_buf[_NTO_THREAD_NAME_MAX] = '\0'; + + update_thread_private_data_name (new_thread, tn->name_buf); + + pti = (struct private_thread_info *) new_thread->private; + pti->tid = tid; + pti->state = state; + pti->flags = flags; +#endif /* _NTO_VERSION */ +} + +static void procfs_find_new_threads (struct target_ops *ops) { procfs_status status; pid_t pid; ptid_t ptid; + pthread_t tid; + struct thread_info *new_thread; if (ctl_fd == -1) return; pid = ptid_get_pid (inferior_ptid); - for (status.tid = 1;; ++status.tid) + status.tid = 1; + + for (tid = 1;; ++tid) { - if (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0) - != EOK && status.tid != 0) + if (status.tid == tid + && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0) + != EOK)) break; - ptid = ptid_build (pid, 0, status.tid); - if (!in_thread_list (ptid)) - add_thread (ptid); + if (status.tid != tid) + /* The reason why this would not be equal is that devctl might have + returned different tid, meaning the requested tid no longer exists + (e.g. thread exited). */ + continue; + ptid = ptid_build (pid, 0, tid); + new_thread = find_thread_ptid (ptid); + if (!new_thread) + new_thread = add_thread (ptid); + update_thread_private_data (new_thread, tid, status.state, 0); + status.tid++; } return; } @@ -303,7 +398,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) { @@ -478,14 +573,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); @@ -505,25 +600,15 @@ 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) +procfs_attach (struct target_ops *ops, const char *args, int from_tty) { char *exec_file; 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...")); @@ -542,19 +627,21 @@ procfs_attach (struct target_ops *ops, char *args, int from_tty) gdb_flush (gdb_stdout); } inferior_ptid = do_attach (pid_to_ptid (pid)); - inf = add_inferior (pid); + inf = current_inferior (); + inferior_appeared (inf, pid); inf->attach_flag = 1; - push_target (ops); + if (!target_is_pushed (ops)) + push_target (ops); procfs_find_new_threads (ops); } 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 @@ -564,7 +651,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, @@ -582,9 +670,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. */ @@ -597,7 +685,7 @@ interrupt_query (void) Give up (and stop debugging it)? "))) { target_mourn_inferior (); - deprecated_throw_reason (RETURN_QUIT); + quit (); } target_terminal_inferior (); @@ -635,7 +723,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; } @@ -655,13 +743,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) { @@ -670,7 +758,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: @@ -683,7 +771,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; @@ -692,7 +780,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. */ @@ -712,7 +800,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; } @@ -748,30 +836,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 (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr) + 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. */ + +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. @@ -779,7 +881,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; @@ -797,7 +899,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; @@ -806,7 +908,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. */ + inf_child_maybe_unpush_target (ops); } static int @@ -824,26 +926,31 @@ procfs_breakpoint (CORE_ADDR addr, int type, int size) } static int -procfs_insert_breakpoint (struct bp_target_info *bp_tgt) +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 bp_target_info *bp_tgt) +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 bp_target_info *bp_tgt) +procfs_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) { return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0); } static int -procfs_remove_hw_breakpoint (struct bp_target_info *bp_tgt) +procfs_remove_hw_breakpoint (struct target_ops *self, + struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) { return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1); @@ -851,7 +958,7 @@ procfs_remove_hw_breakpoint (struct bp_target_info *bp_tgt) 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; @@ -881,23 +988,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); } } @@ -907,7 +1012,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; } } @@ -917,13 +1022,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); - generic_mourn_inferior (); + inf_child_mourn_inferior (ops); } /* This function breaks up an argument string into an argument @@ -1094,7 +1198,8 @@ procfs_create_inferior (struct target_ops *ops, char *exec_file, inferior_ptid = do_attach (pid_to_ptid (pid)); procfs_find_new_threads (ops); - inf = add_inferior (pid); + inf = current_inferior (); + inferior_appeared (inf, pid); inf->attach_flag = 0; flags = _DEBUG_FLAG_KLC; /* Kill-on-Last-Close flag. */ @@ -1105,16 +1210,17 @@ procfs_create_inferior (struct target_ops *ops, char *exec_file, /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n", errn, strerror(errn) ); */ } - push_target (ops); + if (!target_is_pushed (ops)) + push_target (ops); target_terminal_init (); 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); } @@ -1125,13 +1231,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 @@ -1229,34 +1328,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) { @@ -1264,7 +1353,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]; @@ -1285,55 +1374,93 @@ 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; + +/* "target native". */ +static struct target_ops *nto_native_ops; + +/* to_open implementation for "target procfs". */ + +static void +procfs_open (char *arg, int from_tty) +{ + procfs_open_1 (&nto_procfs_ops, arg, from_tty); +} + +/* to_open implementation for "target native". */ + +static void +procfs_native_open (char *arg, int from_tty) +{ + procfs_open_1 (nto_native_ops, arg, from_tty); +} + +/* 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 = 1; - procfs_ops.to_has_memory = 1; - procfs_ops.to_has_stack = 1; - procfs_ops.to_has_registers = 1; - procfs_ops.to_has_execution = 1; - procfs_ops.to_magic = OPS_MAGIC; - procfs_ops.to_have_continuable_watchpoint = 1; + 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_native_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; + + nto_native_ops = t; + + /* 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 "; + t->to_open = procfs_open; + + add_target (&nto_procfs_ops); } #define OSTYPE_NTO 1 @@ -1343,8 +1470,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. */ @@ -1352,8 +1478,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; @@ -1390,32 +1516,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; }