diff options
| -rw-r--r-- | gdb/ChangeLog | 40 | ||||
| -rw-r--r-- | gdb/procfs.c | 858 | ||||
| -rw-r--r-- | gdb/sol-thread.c | 167 | ||||
| -rw-r--r-- | gdb/thread.c | 30 |
4 files changed, 715 insertions, 380 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 8fdbff9..17ba1e8 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,43 @@ +Wed May 21 16:03:25 1997 Michael Snyder <msnyder@cleaver.cygnus.com> + + * procfs.c (init_procinfo): new function, abstracts some code + shared by create_procinfo and do_attach; + (procfs_set_inferior_syscall_traps): new function, abstracts + some code needed by procfs_init_inferior, do_attach, and + procfs_lwp_creation_handler; (procfs_first_available): new + function, find any LWP that's runnable; (procfs_thread_alive): + replace stub function with real implementation; + (procfs_lwp_creation_handler): fix bug starting new child + threads; (info_proc): bug fixes and enhancements for the + "INFO PROCESSES" command; (close_procinfo_file): call new + function "delete_thread" to cleanup GDB's thread database; + (proc_init_failed): add new argument "kill", to control whether + process is killed (so this function can be shared by + create_procinfo and do_attach); (procfs_exit_handler): handle + exit from an attached process, and cleanup procinfo handles + when the process exits; (procfs_resume, procfs_wait): cleanup + after a thread when it exits; (do_attach, do_detach): handle + attached processes with multiple threads; plus some general + improvements in the diagnostic output. + * sol-thread.c (sol_thread_alive): replace stub with real + implementation; (thread_to_lwp, lwp_to_thread): enhance to + handle threads that may have exited; (sol_thread_attach): add + startup setup stuff; (sol_thread_detach): add unpush_target + call; (sol_thread_mourn_inferior): add unpush_target call; + (sol_thread_wait, sol_thread_resume): enhance to deal with + thread exit cleanly; (sol_thread_new_objfile, + sol_thread_pid_to_str): detect unsuccessful startup and + don't crash; plus some general cleanup. + * thread.c (delete_thread): new function, allows targets to + notify gdb when a thread is no longer valid. + * infrun.c (wait_for_inferior): don't try to detect a new + thread on receiving a TARGET_EXITED event. + +Tue May 20 09:32:02 1997 Andrew Cagney <cagney@b1.cygnus.com> + + * remote-sim.c (gdbsim_open): Pass callback struct. + (init_callbacks): Remove call to sim_set_callbacks. + Thu May 15 07:56:50 1997 Peter Schauer (pes@regent.e-technik.tu-muenchen.de) * config/rs6000/tm-rs6000.h (SIG_FRAME_LR_OFFSET): Define. diff --git a/gdb/procfs.c b/gdb/procfs.c index 9d3c969..c6a74a3 100644 --- a/gdb/procfs.c +++ b/gdb/procfs.c @@ -181,14 +181,15 @@ struct procinfo { struct sig_ctl saved_trace; /* Saved traced signal set */ struct sys_ctl saved_exitset; /* Saved traced system call exit set */ struct sys_ctl saved_entryset;/* Saved traced system call entry set */ - int num_syscall_handlers; /* Number of syscall handlers currently installed */ - struct procfs_syscall_handler *syscall_handlers; /* Pointer to list of syscall trap handlers */ + int num_syscall_handlers; /* Number of syscall trap handlers + currently installed */ + /* Pointer to list of syscall trap handlers */ + struct procfs_syscall_handler *syscall_handlers; int new_child; /* Non-zero if it's a new thread */ }; /* List of inferior process information */ static struct procinfo *procinfo_list = NULL; - static struct pollfd *poll_list; /* pollfds used for waiting on /proc */ static int num_poll_list = 0; /* Number of entries in poll_list */ @@ -248,6 +249,15 @@ static struct trans pr_flag_table[] = #if defined (PR_PCOMPAT) { PR_PCOMPAT, "PR_PCOMPAT", "Ptrace compatibility mode in effect" }, #endif +#if defined (PR_MSACCT) + { PR_MSACCT, "PR_MSACCT", "Microstate accounting enabled" }, +#endif +#if defined (PR_BPTADJ) + { PR_BPTADJ, "PR_BPTADJ", "Breakpoint PC adjustment in effect" }, +#endif +#if defined (PR_ASLWP) + { PR_ASLWP, "PR_ASLWP", "Asynchronus signal LWP" }, +#endif { 0, NULL, NULL } }; @@ -261,9 +271,6 @@ static struct trans pr_why_table[] = #if defined (PR_SIGNALLED) { PR_SIGNALLED, "PR_SIGNALLED", "Receipt of a traced signal" }, #endif -#if defined (PR_FAULTED) - { PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault" }, -#endif #if defined (PR_SYSENTRY) { PR_SYSENTRY, "PR_SYSENTRY", "Entry to a traced system call" }, #endif @@ -273,9 +280,15 @@ static struct trans pr_why_table[] = #if defined (PR_JOBCONTROL) { PR_JOBCONTROL, "PR_JOBCONTROL", "Default job control stop signal action" }, #endif +#if defined (PR_FAULTED) + { PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault" }, +#endif #if defined (PR_SUSPENDED) { PR_SUSPENDED, "PR_SUSPENDED", "Process suspended" }, #endif +#if defined (PR_CHECKPOINT) + { PR_CHECKPOINT, "PR_CHECKPOINT", "(???)" }, +#endif { 0, NULL, NULL } }; @@ -502,7 +515,7 @@ static void close_proc_file PARAMS ((struct procinfo *)); static void unconditionally_kill_inferior PARAMS ((struct procinfo *)); -static NORETURN void proc_init_failed PARAMS ((struct procinfo *, char *)) ATTR_NORETURN; +static NORETURN void proc_init_failed PARAMS ((struct procinfo *, char *, int)) ATTR_NORETURN; static void info_proc PARAMS ((char *, int)); @@ -538,8 +551,8 @@ static void notice_signals PARAMS ((struct procinfo *, struct sig_ctl *)); static struct procinfo *find_procinfo PARAMS ((pid_t pid, int okfail)); -static int procfs_read_status PARAMS ((struct procinfo *)); static int procfs_write_pcwstop PARAMS ((struct procinfo *)); +static int procfs_read_status PARAMS ((struct procinfo *)); static void procfs_write_pckill PARAMS ((struct procinfo *)); typedef int syscall_func_t PARAMS ((struct procinfo *pi, int syscall_num, @@ -684,6 +697,22 @@ add_fd (pi) num_poll_list++; } +/* + +LOCAL FUNCTION + + remove_fd -- Remove the fd from the poll/select list + +SYNOPSIS + + static void remove_fd (struct procinfo *); + +DESCRIPTION + + Remove the fd of the supplied procinfo from the list of fds used + for poll/select operations. + */ + static void remove_fd (pi) struct procinfo *pi; @@ -859,7 +888,8 @@ wait_fd () for (i = 0; i < num_poll_list && num_fds > 0; i++) { - if ((poll_list[i].revents & (POLLWRNORM|POLLPRI|POLLERR|POLLHUP|POLLNVAL)) == 0) + if (0 == (poll_list[i].revents & + (POLLWRNORM | POLLPRI | POLLERR | POLLHUP | POLLNVAL))) continue; for (pi = procinfo_list; pi; pi = pi->next) { @@ -867,8 +897,11 @@ wait_fd () { if (!procfs_read_status(pi)) { - print_sys_errmsg (pi->pathname, errno); - error ("procfs_read_status failed"); + /* The LWP has apparently terminated. */ + if (info_verbose) + printf_filtered ("LWP %d doesn't respond.\n", + (pi->pid >> 16) & 0xffff); + /* could call close_proc_file here, but I'm afraid to... */ } num_fds--; @@ -1549,23 +1582,23 @@ init_syscall_table () #if defined (SYS_settimeofday) syscall_table[SYS_settimeofday] = "settimeofday"; #endif -#if defined (SYS_lwpcreate) - syscall_table[SYS_lwpcreate] = "lwpcreate"; +#if defined (SYS_lwp_create) + syscall_table[SYS_lwp_create] = "_lwp_create"; #endif -#if defined (SYS_lwpexit) - syscall_table[SYS_lwpexit] = "lwpexit"; +#if defined (SYS_lwp_exit) + syscall_table[SYS_lwp_exit] = "_lwp_exit"; #endif -#if defined (SYS_lwpwait) - syscall_table[SYS_lwpwait] = "lwpwait"; +#if defined (SYS_lwp_wait) + syscall_table[SYS_lwp_wait] = "_lwp_wait"; #endif -#if defined (SYS_lwpself) - syscall_table[SYS_lwpself] = "lwpself"; +#if defined (SYS_lwp_self) + syscall_table[SYS_lwp_self] = "_lwp_self"; #endif -#if defined (SYS_lwpinfo) - syscall_table[SYS_lwpinfo] = "lwpinfo"; +#if defined (SYS_lwp_info) + syscall_table[SYS_lwp_info] = "_lwp_info"; #endif -#if defined (SYS_lwpprivate) - syscall_table[SYS_lwpprivate] = "lwpprivate"; +#if defined (SYS_lwp_private) + syscall_table[SYS_lwp_private] = "_lwp_private"; #endif #if defined (SYS_processor_bind) syscall_table[SYS_processor_bind] = "processor_bind"; @@ -1600,8 +1633,8 @@ init_syscall_table () #if defined (SYS_ftruncate) syscall_table[SYS_ftruncate] = "ftruncate"; #endif -#if defined (SYS_lwpkill) - syscall_table[SYS_lwpkill] = "lwpkill"; +#if defined (SYS_lwp_kill) + syscall_table[SYS_lwp_kill] = "_lwp_kill"; #endif #if defined (SYS_sigwait) syscall_table[SYS_sigwait] = "sigwait"; @@ -1630,11 +1663,11 @@ init_syscall_table () #if defined (SYS_getksym) syscall_table[SYS_getksym] = "getksym"; #endif -#if defined (SYS_lwpsuspend) - syscall_table[SYS_lwpsuspend] = "lwpsuspend"; +#if defined (SYS_lwp_suspend) + syscall_table[SYS_lwp_suspend] = "_lwp_suspend"; #endif -#if defined (SYS_lwpcontinue) - syscall_table[SYS_lwpcontinue] = "lwpcontinue"; +#if defined (SYS_lwp_continue) + syscall_table[SYS_lwp_continue] = "_lwp_continue"; #endif #if defined (SYS_priocntllst) syscall_table[SYS_priocntllst] = "priocntllst"; @@ -1643,10 +1676,10 @@ init_syscall_table () syscall_table[SYS_sleep] = "sleep"; #endif #if defined (SYS_lwp_sema_wait) - syscall_table[SYS_lwp_sema_wait] = "lwp_sema_wait"; + syscall_table[SYS_lwp_sema_wait] = "_lwp_sema_wait"; #endif #if defined (SYS_lwp_sema_post) - syscall_table[SYS_lwp_sema_post] = "lwp_sema_post"; + syscall_table[SYS_lwp_sema_post] = "_lwp_sema_post"; #endif #if defined (SYS_lwp_sema_trywait) syscall_table[SYS_lwp_sema_trywait] = "lwp_sema_trywait"; @@ -1928,17 +1961,17 @@ procfs_store_registers (regno) LOCAL FUNCTION - create_procinfo - initialize access to a /proc entry + init_procinfo - setup a procinfo struct and connect it to a process SYNOPSIS - struct procinfo * create_procinfo (int pid) + struct procinfo * init_procinfo (int pid) DESCRIPTION Allocate a procinfo structure, open the /proc file and then set up the set of signals and faults that are to be traced. Returns a pointer to - the new procinfo structure. + the new procinfo structure. NOTES @@ -1948,21 +1981,16 @@ NOTES */ static struct procinfo * -create_procinfo (pid) +init_procinfo (pid, kill) int pid; + int kill; { - struct procinfo *pi; - struct sig_ctl sctl; - struct flt_ctl fctl; - - pi = find_procinfo (pid, 1); - if (pi != NULL) - return pi; /* All done! It already exists */ - - pi = (struct procinfo *) xmalloc (sizeof (struct procinfo)); + struct procinfo *pi = (struct procinfo *) + xmalloc (sizeof (struct procinfo)); + memset ((char *) pi, 0, sizeof (*pi)); if (!open_proc_file (pid, pi, O_RDWR, 1)) - proc_init_failed (pi, "can't open process file"); + proc_init_failed (pi, "can't open process file", kill); /* open_proc_file may modify pid. */ @@ -1975,14 +2003,34 @@ create_procinfo (pid) add_fd (pi); /* Add to list for poll/select */ - pi->num_syscall_handlers = 0; - pi->syscall_handlers = NULL; + /* Remember some things about the inferior that we will, or might, change + so that we can restore them when we detach. */ #ifdef UNIXWARE + memcpy ((char *) &pi->saved_trace.sigset, + (char *) &pi->prstatus.pr_sigtrace, sizeof (sigset_t)); + memcpy ((char *) &pi->saved_fltset.fltset, + (char *) &pi->prstatus.pr_flttrace, sizeof (fltset_t)); + memcpy ((char *) &pi->saved_entryset.sysset, + (char *) &pi->prstatus.pr_sysentry, sizeof (sysset_t)); + memcpy ((char *) &pi->saved_exitset.sysset, + (char *) &pi->prstatus.pr_sysexit, sizeof (sysset_t)); + + /* Set up trace and fault sets, as gdb expects them. */ + prfillset (&sctl.sigset); - notice_signals (pi, &sctl); + notice_signals (pi, &sctl); prfillset (&fctl.fltset); prdelset (&fctl.fltset, FLTPAGE); -#else /* UNIXWARE */ + +#else /* ! UNIXWARE */ + ioctl (pi->ctl_fd, PIOCGTRACE, &pi->saved_trace.sigset); + ioctl (pi->ctl_fd, PIOCGHOLD, &pi->saved_sighold.sigset); + ioctl (pi->ctl_fd, PIOCGFAULT, &pi->saved_fltset.fltset); + ioctl (pi->ctl_fd, PIOCGENTRY, &pi->saved_entryset.sysset); + ioctl (pi->ctl_fd, PIOCGEXIT, &pi->saved_exitset.sysset); + + /* Set up trace and fault sets, as gdb expects them. */ + memset ((char *) &pi->prrun, 0, sizeof (pi->prrun)); prfillset (&pi->prrun.pr_trace); procfs_notice_signals (pid); @@ -1994,24 +2042,63 @@ create_procinfo (pid) #endif /* UNIXWARE */ if (!procfs_read_status (pi)) - proc_init_failed (pi, "procfs_read_status failed"); + proc_init_failed (pi, "procfs_read_status failed", kill); -/* A bug in Solaris (2.5 at least) causes PIOCWSTOP to hang on LWPs that are - already stopped, even if they all have PR_ASYNC set. */ + return pi; +} + +/* + +LOCAL FUNCTION + + create_procinfo - initialize access to a /proc entry + +SYNOPSIS + + struct procinfo * create_procinfo (int pid) + +DESCRIPTION + + Allocate a procinfo structure, open the /proc file and then set up the + set of signals and faults that are to be traced. Returns a pointer to + the new procinfo structure. + +NOTES + + If proc_init_failed ever gets called, control returns to the command + processing loop via the standard error handling code. + + */ + +static struct procinfo * +create_procinfo (pid) + int pid; +{ + struct procinfo *pi; + struct sig_ctl sctl; + struct flt_ctl fctl; + + pi = find_procinfo (pid, 1); + if (pi != NULL) + return pi; /* All done! It already exists */ + + pi = init_procinfo (pid, 1); #ifndef UNIXWARE +/* A bug in Solaris (2.5 at least) causes PIOCWSTOP to hang on LWPs that are + already stopped, even if they all have PR_ASYNC set. */ if (!(pi->prstatus.pr_flags & PR_STOPPED)) #endif if (!procfs_write_pcwstop (pi)) - proc_init_failed (pi, "procfs_write_pcwstop failed"); + proc_init_failed (pi, "procfs_write_pcwstop failed", 1); #ifdef PROCFS_USE_READ_WRITE fctl.cmd = PCSFAULT; if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0) - proc_init_failed (pi, "PCSFAULT failed"); + proc_init_failed (pi, "PCSFAULT failed", 1); #else if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault) < 0) - proc_init_failed (pi, "PIOCSFAULT failed"); + proc_init_failed (pi, "PIOCSFAULT failed", 1); #endif return pi; @@ -2047,15 +2134,37 @@ procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp) int *rtnvalp; int *statvalp; { + struct procinfo *temp_pi, *next_pi; + pi->prrun.pr_flags = PRCFAULT; if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0) perror_with_name (pi->pathname); - *rtnvalp = wait (statvalp); - if (*rtnvalp >= 0) - *rtnvalp = pi->pid; + if (attach_flag) + { + /* Claim it exited (don't call wait). */ + if (info_verbose) + printf_filtered ("(attached process has exited)\n"); + *statvalp = 0; + *rtnvalp = inferior_pid; + } + else + { + *rtnvalp = wait (statvalp); + if (*rtnvalp >= 0) + *rtnvalp = pi->pid; + } + /* Close ALL open proc file handles, + except the one that called SYS_exit. */ + for (temp_pi = procinfo_list; temp_pi; temp_pi = next_pi) + { + next_pi = temp_pi->next; + if (temp_pi == pi) + continue; /* Handled below */ + close_proc_file (temp_pi); + } return 1; } @@ -2223,39 +2332,24 @@ procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp) LOCAL FUNCTION - procfs_init_inferior - initialize target vector and access to a - /proc entry + procfs_set_inferior_syscall_traps - setup the syscall traps SYNOPSIS - int procfs_init_inferior (int pid) + void procfs_set_inferior_syscall_traps (struct procinfo *pip) DESCRIPTION - When gdb starts an inferior, this function is called in the parent - process immediately after the fork. It waits for the child to stop - on the return from the exec system call (the child itself takes care - of ensuring that this is set up), then sets up the set of signals - and faults that are to be traced. Returns the pid, which may have had - the thread-id added to it. - -NOTES - - If proc_init_failed ever gets called, control returns to the command - processing loop via the standard error handling code. + Called for each "procinfo" (process, thread, or LWP) in the + inferior, to register for notification of and handlers for + syscall traps in the inferior. */ -static int -procfs_init_inferior (pid) - int pid; +static void +procfs_set_inferior_syscall_traps (pip) + struct procinfo *pip; { - struct procinfo *pip; - - push_target (&procfs_ops); - - pip = create_procinfo (pid); - #ifndef PIOCSSPCACT procfs_set_syscall_trap (pip, SYS_exit, PROCFS_SYSCALL_ENTRY, procfs_exit_handler); @@ -2297,6 +2391,46 @@ procfs_init_inferior (pid) procfs_set_syscall_trap (pip, SYS_lwp_create, PROCFS_SYSCALL_EXIT, procfs_lwp_creation_handler); #endif +} + +/* + +LOCAL FUNCTION + + procfs_init_inferior - initialize target vector and access to a + /proc entry + +SYNOPSIS + + int procfs_init_inferior (int pid) + +DESCRIPTION + + When gdb starts an inferior, this function is called in the parent + process immediately after the fork. It waits for the child to stop + on the return from the exec system call (the child itself takes care + of ensuring that this is set up), then sets up the set of signals + and faults that are to be traced. Returns the pid, which may have had + the thread-id added to it. + +NOTES + + If proc_init_failed ever gets called, control returns to the command + processing loop via the standard error handling code. + + */ + +static int +procfs_init_inferior (pid) + int pid; +{ + struct procinfo *pip; + + push_target (&procfs_ops); + + pip = create_procinfo (pid); + + procfs_set_inferior_syscall_traps (pip); /* create_procinfo may change the pid, so we have to update inferior_pid here before calling other gdb routines that need the right pid. */ @@ -2863,131 +2997,93 @@ do_attach (pid) struct procinfo *pi; struct sig_ctl sctl; struct flt_ctl fctl; + int nlwp, *lwps; - pi = (struct procinfo *) xmalloc (sizeof (struct procinfo)); - - if (!open_proc_file (pid, pi, O_RDWR, 1)) - { - free (pi); - perror_with_name (pi->pathname); - /* NOTREACHED */ - } - - pid = pi -> pid; - - /* Add new process to process info list */ - - pi->next = procinfo_list; - procinfo_list = pi; + pi = init_procinfo (pid, 0); - add_fd (pi); /* Add to list for poll/select */ +#ifdef PIOCLWPIDS + nlwp = pi->prstatus.pr_nlwp; + lwps = alloca ((2 * nlwp + 2) * sizeof (id_t)); - /* Get current status of process and if it is not already stopped, - then stop it. Remember whether or not it was stopped when we first - examined it. */ - if (!procfs_read_status (pi)) + if (ioctl (pi->ctl_fd, PIOCLWPIDS, lwps)) { - print_sys_errmsg (pi->pathname, errno); - close_proc_file (pi); - error ("procfs_read_status failed"); + print_sys_errmsg (pi -> pathname, errno); + error ("PIOCLWPIDS failed"); } +#else /* PIOCLWPIDS */ + nlwp = 1; + lwps = alloca ((2 * nlwp + 2) * sizeof *lwps); + lwps[0] = 0; +#endif + for (; nlwp > 0; nlwp--, lwps++) + { + /* First one has already been created above. */ + if ((pi = find_procinfo ((*lwps << 16) | pid, 1)) == 0) + pi = init_procinfo ((*lwps << 16) | pid, 0); + #ifdef UNIXWARE - if (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP)) + if (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP)) #else - if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)) + if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP)) #endif - { - pi->was_stopped = 1; - } - else - { - pi->was_stopped = 0; - if (1 || query ("Process is currently running, stop it? ")) { - long cmd; - /* Make it run again when we close it. */ - - modify_run_on_last_close_flag (pi->ctl_fd, 1); - + pi->was_stopped = 1; + } + else + { + pi->was_stopped = 0; + if (1 || query ("Process is currently running, stop it? ")) + { + long cmd; + /* Make it run again when we close it. */ + modify_run_on_last_close_flag (pi->ctl_fd, 1); #ifdef PROCFS_USE_READ_WRITE - cmd = PCSTOP; - if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0) + cmd = PCSTOP; + if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0) #else - if (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) < 0) + if (ioctl (pi->ctl_fd, PIOCSTOP, &pi->prstatus) < 0) #endif - { - print_sys_errmsg (pi->pathname, errno); - close_proc_file (pi); - error ("PIOCSTOP failed"); - } + { + print_sys_errmsg (pi->pathname, errno); + close_proc_file (pi); + error ("PIOCSTOP failed"); + } #ifdef UNIXWARE - if (!procfs_read_status (pi)) - { - print_sys_errmsg (pi->pathname, errno); - close_proc_file (pi); - error ("procfs_read_status failed"); - } + if (!procfs_read_status (pi)) + { + print_sys_errmsg (pi->pathname, errno); + close_proc_file (pi); + error ("procfs_read_status failed"); + } #endif - pi->nopass_next_sigstop = 1; - } - else - { - printf_unfiltered ("Ok, gdb will wait for %s to stop.\n", target_pid_to_str (pid)); + pi->nopass_next_sigstop = 1; + } + else + { + printf_unfiltered ("Ok, gdb will wait for %s to stop.\n", + target_pid_to_str (pi->pid)); + } } - } - /* Remember some things about the inferior that we will, or might, change - so that we can restore them when we detach. */ #ifdef PROCFS_USE_READ_WRITE - memcpy ((char *) &pi->saved_trace.sigset, - (char *) &pi->prstatus.pr_sigtrace, sizeof (sigset_t)); - memcpy ((char *) &pi->saved_fltset.fltset, - (char *) &pi->prstatus.pr_flttrace, sizeof (fltset_t)); - memcpy ((char *) &pi->saved_entryset.sysset, - (char *) &pi->prstatus.pr_sysentry, sizeof (sysset_t)); - memcpy ((char *) &pi->saved_exitset.sysset, - (char *) &pi->prstatus.pr_sysexit, sizeof (sysset_t)); - - /* Set up trace and fault sets, as gdb expects them. */ - - prfillset (&sctl.sigset); - notice_signals (pi, &sctl); - prfillset (&fctl.fltset); - prdelset (&fctl.fltset, FLTPAGE); - - fctl.cmd = PCSFAULT; - if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0) - print_sys_errmsg ("PCSFAULT failed", errno); + fctl.cmd = PCSFAULT; + if (write (pi->ctl_fd, (char *) &fctl, sizeof (struct flt_ctl)) < 0) + print_sys_errmsg ("PCSFAULT failed", errno); #else /* PROCFS_USE_READ_WRITE */ - ioctl (pi->ctl_fd, PIOCGTRACE, &pi->saved_trace.sigset); - ioctl (pi->ctl_fd, PIOCGHOLD, &pi->saved_sighold.sigset); - ioctl (pi->ctl_fd, PIOCGFAULT, &pi->saved_fltset.fltset); - ioctl (pi->ctl_fd, PIOCGENTRY, &pi->saved_entryset.sysset); - ioctl (pi->ctl_fd, PIOCGEXIT, &pi->saved_exitset.sysset); - - /* Set up trace and fault sets, as gdb expects them. */ - - memset (&pi->prrun, 0, sizeof (pi->prrun)); - prfillset (&pi->prrun.pr_trace); - procfs_notice_signals (pid); - prfillset (&pi->prrun.pr_fault); - prdelset (&pi->prrun.pr_fault, FLTPAGE); - -#ifdef PROCFS_DONT_TRACE_FAULTS - premptyset (&pi->prrun.pr_fault); -#endif - - if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault)) - { - print_sys_errmsg ("PIOCSFAULT failed", errno); - } - if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->prrun.pr_trace)) - { - print_sys_errmsg ("PIOCSTRACE failed", errno); + if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->prrun.pr_fault)) + { + print_sys_errmsg ("PIOCSFAULT failed", errno); + } + if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->prrun.pr_trace)) + { + print_sys_errmsg ("PIOCSTRACE failed", errno); + } + add_thread (pi->pid); + procfs_set_inferior_syscall_traps (pi); } #endif /* PROCFS_USE_READ_WRITE */ attach_flag = 1; - return (pid); + return (pi->pid); } /* @@ -3025,106 +3121,107 @@ do_detach (signal) { struct procinfo *pi; - pi = current_procinfo; - - if (signal) + for (pi = procinfo_list; pi; pi = pi->next) { - set_proc_siginfo (pi, signal); - } + if (signal) + { + set_proc_siginfo (pi, signal); + } #ifdef PROCFS_USE_READ_WRITE - pi->saved_exitset.cmd = PCSEXIT; - if (write (pi->ctl_fd, (char *) &pi->saved_exitset, - sizeof (struct sys_ctl)) < 0) + pi->saved_exitset.cmd = PCSEXIT; + if (write (pi->ctl_fd, (char *) &pi->saved_exitset, + sizeof (struct sys_ctl)) < 0) #else - if (ioctl (pi->ctl_fd, PIOCSEXIT, &pi->saved_exitset.sysset) < 0) + if (ioctl (pi->ctl_fd, PIOCSEXIT, &pi->saved_exitset.sysset) < 0) #endif - { - print_sys_errmsg (pi->pathname, errno); - printf_unfiltered ("PIOCSEXIT failed.\n"); - } + { + print_sys_errmsg (pi->pathname, errno); + printf_unfiltered ("PIOCSEXIT failed.\n"); + } #ifdef PROCFS_USE_READ_WRITE - pi->saved_entryset.cmd = PCSENTRY; - if (write (pi->ctl_fd, (char *) &pi->saved_entryset, - sizeof (struct sys_ctl)) < 0) + pi->saved_entryset.cmd = PCSENTRY; + if (write (pi->ctl_fd, (char *) &pi->saved_entryset, + sizeof (struct sys_ctl)) < 0) #else - if (ioctl (pi->ctl_fd, PIOCSENTRY, &pi->saved_entryset.sysset) < 0) + if (ioctl (pi->ctl_fd, PIOCSENTRY, &pi->saved_entryset.sysset) < 0) #endif - { - print_sys_errmsg (pi->pathname, errno); - printf_unfiltered ("PIOCSENTRY failed.\n"); - } + { + print_sys_errmsg (pi->pathname, errno); + printf_unfiltered ("PIOCSENTRY failed.\n"); + } #ifdef PROCFS_USE_READ_WRITE - pi->saved_trace.cmd = PCSTRACE; - if (write (pi->ctl_fd, (char *) &pi->saved_trace, - sizeof (struct sig_ctl)) < 0) + pi->saved_trace.cmd = PCSTRACE; + if (write (pi->ctl_fd, (char *) &pi->saved_trace, + sizeof (struct sig_ctl)) < 0) #else - if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->saved_trace.sigset) < 0) + if (ioctl (pi->ctl_fd, PIOCSTRACE, &pi->saved_trace.sigset) < 0) #endif - { - print_sys_errmsg (pi->pathname, errno); - printf_unfiltered ("PIOCSTRACE failed.\n"); - } + { + print_sys_errmsg (pi->pathname, errno); + printf_unfiltered ("PIOCSTRACE failed.\n"); + } #ifndef UNIXWARE - if (ioctl (pi->ctl_fd, PIOCSHOLD, &pi->saved_sighold.sigset) < 0) - { - print_sys_errmsg (pi->pathname, errno); - printf_unfiltered ("PIOSCHOLD failed.\n"); - } + if (ioctl (pi->ctl_fd, PIOCSHOLD, &pi->saved_sighold.sigset) < 0) + { + print_sys_errmsg (pi->pathname, errno); + printf_unfiltered ("PIOSCHOLD failed.\n"); + } #endif #ifdef PROCFS_USE_READ_WRITE - pi->saved_fltset.cmd = PCSFAULT; - if (write (pi->ctl_fd, (char *) &pi->saved_fltset, - sizeof (struct flt_ctl)) < 0) + pi->saved_fltset.cmd = PCSFAULT; + if (write (pi->ctl_fd, (char *) &pi->saved_fltset, + sizeof (struct flt_ctl)) < 0) #else - if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->saved_fltset.fltset) < 0) + if (ioctl (pi->ctl_fd, PIOCSFAULT, &pi->saved_fltset.fltset) < 0) #endif - { - print_sys_errmsg (pi->pathname, errno); - printf_unfiltered ("PIOCSFAULT failed.\n"); - } - if (!procfs_read_status (pi)) - { - print_sys_errmsg (pi->pathname, errno); - printf_unfiltered ("procfs_read_status failed.\n"); - } - else - { + { + print_sys_errmsg (pi->pathname, errno); + printf_unfiltered ("PIOCSFAULT failed.\n"); + } + if (!procfs_read_status (pi)) + { + print_sys_errmsg (pi->pathname, errno); + printf_unfiltered ("procfs_read_status failed.\n"); + } + else + { #ifdef UNIXWARE - if (signal || (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP))) + if (signal || (pi->prstatus.pr_lwp.pr_flags & (PR_STOPPED | PR_ISTOP))) #else - if (signal || (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))) + if (signal || (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))) #endif - { - long cmd; - struct proc_ctl pctl; - - if (signal || !pi->was_stopped || - query ("Was stopped when attached, make it runnable again? ")) { - /* Clear any pending signal if we want to detach without - a signal. */ - if (signal == 0) - set_proc_siginfo (pi, signal); + long cmd; + struct proc_ctl pctl; - /* Clear any fault that might have stopped it. */ + if (signal || !pi->was_stopped || + query ("Was stopped when attached, make it runnable again? ")) + { + /* Clear any pending signal if we want to detach without + a signal. */ + if (signal == 0) + set_proc_siginfo (pi, signal); + + /* Clear any fault that might have stopped it. */ #ifdef PROCFS_USE_READ_WRITE - cmd = PCCFAULT; - if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0) + cmd = PCCFAULT; + if (write (pi->ctl_fd, (char *) &cmd, sizeof (long)) < 0) #else - if (ioctl (pi->ctl_fd, PIOCCFAULT, 0)) + if (ioctl (pi->ctl_fd, PIOCCFAULT, 0)) #endif - { - print_sys_errmsg (pi->pathname, errno); - printf_unfiltered ("PIOCCFAULT failed.\n"); - } + { + print_sys_errmsg (pi->pathname, errno); + printf_unfiltered ("PIOCCFAULT failed.\n"); + } - /* Make it run again when we close it. */ + /* Make it run again when we close it. */ - modify_run_on_last_close_flag (pi->ctl_fd, 1); + modify_run_on_last_close_flag (pi->ctl_fd, 1); + } } } + close_proc_file (pi); } - close_proc_file (pi); attach_flag = 0; } @@ -3152,7 +3249,6 @@ do_detach (signal) FIXME: Investigate why wait() seems to have problems with programs being control by /proc routines. */ - static int procfs_wait (pid, ourstatus) int pid; @@ -3203,16 +3299,17 @@ procfs_wait (pid, ourstatus) { checkerr++; } - } + } if (checkerr) { if (errno == ENOENT) { + /* XXX Fixme -- what to do if attached? Can't call wait... */ rtnval = wait (&statval); - if (rtnval != inferior_pid) + if ((rtnval) != (inferior_pid)) { print_sys_errmsg (pi->pathname, errno); - error ("procfs_write_pcwstop, wait failed, returned %d", rtnval); + error ("procfs_wait: wait failed, returned %d", rtnval); /* NOTREACHED */ } } @@ -3319,7 +3416,7 @@ procfs_wait (pid, ourstatus) case FLTBPT: case FLTTRACE: statval = (SIGTRAP << 8) | 0177; - break; + break; case FLTSTACK: case FLTACCESS: case FLTBOUNDS: @@ -3350,10 +3447,11 @@ procfs_wait (pid, ourstatus) /* Stop all the other threads when any of them stops. */ { - struct procinfo *procinfo; + struct procinfo *procinfo, *next_pi; - for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next) + for (procinfo = procinfo_list; procinfo; procinfo = next_pi) { + next_pi = procinfo->next; if (!procinfo->had_event) { #ifdef PROCFS_USE_READ_WRITE @@ -3369,15 +3467,20 @@ procfs_wait (pid, ourstatus) order to avoid the hang. */ if (!procfs_read_status (procinfo)) { - print_sys_errmsg (procinfo->pathname, errno); - error ("procfs_read_status failed"); + /* The LWP has apparently terminated. */ + if (info_verbose) + printf_filtered ("LWP %d doesn't respond.\n", + (procinfo->pid >> 16) & 0xffff); + close_proc_file (procinfo); + continue; } if (!(procinfo->prstatus.pr_flags & PR_STOPPED)) - if (ioctl (procinfo->ctl_fd, PIOCSTOP, &procinfo->prstatus) < 0) + if (ioctl (procinfo->ctl_fd, PIOCSTOP, &procinfo->prstatus) + < 0) { print_sys_errmsg (procinfo->pathname, errno); - error ("PIOCSTOP failed"); + warning ("PIOCSTOP failed"); } #endif } @@ -3394,7 +3497,7 @@ procfs_wait (pid, ourstatus) if (rtnval == -1) /* No more children to wait for */ { - fprintf_unfiltered (gdb_stderr, "Child process unexpectedly missing.\n"); + warning ("Child process unexpectedly missing"); /* Claim it exited with unknown signal. */ ourstatus->kind = TARGET_WAITKIND_SIGNALLED; ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; @@ -3514,7 +3617,7 @@ procfs_resume (pid, step, signo) enum target_signal signo; { int signal_to_pass; - struct procinfo *pi, *procinfo; + struct procinfo *pi, *procinfo, *next_pi; struct proc_ctl pctl; pi = find_procinfo (pid == -1 ? inferior_pid : pid, 0); @@ -3562,11 +3665,12 @@ procfs_resume (pid, step, signo) else if (signo == TARGET_SIGNAL_TSTP #ifdef UNIXWARE && pi->prstatus.pr_lwp.pr_cursig == SIGTSTP - && pi->prstatus.pr_lwp.pr_action.sa_handler == SIG_DFL) + && pi->prstatus.pr_lwp.pr_action.sa_handler == SIG_DFL #else && pi->prstatus.pr_cursig == SIGTSTP - && pi->prstatus.pr_action.sa_handler == SIG_DFL) + && pi->prstatus.pr_action.sa_handler == SIG_DFL #endif + ) /* We are about to pass the inferior a SIGTSTP whose action is SIG_DFL. The SIG_DFL action for a SIGTSTP is to stop @@ -3607,65 +3711,91 @@ procfs_resume (pid, step, signo) pi->prrun.pr_flags |= PRSTEP; #endif } - + pi->had_event = 0; /* Don't try to start a process unless it's stopped on an `event of interest'. Doing so will cause errors. */ + if (!procfs_read_status (pi)) + { + /* The LWP has apparently terminated. */ + if (info_verbose) + printf_filtered ("LWP %d doesn't respond.\n", + (pi->pid >> 16) & 0xffff); + close_proc_file (pi); + } + else + { #ifdef PROCFS_USE_READ_WRITE - if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0) + if (write (pi->ctl_fd, (char *) &pctl, sizeof (struct proc_ctl)) < 0) #else - if ((pi->prstatus.pr_flags & PR_ISTOP) - && ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0) + if ((pi->prstatus.pr_flags & PR_ISTOP) + && ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0) #endif - { - perror_with_name (pi->pathname); - /* NOTREACHED */ + { + /* The LWP has apparently terminated. */ + if (info_verbose) + printf_filtered ("LWP %d doesn't respond.\n", + (pi->pid >> 16) & 0xffff); + close_proc_file (pi); + } } - pi->had_event = 0; - - /* Continue all the other threads that haven't had an event of - interest. */ + /* Continue all the other threads that haven't had an event of interest. + Also continue them if they have NOPASS_NEXT_SIGSTOP set; this is only + set by do_attach, and means this is the first resume after an attach. + All threads were CSTOP'd by do_attach, and should be resumed now. */ if (pid == -1) - for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next) + for (procinfo = procinfo_list; procinfo; procinfo = next_pi) { - if (pi != procinfo && !procinfo->had_event) - { + next_pi = procinfo->next; + if (pi != procinfo) + if (!procinfo->had_event || + (procinfo->nopass_next_sigstop && signo == TARGET_SIGNAL_STOP)) + { + procinfo->had_event = procinfo->nopass_next_sigstop = 0; #ifdef PROCFS_USE_READ_WRITE - pctl.data = PRCFAULT | PRCSIG; - if (write (procinfo->ctl_fd, (char *) &pctl, - sizeof (struct proc_ctl)) < 0) - { - if (!procfs_read_status (procinfo)) - { - fprintf_unfiltered(gdb_stderr, "procfs_read_status failed, errno=%d\n", errno); - } - print_sys_errmsg (procinfo->pathname, errno); - error ("PCRUN failed"); - } - procfs_read_status (procinfo); + pctl.data = PRCFAULT | PRCSIG; + if (write (procinfo->ctl_fd, (char *) &pctl, + sizeof (struct proc_ctl)) < 0) + { + if (!procfs_read_status (procinfo)) + fprintf_unfiltered(gdb_stderr, + "procfs_read_status failed, errno=%d\n", + errno); + print_sys_errmsg (procinfo->pathname, errno); + error ("PCRUN failed"); + } + procfs_read_status (procinfo); #else - procinfo->prrun.pr_flags &= PRSTEP; - procinfo->prrun.pr_flags |= PRCFAULT | PRCSIG; - procfs_read_status (procinfo); + procinfo->prrun.pr_flags &= PRSTEP; + procinfo->prrun.pr_flags |= PRCFAULT | PRCSIG; + if (!procfs_read_status (procinfo)) + { + /* The LWP has apparently terminated. */ + if (info_verbose) + printf_filtered ("LWP %d doesn't respond.\n", + (procinfo->pid >> 16) & 0xffff); + close_proc_file (procinfo); + continue; + } - /* Don't try to start a process unless it's stopped on an - `event of interest'. Doing so will cause errors. */ + /* Don't try to start a process unless it's stopped on an + `event of interest'. Doing so will cause errors. */ - if ((procinfo->prstatus.pr_flags & PR_ISTOP) - && ioctl (procinfo->ctl_fd, PIOCRUN, &procinfo->prrun) < 0) - { - if (!procfs_read_status (procinfo)) - { - fprintf_unfiltered(gdb_stderr, "procfs_read_status failed, errno=%d\n", errno); - } - print_sys_errmsg (procinfo->pathname, errno); - error ("PIOCRUN failed"); - } - procfs_read_status (procinfo); + if ((procinfo->prstatus.pr_flags & PR_ISTOP) + && ioctl (procinfo->ctl_fd, PIOCRUN, &procinfo->prrun) < 0) + { + if (!procfs_read_status (procinfo)) + fprintf_unfiltered(gdb_stderr, + "procfs_read_status failed, errno=%d\n", + errno); + print_sys_errmsg (procinfo->pathname, errno); + warning ("PIOCRUN failed"); + } + } + procfs_read_status (procinfo); #endif - } } } @@ -3721,28 +3851,31 @@ procfs_fetch_registers (regno) LOCAL FUNCTION - proc_init_failed - called whenever /proc access initialization + proc_init_failed - called when /proc access initialization fails fails SYNOPSIS - static void proc_init_failed (struct procinfo *pi, char *why) + static void proc_init_failed (struct procinfo *pi, + char *why, int kill_p) DESCRIPTION This function is called whenever initialization of access to a /proc entry fails. It prints a suitable error message, does some cleanup, and then invokes the standard error processing routine which dumps - us back into the command loop. + us back into the command loop. If KILL_P is true, sends SIGKILL. */ static void -proc_init_failed (pi, why) +proc_init_failed (pi, why, kill_p) struct procinfo *pi; char *why; + int kill_p; { print_sys_errmsg (pi->pathname, errno); - kill (pi->pid, SIGKILL); + if (kill_p) + kill (pi->pid, SIGKILL); close_proc_file (pi); error (why); /* NOTREACHED */ @@ -3773,6 +3906,7 @@ close_proc_file (pip) { struct procinfo *procinfo; + delete_thread (pip->pid); /* remove thread from GDB's thread list */ remove_fd (pip); /* Remove fd from poll/select list */ close (pip->ctl_fd); @@ -3890,7 +4024,7 @@ open_proc_file (pid, pip, mode, control) close (pip->as_fd); close (pip->map_fd); return 0; - } + } } #else /* HAVE_MULTIPLE_PROC_FDS */ @@ -4531,7 +4665,7 @@ info_proc (args, from_tty) char *args; int from_tty; { - int pid = inferior_pid; + int pid; struct procinfo *pip; struct cleanup *old_chain; char **argv; @@ -4554,7 +4688,10 @@ info_proc (args, from_tty) /* Default to using the current inferior if no pid specified. Note that inferior_pid may be 0, hence we set okerr. */ - pip = find_procinfo (inferior_pid, 1); + pid = inferior_pid & 0x7fffffff; /* strip off sol-thread bit */ + if (!(pip = find_procinfo (pid, 1))) /* inferior_pid no good? */ + pip = procinfo_list; /* take first available */ + pid = pid & 0xffff; /* extract "real" pid */ if (args != NULL) { @@ -4652,12 +4789,12 @@ No process. Start debugging a program or specify an explicit process ID."); #ifndef PROCFS_USE_READ_WRITE #ifdef PIOCLWPIDS nlwp = pip->prstatus.pr_nlwp; - lwps = alloca ((2 * nlwp + 2) * sizeof (id_t)); + lwps = alloca ((2 * nlwp + 2) * sizeof (*lwps)); if (ioctl (pip->ctl_fd, PIOCLWPIDS, lwps)) { print_sys_errmsg (pip -> pathname, errno); - error ("PIOCLWPIDS failed"); + error ("PIOCLWPIDS failed"); } #else /* PIOCLWPIDS */ nlwp = 1; @@ -4698,6 +4835,10 @@ No process. Start debugging a program or specify an explicit process ID."); if (summary || all) { info_proc_stop (pip, summary); + supply_gregset (&pip->prstatus.pr_reg); + printf_filtered ("PC: "); + print_address (read_pc (), gdb_stdout); + printf_filtered ("\n"); } if (summary || all || signals || faults) { @@ -5005,7 +5146,7 @@ procfs_set_syscall_trap (pi, syscall_num, flags, func) syscall_func_t *func; { sysset_t sysset; - + if (flags & PROCFS_SYSCALL_ENTRY) { if (ioctl (pi->ctl_fd, PIOCGENTRY, &sysset) < 0) @@ -5148,7 +5289,7 @@ procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp) /* We're the proud parent of a new thread. Setup an exit trap for lwp_create in the child and continue the parent. */ - + /* Third arg is pointer to new thread id. */ lwp_id = read_memory_integer (pi->prstatus.pr_sysarg[2], sizeof (int)); @@ -5157,18 +5298,36 @@ procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp) childpi = create_procinfo (lwp_id); /* The new process has actually inherited the lwp_create syscall trap from - it's parent, but we still have to call this to register a handler for + it's parent, but we still have to call this to register handlers for that child. */ - procfs_set_syscall_trap (childpi, SYS_lwp_create, PROCFS_SYSCALL_EXIT, - procfs_lwp_creation_handler); + procfs_set_inferior_syscall_traps (childpi); + add_thread (lwp_id); + printf_filtered ("[New %s]\n", target_pid_to_str (lwp_id)); - childpi->new_child = 1; /* Flag this as an unseen child process */ + /* Continue the parent */ - *rtnvalp = lwp_id; /* the new arrival. */ - *statvalp = (SIGTRAP << 8) | 0177; + pi->prrun.pr_flags &= PRSTEP; + pi->prrun.pr_flags |= PRCFAULT; + if (ioctl (pi->ctl_fd, PIOCRUN, &pi->prrun) != 0) + perror_with_name (pi->pathname); - return 1; + /* The new child may have been created in one of two states: + SUSPENDED or RUNNABLE. If runnable, we will simply signal it to run. + If suspended, we flag it to be continued later, when it has an event. */ + + if (childpi->prstatus.pr_why == PR_SUSPENDED) + childpi->new_child = 1; /* Flag this as an unseen child process */ + else + { + /* Continue the child */ + childpi->prrun.pr_flags &= PRSTEP; + childpi->prrun.pr_flags |= PRCFAULT; + + if (ioctl (childpi->ctl_fd, PIOCRUN, &childpi->prrun) != 0) + perror_with_name (childpi->pathname); + } + return 0; } #endif /* SYS_lwp_create */ @@ -5356,7 +5515,34 @@ static int procfs_thread_alive (pid) int pid; { - return 1; + struct procinfo *pi, *next_pi; + + for (pi = procinfo_list; pi; pi = next_pi) + { + next_pi = pi->next; + if (pi -> pid == pid) + if (procfs_read_status (pi)) /* alive */ + return 1; + else /* defunct (exited) */ + { + close_proc_file (pi); + return 0; + } + } + return 0; +} + +int +procfs_first_available () +{ + struct procinfo *pi; + + for (pi = procinfo_list; pi; pi = pi->next) + { + if (procfs_read_status (pi)) + return pi->pid; + } + return -1; } /* Send a SIGINT to the process group. This acts just like the user typed a @@ -5449,7 +5635,7 @@ _initialize_procfs () add_target (&procfs_ops); - add_info ("proc", info_proc, + add_info ("processes", info_proc, "Show process status information using /proc entry.\n\ Specify process id or use current inferior by default.\n\ Specify keywords for detailed information; default is summary.\n\ diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c index 00bdc60..4b73c19 100644 --- a/gdb/sol-thread.c +++ b/gdb/sol-thread.c @@ -72,6 +72,7 @@ extern struct target_ops sol_thread_ops; /* Forward declaration */ extern int procfs_suppress_run; extern struct target_ops procfs_ops; /* target vector for procfs.c */ +extern char *procfs_pid_to_str PARAMS ((int pid)); /* Note that these prototypes differ slightly from those used in procfs.c for of two reasons. One, we can't use gregset_t, as that's got a whole @@ -110,10 +111,11 @@ static struct cleanup * save_inferior_pid PARAMS ((void)); static void restore_inferior_pid PARAMS ((int pid)); static char *td_err_string PARAMS ((td_err_e errcode)); static char *td_state_string PARAMS ((td_thr_state_e statecode)); -static int thread_to_lwp PARAMS ((int thread_id, int default_lwp)); +static int thread_to_lwp PARAMS ((int thread_id, int default_lwp)); static void sol_thread_resume PARAMS ((int pid, int step, enum target_signal signo)); static int lwp_to_thread PARAMS ((int lwp)); +static int sol_thread_alive PARAMS ((int pid)); #define THREAD_FLAG 0x80000000 #define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0) @@ -306,24 +308,22 @@ thread_to_lwp (thread_id, default_lwp) td_thrinfo_t ti; td_thrhandle_t th; td_err_e val; - int pid; - int lwp; if (is_lwp (thread_id)) return thread_id; /* It's already an LWP id */ /* It's a thread. Convert to lwp */ - pid = PIDGET (thread_id); - thread_id = GET_THREAD(thread_id); - - val = p_td_ta_map_id2thr (main_ta, thread_id, &th); - if (val != TD_OK) + val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th); + if (val == TD_NOTHR) + return -1; /* thread must have terminated */ + else if (val != TD_OK) error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val)); val = p_td_thr_get_info (&th, &ti); - - if (val != TD_OK) + if (val == TD_NOTHR) + return -1; /* thread must have terminated */ + else if (val != TD_OK) error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val)); if (ti.ti_state != TD_THR_ACTIVE) @@ -333,10 +333,8 @@ thread_to_lwp (thread_id, default_lwp) error ("thread_to_lwp: thread state not active: %s", td_state_string (ti.ti_state)); } - - lwp = BUILD_LWP (ti.ti_lid, pid); - return lwp; + return BUILD_LWP (ti.ti_lid, PIDGET (thread_id)); } /* @@ -367,29 +365,34 @@ lwp_to_thread (lwp) td_thrinfo_t ti; td_thrhandle_t th; td_err_e val; - int pid; - int thread_id; if (is_thread (lwp)) return lwp; /* It's already a thread id */ /* It's an lwp. Convert it to a thread id. */ - pid = PIDGET (lwp); - lwp = GET_LWP (lwp); + if (!sol_thread_alive (lwp)) + return -1; /* defunct lwp */ - val = p_td_ta_map_lwp2thr (main_ta, lwp, &th); - if (val != TD_OK) + val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th); + if (val == TD_NOTHR) + return -1; /* thread must have terminated */ + else if (val != TD_OK) error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val)); - val = p_td_thr_get_info (&th, &ti); + val = p_td_thr_validate (&th); + if (val == TD_NOTHR) + return lwp; /* libthread doesn't know about it, just return lwp */ + else if (val != TD_OK) + error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val)); - if (val != TD_OK) + val = p_td_thr_get_info (&th, &ti); + if (val == TD_NOTHR) + return -1; /* thread must have terminated */ + else if (val != TD_OK) error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val)); - thread_id = BUILD_THREAD (ti.ti_tid, pid); - - return thread_id; + return BUILD_THREAD (ti.ti_tid, PIDGET (lwp)); } /* @@ -456,7 +459,19 @@ sol_thread_attach (args, from_tty) int from_tty; { procfs_ops.to_attach (args, from_tty); - + /* Must get symbols from solibs before libthread_db can run! */ + SOLIB_ADD ((char *)0, from_tty, (struct target_ops *)0); + if (sol_thread_active) + { + printf_filtered ("sol-thread active.\n"); + main_ph.pid = inferior_pid; /* Save for xfer_memory */ + push_target (&sol_thread_ops); + inferior_pid = lwp_to_thread (inferior_pid); + if (inferior_pid == -1) + inferior_pid = main_ph.pid; + else + add_thread (inferior_pid); + } /* XXX - might want to iterate over all the threads and register them. */ } @@ -473,6 +488,7 @@ sol_thread_detach (args, from_tty) char *args; int from_tty; { + unpush_target (&sol_thread_ops); procfs_ops.to_detach (args, from_tty); } @@ -492,12 +508,19 @@ sol_thread_resume (pid, step, signo) old_chain = save_inferior_pid (); inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid); + if (inferior_pid == -1) + inferior_pid = procfs_first_available (); if (pid != -1) { + int save_pid = pid; + pid = thread_to_lwp (pid, -2); if (pid == -2) /* Inactive thread */ error ("This version of Solaris can't start inactive threads."); + if (info_verbose && pid == -1) + warning ("Specified thread %d seems to have terminated", + GET_THREAD (save_pid)); } procfs_ops.to_resume (pid, step, signo); @@ -521,28 +544,44 @@ sol_thread_wait (pid, ourstatus) old_chain = save_inferior_pid (); inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid); + if (inferior_pid == -1) + inferior_pid = procfs_first_available (); if (pid != -1) - pid = thread_to_lwp (pid, -1); + { + int save_pid = pid; + + pid = thread_to_lwp (pid, -2); + if (pid == -2) /* Inactive thread */ + error ("This version of Solaris can't start inactive threads."); + if (info_verbose && pid == -1) + warning ("Specified thread %d seems to have terminated", + GET_THREAD (save_pid)); + } rtnval = procfs_ops.to_wait (pid, ourstatus); - if (rtnval != save_pid - && !in_thread_list (rtnval)) + if (ourstatus->kind != TARGET_WAITKIND_EXITED) { - fprintf_unfiltered (gdb_stderr, "[New %s]\n", - target_pid_to_str (rtnval)); - add_thread (rtnval); + /* Map the LWP of interest back to the appropriate thread ID */ + rtnval = lwp_to_thread (rtnval); + if (rtnval == -1) + rtnval = save_pid; + + /* See if we have a new thread */ + if (is_thread (rtnval) + && rtnval != save_pid + && !in_thread_list (rtnval)) + { + printf_filtered ("[New %s]\n", target_pid_to_str (rtnval)); + add_thread (rtnval); + } } /* During process initialization, we may get here without the thread package being initialized, since that can only happen after we've found the shared libs. */ - /* Map the LWP of interest back to the appropriate thread ID */ - - rtnval = lwp_to_thread (rtnval); - do_cleanups (old_chain); return rtnval; @@ -751,8 +790,6 @@ sol_thread_notice_signals (pid) procfs_ops.to_notice_signals (pid); } -void target_new_objfile PARAMS ((struct objfile *objfile)); - /* Fork an inferior process, and start debugging it with /proc. */ static void @@ -763,13 +800,15 @@ sol_thread_create_inferior (exec_file, allargs, env) { procfs_ops.to_create_inferior (exec_file, allargs, env); - if (sol_thread_active) + if (sol_thread_active && inferior_pid != 0) { main_ph.pid = inferior_pid; /* Save for xfer_memory */ push_target (&sol_thread_ops); inferior_pid = lwp_to_thread (inferior_pid); + if (inferior_pid == -1) + inferior_pid = main_ph.pid; add_thread (inferior_pid); } @@ -794,6 +833,10 @@ sol_thread_new_objfile (objfile) return; } + /* don't do anything if init failed to resolve the libthread_db library */ + if (!procfs_suppress_run) + return; + /* Now, initialize the thread debugging library. This needs to be done after the shared libraries are located because it needs information from the user's thread library. */ @@ -816,6 +859,7 @@ sol_thread_new_objfile (objfile) static void sol_thread_mourn_inferior () { + unpush_target (&sol_thread_ops); procfs_ops.to_mourn_inferior (); } @@ -827,11 +871,40 @@ sol_thread_can_run () return procfs_suppress_run; } +/* + +LOCAL FUNCTION + + sol_thread_alive - test thread for "aliveness" + +SYNOPSIS + + static bool sol_thread_alive (int pid); + +DESCRIPTION + + returns true if thread still active in inferior. + + */ + static int sol_thread_alive (pid) int pid; { - return 1; + if (is_thread (pid)) /* non-kernel thread */ + { + td_err_e val; + td_thrhandle_t th; + + pid = GET_THREAD (pid); + if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK) + return 0; /* thread not found */ + if ((val = p_td_thr_validate (&th)) != TD_OK) + return 0; /* thread not valid */ + return 1; /* known thread: return true */ + } + else /* kernel thread (LWP): let procfs test it */ + return procfs_ops.to_thread_alive (pid); } static void @@ -910,9 +983,9 @@ rw_common (int dowrite, const struct ps_prochandle *ph, paddr_t addr, if (cc < 0) { if (dowrite == 0) - print_sys_errmsg ("ps_pdread (): read", errno); + print_sys_errmsg ("rw_common (): read", errno); else - print_sys_errmsg ("ps_pdread (): write", errno); + print_sys_errmsg ("rw_common (): write", errno); do_cleanups (old_chain); @@ -1123,19 +1196,27 @@ solaris_pid_to_str (pid) { static char buf[100]; + /* in case init failed to resolve the libthread_db library */ + if (!procfs_suppress_run) + return procfs_pid_to_str (pid); + if (is_thread (pid)) { int lwp; lwp = thread_to_lwp (pid, -2); - if (lwp != -2) + if (lwp == -1) + sprintf (buf, "Thread %d (defunct)", GET_THREAD (pid)); + else if (lwp != -2) sprintf (buf, "Thread %d (LWP %d)", GET_THREAD (pid), GET_LWP (lwp)); else sprintf (buf, "Thread %d ", GET_THREAD (pid)); } - else + else if (GET_LWP (pid) != 0) sprintf (buf, "LWP %d ", GET_LWP (pid)); + else + sprintf (buf, "process %d ", PIDGET (pid)); return buf; } diff --git a/gdb/thread.c b/gdb/thread.c index 7ffc65a..b8bf9e1 100644 --- a/gdb/thread.c +++ b/gdb/thread.c @@ -125,6 +125,31 @@ add_thread (pid) thread_list = tp; } +void +delete_thread (pid) + int pid; +{ + struct thread_info *tp, *tpprev; + + tpprev = NULL; + + for (tp = thread_list; tp; tpprev = tp, tp = tp->next) + if (tp->pid == pid) + break; + + if (!tp) + return; + + if (tpprev) + tpprev->next = tp->next; + else + thread_list = tp->next; + + free (tp); + + return; +} + static struct thread_info * find_thread_id (num) int num; @@ -332,7 +357,10 @@ info_threads_command (arg, from_tty) printf_filtered ("%d %s ", tp->num, target_pid_to_str (tp->pid)); switch_to_thread (tp->pid); - print_stack_frame (selected_frame, -1, 0); + if (selected_frame) + print_stack_frame (selected_frame, -1, 0); + else + printf_filtered ("[No stack.]\n"); } switch_to_thread (current_pid); |