X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fnto-procfs.c;h=311a0b1eff8033ebea6400e765076503506a4663;hb=e4975d6a9cd8aaf3fb14135b36850964def131d7;hp=d659f79c2bbc8af0474a21b5d8beeec91f6725fd;hpb=774ee6d252eba19d3e23c936d14bfc1f7fa70651;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/nto-procfs.c b/gdb/nto-procfs.c index d659f79c2b..311a0b1eff 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. - Copyright (C) 2003-2015 Free Software Foundation, Inc. + Copyright (C) 2003-2016 Free Software Foundation, Inc. Contributed by QNX Software Systems Ltd. @@ -30,6 +30,8 @@ #include #include #include +#include + #include "gdbcore.h" #include "inferior.h" #include "target.h" @@ -73,7 +75,7 @@ static int procfs_stopped_by_watchpoint (struct target_ops *ops); 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. */ -static char nto_procfs_path[PATH_MAX] = { "/proc" }; +static char *nodestr; static unsigned nto_procfs_node = ND_LOCAL_NODE; /* Return the current QNX Node, or error out. This is a simple @@ -85,10 +87,11 @@ nto_node (void) { unsigned node; - if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0) + if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 + || nodestr == NULL) return ND_LOCAL_NODE; - node = netmgr_strtond (nto_procfs_path, 0); + node = netmgr_strtond (nodestr, 0); if (node == -1) error (_("Lost the QNX node. Debug session probably over.")); @@ -108,12 +111,12 @@ procfs_is_nto_target (bfd *abfd) static void procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty) { - char *nodestr; char *endstr; char buffer[50]; int fd, total_size; procfs_sysinfo *sysinfo; struct cleanup *cleanups; + char nto_procfs_path[PATH_MAX]; /* Offer to kill previous inferiors before opening this target. */ target_preopen (from_tty); @@ -123,8 +126,11 @@ procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty) /* Set the default node used for spawning to this one, and only override it if there is a valid arg. */ + xfree (nodestr); + nodestr = NULL; + nto_procfs_node = ND_LOCAL_NODE; - nodestr = arg ? xstrdup (arg) : NULL; + nodestr = (arg != NULL) ? xstrdup (arg) : NULL; init_thread_list (); @@ -149,10 +155,8 @@ procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty) *endstr = 0; } } - snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "", - "/proc"); - if (nodestr) - xfree (nodestr); + snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", + (nodestr != NULL) ? nodestr : "", "/proc"); fd = open (nto_procfs_path, O_RDONLY); if (fd == -1) @@ -174,7 +178,7 @@ procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty) { total_size = sysinfo->total_size; sysinfo = alloca (total_size); - if (!sysinfo) + if (sysinfo == NULL) { printf_filtered ("Memory error: %d (%s)\n", errno, safe_strerror (errno)); @@ -359,7 +363,7 @@ procfs_pidlist (char *args, int from_tty) { DIR *dp = NULL; struct dirent *dirp = NULL; - char buf[512]; + char buf[PATH_MAX]; procfs_info *pidinfo = NULL; procfs_debuginfo *info = NULL; procfs_status *status = NULL; @@ -367,12 +371,16 @@ procfs_pidlist (char *args, int from_tty) pid_t pid; char name[512]; struct cleanup *cleanups; + char procfs_dir[PATH_MAX]; - dp = opendir (nto_procfs_path); + snprintf (procfs_dir, sizeof (procfs_dir), "%s%s", + (nodestr != NULL) ? nodestr : "", "/proc"); + + dp = opendir (procfs_dir); if (dp == NULL) { fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)", - nto_procfs_path, errno, safe_strerror (errno)); + procfs_dir, errno, safe_strerror (errno)); return; } @@ -395,7 +403,9 @@ procfs_pidlist (char *args, int from_tty) do_cleanups (cleanups); return; } - snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name); + snprintf (buf, sizeof (buf), "%s%s/%s/as", + (nodestr != NULL) ? nodestr : "", + "/proc", dirp->d_name); pid = atoi (dirp->d_name); } while (pid == 0); @@ -406,8 +416,7 @@ procfs_pidlist (char *args, int from_tty) { fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n", buf, errno, safe_strerror (errno)); - do_cleanups (cleanups); - return; + continue; } inner_cleanup = make_cleanup_close (fd); @@ -431,11 +440,16 @@ procfs_pidlist (char *args, int from_tty) status = (procfs_status *) buf; for (status->tid = 1; status->tid <= num_threads; status->tid++) { - if (devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0) != EOK - && status->tid != 0) - break; - if (status->tid != 0) - printf_filtered ("%s - %d/%d\n", name, pid, status->tid); + const int err + = devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0); + printf_filtered ("%s - %d", name, pid); + if (err == EOK && status->tid != 0) + printf_filtered ("/%d\n", status->tid); + else + { + printf_filtered ("\n"); + break; + } } do_cleanups (inner_cleanup); @@ -502,7 +516,7 @@ procfs_meminfo (char *args, int from_tty) return; } - num = min (num, num_mapinfos); + num = std::min (num, num_mapinfos); /* Run through the list of mapinfos, and store the data and text info so we can print it at the bottom of the loop. */ @@ -599,7 +613,35 @@ procfs_files_info (struct target_ops *ignore) printf_unfiltered ("\tUsing the running image of %s %s via %s.\n", inf->attach_flag ? "attached" : "child", - target_pid_to_str (inferior_ptid), nto_procfs_path); + target_pid_to_str (inferior_ptid), + (nodestr != NULL) ? nodestr : "local node"); +} + +/* Target to_pid_to_exec_file implementation. */ + +static char * +procfs_pid_to_exec_file (struct target_ops *ops, const int pid) +{ + int proc_fd; + static char proc_path[PATH_MAX]; + ssize_t rd; + + /* Read exe file name. */ + snprintf (proc_path, sizeof (proc_path), "%s/proc/%d/exefile", + (nodestr != NULL) ? nodestr : "", pid); + proc_fd = open (proc_path, O_RDONLY); + if (proc_fd == -1) + return NULL; + + rd = read (proc_fd, proc_path, sizeof (proc_path) - 1); + close (proc_fd); + if (rd <= 0) + { + proc_path[0] = '\0'; + return NULL; + } + proc_path[rd] = '\0'; + return proc_path; } /* Attach to process PID, then initialize for debugging it. */ @@ -653,8 +695,8 @@ do_attach (ptid_t ptid) struct sigevent event; char path[PATH_MAX]; - snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path, - ptid_get_pid (ptid)); + snprintf (path, PATH_MAX - 1, "%s%s/%d/as", + (nodestr != NULL) ? nodestr : "", "/proc", 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,16 +723,12 @@ do_attach (ptid_t ptid) static void interrupt_query (void) { - target_terminal_ours (); - if (query (_("Interrupted while waiting for the program.\n\ Give up (and stop debugging it)? "))) { - target_mourn_inferior (); + target_mourn_inferior (inferior_ptid); quit (); } - - target_terminal_inferior (); } /* The user typed ^C twice. */ @@ -742,6 +780,9 @@ procfs_wait (struct target_ops *ops, devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0); } + nto_inferior_data (NULL)->stopped_flags = status.flags; + nto_inferior_data (NULL)->stopped_pc = status.ip; + if (status.flags & _DEBUG_FLAG_SSTEP) { ourstatus->kind = TARGET_WAITKIND_STOPPED; @@ -872,6 +913,38 @@ procfs_xfer_partial (struct target_ops *ops, enum target_object object, { case TARGET_OBJECT_MEMORY: return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len); + case TARGET_OBJECT_AUXV: + if (readbuf != NULL) + { + int err; + CORE_ADDR initial_stack; + debug_process_t procinfo; + /* For 32-bit architecture, size of auxv_t is 8 bytes. */ + const unsigned int sizeof_auxv_t = sizeof (auxv_t); + const unsigned int sizeof_tempbuf = 20 * sizeof_auxv_t; + int tempread; + gdb_byte *const tempbuf = alloca (sizeof_tempbuf); + + if (tempbuf == NULL) + return TARGET_XFER_E_IO; + + err = devctl (ctl_fd, DCMD_PROC_INFO, &procinfo, + sizeof procinfo, 0); + if (err != EOK) + return TARGET_XFER_E_IO; + + initial_stack = procinfo.initial_stack; + + /* procfs is always 'self-hosted', no byte-order manipulation. */ + tempread = nto_read_auxv_from_initial_stack (initial_stack, tempbuf, + sizeof_tempbuf, + sizeof (auxv_t)); + tempread = std::min (tempread, len) - offset; + memcpy (readbuf, tempbuf + offset, tempread); + *xfered_len = tempread; + return tempread ? TARGET_XFER_OK : TARGET_XFER_EOF; + } + /* Fallthru */ default: return ops->beneath->to_xfer_partial (ops->beneath, object, annex, readbuf, writebuf, offset, len, @@ -889,15 +962,8 @@ procfs_detach (struct target_ops *ops, const char *args, int from_tty) int siggnal = 0; int pid; - if (from_tty) - { - char *exec_file = get_exec_file (0); - if (exec_file == 0) - exec_file = ""; - printf_unfiltered ("Detaching from program: %s %s\n", - exec_file, target_pid_to_str (inferior_ptid)); - gdb_flush (gdb_stdout); - } + target_announce_detach (); + if (args) siggnal = atoi (args); @@ -938,7 +1004,8 @@ procfs_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, static int procfs_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) { return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1); } @@ -1121,7 +1188,7 @@ procfs_create_inferior (struct target_ops *ops, char *exec_file, } args = xstrdup (allargs); - breakup_args (args, exec_file ? &argv[1] : &argv[0]); + breakup_args (args, (exec_file != NULL) ? &argv[1] : &argv[0]); argv = nto_parse_redirection (argv, &in, &out, &err); @@ -1233,7 +1300,7 @@ procfs_interrupt (struct target_ops *self, ptid_t ptid) static void procfs_kill_inferior (struct target_ops *ops) { - target_mourn_inferior (); + target_mourn_inferior (inferior_ptid); } /* Fill buf with regset and return devctl cmd to do the setting. Return @@ -1444,6 +1511,7 @@ init_procfs_targets (void) t->to_interrupt = procfs_interrupt; t->to_have_continuable_watchpoint = 1; t->to_extra_thread_info = nto_extra_thread_info; + t->to_pid_to_exec_file = procfs_pid_to_exec_file; nto_native_ops = t; @@ -1551,5 +1619,21 @@ procfs_insert_hw_watchpoint (struct target_ops *self, static int procfs_stopped_by_watchpoint (struct target_ops *ops) { - return 0; + /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are + stopped due to a SIGTRAP. This assumes gdb works in 'all-stop' mode; + future gdb versions will likely run in 'non-stop' mode in which case + we will have to store/examine statuses per thread in question. + Until then, this will work fine. */ + + struct inferior *inf = current_inferior (); + struct nto_inferior_data *inf_data; + + gdb_assert (inf != NULL); + + inf_data = nto_inferior_data (inf); + + return inf_data->stopped_flags + & (_DEBUG_FLAG_TRACE_RD + | _DEBUG_FLAG_TRACE_WR + | _DEBUG_FLAG_TRACE_MODIFY); }