extern struct target_ops procfs_ops; /* Forward declaration */
+int procfs_suppress_run = 0; /* Non-zero if procfs should pretend not to
+ be a runnable target. Used by targets
+ that can sit atop procfs, such as solaris
+ thread support. */
+
#if 1 /* FIXME: Gross and ugly hack to resolve coredep.c global */
CORE_ADDR kernel_u_addr;
#endif
sigset_t saved_sighold; /* Saved held signal set */
sysset_t saved_exitset; /* Saved traced system call exit set */
sysset_t 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 new_child; /* Non-zero if it's a new thread */
};
/* List of inferior process information */
static struct procinfo *find_procinfo PARAMS ((pid_t pid, int okfail));
+typedef int syscall_func_t PARAMS ((struct procinfo *pi, int syscall_num,
+ int why, int *rtnval, int *statval));
+
+static void procfs_set_syscall_trap PARAMS ((struct procinfo *pi,
+ int syscall_num, int flags,
+ syscall_func_t *func));
+
+static void procfs_clear_syscall_trap PARAMS ((struct procinfo *pi,
+ int syscall_num, int errok));
+
+#define PROCFS_SYSCALL_ENTRY 0x1 /* Trap on entry to sys call */
+#define PROCFS_SYSCALL_EXIT 0x2 /* Trap on exit from sys call */
+
+static syscall_func_t procfs_exit_handler;
+
+static syscall_func_t procfs_exec_handler;
+
+#ifdef SYS_sproc
+static syscall_func_t procfs_sproc_handler;
+static syscall_func_t procfs_fork_handler;
+#endif
+
+#ifdef SYS_lwp_create
+static syscall_func_t procfs_lwp_creation_handler;
+#endif
+
+static void modify_inherit_on_fork_flag PARAMS ((int fd, int flag));
+static void modify_run_on_last_close_flag PARAMS ((int fd, int flag));
+
+/* */
+
+struct procfs_syscall_handler
+{
+ int syscall_num; /* The number of the system call being handled */
+ /* The function to be called */
+ syscall_func_t *func;
+};
+
+static void procfs_resume PARAMS ((int pid, int step,
+ enum target_signal signo));
+
/* External function prototypes that can't be easily included in any
header file because the args are typedefs in system include files. */
if (poll_list[i].fd == pi->fd)
{
if (i != num_poll_list - 1)
- memcpy (poll_list, poll_list + i + 1,
+ memcpy (poll_list + i, poll_list + i + 1,
(num_poll_list - i - 1) * sizeof (struct pollfd));
num_poll_list--;
}
}
-#define LOSING_POLL unixware_sux
-
static struct procinfo *
wait_fd ()
{
}
}
if (!pi)
- error ("procfs_wait: Couldn't find procinfo for fd %d\n",
+ error ("wait_fd: Couldn't find procinfo for fd %d\n",
poll_list[i].fd);
}
#endif /* LOSING_POLL */
int syscallnum;
{
static char locbuf[32];
- char *rtnval;
- if (syscallnum >= 0 && syscallnum < MAX_SYSCALLS)
- {
- rtnval = syscall_table[syscallnum];
- }
+ if (syscallnum >= 0 && syscallnum < MAX_SYSCALLS
+ && syscall_table[syscallnum] != NULL)
+ return syscall_table[syscallnum];
else
{
sprintf (locbuf, "syscall %u", syscallnum);
- rtnval = locbuf;
+ return locbuf;
}
- return (rtnval);
}
/*
if (!open_proc_file (pid, pi, O_RDWR))
proc_init_failed (pi, "can't open process file");
+ /* open_proc_file may modify pid. */
+
+ pid = pi -> pid;
+
/* Add new process to process info list */
pi->next = procinfo_list;
add_fd (pi); /* Add to list for poll/select */
+ pi->num_syscall_handlers = 0;
+ pi->syscall_handlers = NULL;
memset ((char *) &pi->prrun, 0, sizeof (pi->prrun));
prfillset (&pi->prrun.pr_trace);
procfs_notice_signals (pid);
premptyset (&pi->prrun.pr_fault);
#endif
- if (ioctl (pi->fd, PIOCWSTOP, &pi->prstatus) < 0)
- proc_init_failed (pi, "PIOCWSTOP failed");
+ if (ioctl (pi->fd, PIOCSTATUS, &pi->prstatus) < 0)
+ proc_init_failed (pi, "PIOCSTATUS failed");
+
+/* 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))
+ if (ioctl (pi->fd, PIOCWSTOP, &pi->prstatus) < 0)
+ proc_init_failed (pi, "PIOCWSTOP failed");
if (ioctl (pi->fd, PIOCSFAULT, &pi->prrun.pr_fault) < 0)
proc_init_failed (pi, "PIOCSFAULT failed");
/*
+LOCAL FUNCTION
+
+ procfs_exit_handler - handle entry into the _exit syscall
+
+SYNOPSIS
+
+ int procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
+
+DESCRIPTION
+
+ This routine is called when an inferior process enters the _exit()
+ system call. It continues the process, and then collects the exit
+ status and pid which are returned in *statvalp and *rtnvalp. After
+ that it returns non-zero to indicate that procfs_wait should wake up.
+
+NOTES
+ There is probably a better way to do this.
+
+ */
+
+static int
+procfs_exit_handler (pi, syscall_num, why, rtnvalp, statvalp)
+ struct procinfo *pi;
+ int syscall_num;
+ int why;
+ int *rtnvalp;
+ int *statvalp;
+{
+ pi->prrun.pr_flags = PRCFAULT;
+
+ if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
+ perror_with_name (pi->pathname);
+
+ *rtnvalp = wait (statvalp);
+ if (*rtnvalp >= 0)
+ *rtnvalp = pi->pid;
+
+ return 1;
+}
+
+/*
+
+LOCAL FUNCTION
+
+ procfs_exec_handler - handle exit from the exec family of syscalls
+
+SYNOPSIS
+
+ int procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
+
+DESCRIPTION
+
+ This routine is called when an inferior process is about to finish any
+ of the exec() family of system calls. It pretends that we got a
+ SIGTRAP (for compatibility with ptrace behavior), and returns non-zero
+ to tell procfs_wait to wake up.
+
+NOTES
+ This need for compatibility with ptrace is questionable. In the
+ future, it shouldn't be necessary.
+
+ */
+
+static int
+procfs_exec_handler (pi, syscall_num, why, rtnvalp, statvalp)
+ struct procinfo *pi;
+ int syscall_num;
+ int why;
+ int *rtnvalp;
+ int *statvalp;
+{
+ *statvalp = (SIGTRAP << 8) | 0177;
+
+ return 1;
+}
+
+#ifdef SYS_sproc /* IRIX lwp creation system call */
+
+/*
+
+LOCAL FUNCTION
+
+ procfs_sproc_handler - handle exit from the sproc syscall
+
+SYNOPSIS
+
+ int procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
+
+DESCRIPTION
+
+ This routine is called when an inferior process is about to finish an
+ sproc() system call. This is the system call that IRIX uses to create
+ a lightweight process. When the target process gets this event, we can
+ look at rval1 to find the new child processes ID, and create a new
+ procinfo struct from that.
+
+ After that, it pretends that we got a SIGTRAP, and returns non-zero
+ to tell procfs_wait to wake up. Subsequently, wait_for_inferior gets
+ woken up, sees the new process and continues it.
+
+NOTES
+ We actually never see the child exiting from sproc because we will
+ shortly stop the child with PIOCSTOP, which is then registered as the
+ event of interest.
+ */
+
+static int
+procfs_sproc_handler (pi, syscall_num, why, rtnvalp, statvalp)
+ struct procinfo *pi;
+ int syscall_num;
+ int why;
+ int *rtnvalp;
+ int *statvalp;
+{
+/* We've just detected the completion of an sproc system call. Now we need to
+ setup a procinfo struct for this thread, and notify the thread system of the
+ new arrival. */
+
+/* If sproc failed, then nothing interesting happened. Continue the process
+ and go back to sleep. */
+
+ if (pi->prstatus.pr_errno != 0)
+ {
+ pi->prrun.pr_flags &= PRSTEP;
+ pi->prrun.pr_flags |= PRCFAULT;
+
+ if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
+ perror_with_name (pi->pathname);
+
+ return 0;
+ }
+
+ /* At this point, the new thread is stopped at it's first instruction, and
+ the parent is stopped at the exit from sproc. */
+
+ /* Notify the caller of the arrival of a new thread. */
+ create_procinfo (pi->prstatus.pr_rval1);
+
+ *rtnvalp = pi->prstatus.pr_rval1;
+ *statvalp = (SIGTRAP << 8) | 0177;
+
+ return 1;
+}
+
+/*
+
+LOCAL FUNCTION
+
+ procfs_fork_handler - handle exit from the fork syscall
+
+SYNOPSIS
+
+ int procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
+
+DESCRIPTION
+
+ This routine is called when an inferior process is about to finish a
+ fork() system call. We will open up the new process, and then close
+ it, which releases it from the clutches of the debugger.
+
+ After that, we continue the target process as though nothing had
+ happened.
+
+NOTES
+ This is necessary for IRIX because we have to set PR_FORK in order
+ to catch the creation of lwps (via sproc()). When an actual fork
+ occurs, it becomes necessary to reset the forks debugger flags and
+ continue it because we can't hack multiple processes yet.
+ */
+
+static int
+procfs_fork_handler (pi, syscall_num, why, rtnvalp, statvalp)
+ struct procinfo *pi;
+ int syscall_num;
+ int why;
+ int *rtnvalp;
+ int *statvalp;
+{
+ struct procinfo *pitemp;
+
+/* At this point, we've detected the completion of a fork (or vfork) call in
+ our child. The grandchild is also stopped because we set inherit-on-fork
+ earlier. (Note that nobody has the grandchilds' /proc file open at this
+ point.) We will release the grandchild from the debugger by opening it's
+ /proc file and then closing it. Since run-on-last-close is set, the
+ grandchild continues on its' merry way. */
+
+
+ pitemp = create_procinfo (pi->prstatus.pr_rval1);
+ if (pitemp)
+ close_proc_file (pitemp);
+
+ if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
+ perror_with_name (pi->pathname);
+
+ return 0;
+}
+#endif /* SYS_sproc */
+
+/*
+
LOCAL FUNCTION
procfs_init_inferior - initialize target vector and access to a
SYNOPSIS
- void procfs_init_inferior (int pid)
+ int procfs_init_inferior (int pid)
DESCRIPTION
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.
+ and faults that are to be traced. Returns the pid, which may have had
+ the thread-id added to it.
NOTES
*/
-static void
+static int
procfs_init_inferior (pid)
int pid;
{
+ struct procinfo *pip;
+
push_target (&procfs_ops);
- create_procinfo (pid);
- add_thread (pid); /* Setup initial thread */
+ pip = create_procinfo (pid);
+
+ procfs_set_syscall_trap (pip, SYS_exit, PROCFS_SYSCALL_ENTRY,
+ procfs_exit_handler);
+
+#ifndef PRFS_STOPEXEC
+#ifdef SYS_exec
+ procfs_set_syscall_trap (pip, SYS_exec, PROCFS_SYSCALL_EXIT,
+ procfs_exec_handler);
+#endif
+#ifdef SYS_execv
+ procfs_set_syscall_trap (pip, SYS_execv, PROCFS_SYSCALL_EXIT,
+ procfs_exec_handler);
+#endif
+#ifdef SYS_execve
+ procfs_set_syscall_trap (pip, SYS_execve, PROCFS_SYSCALL_EXIT,
+ procfs_exec_handler);
+#endif
+#endif /* PRFS_STOPEXEC */
+
+ /* Setup traps on exit from sproc() */
+
+#ifdef SYS_sproc
+ procfs_set_syscall_trap (pip, SYS_sproc, PROCFS_SYSCALL_EXIT,
+ procfs_sproc_handler);
+ procfs_set_syscall_trap (pip, SYS_fork, PROCFS_SYSCALL_EXIT,
+ procfs_fork_handler);
+#ifdef SYS_vfork
+ procfs_set_syscall_trap (pip, SYS_vfork, PROCFS_SYSCALL_EXIT,
+ procfs_fork_handler);
+#endif
+/* Turn on inherit-on-fork flag so that all children of the target process
+ start with tracing flags set. This allows us to trap lwp creation. Note
+ that we also have to trap on fork and vfork in order to disable all tracing
+ in the targets child processes. */
+
+ modify_inherit_on_fork_flag (pip->fd, 1);
+#endif
+
+#ifdef SYS_lwp_create
+ procfs_set_syscall_trap (pip, SYS_lwp_create, PROCFS_SYSCALL_EXIT,
+ procfs_lwp_creation_handler);
+#endif
+
+ /* create_procinfo may change the pid, so we have to update inferior_pid
+ here before calling other gdb routines that need the right pid. */
+
+ pid = pip -> pid;
+ inferior_pid = pid;
+
+ add_thread (pip -> pid); /* Setup initial thread */
#ifdef START_INFERIOR_TRAPS_EXPECTED
startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
/* One trap to exec the shell, one to exec the program being debugged. */
startup_inferior (2);
#endif
+
+ return pid;
}
/*
/* Turn off inherit-on-fork flag so that all grand-children of gdb
start with tracing flags cleared. */
-#if defined (PIOCRESET) /* New method */
- {
- long pr_flags;
- pr_flags = PR_FORK;
- ioctl (fd, PIOCRESET, &pr_flags);
- }
-#else
-#if defined (PIOCRFORK) /* Original method */
- ioctl (fd, PIOCRFORK, NULL);
-#endif
-#endif
+ modify_inherit_on_fork_flag (fd, 0);
/* Turn on run-on-last-close flag so that this process will not hang
if GDB goes away for some reason. */
-#if defined (PIOCSET) /* New method */
+ modify_run_on_last_close_flag (fd, 1);
+
+#ifdef PR_ASYNC
{
- long pr_flags;
- pr_flags = PR_RLC;
- (void) ioctl (fd, PIOCSET, &pr_flags);
+ long pr_flags;
+
+/* Solaris needs this to make procfs treat all threads seperately. Without
+ this, all threads halt whenever something happens to any thread. Since
+ GDB wants to control all this itself, it needs to set PR_ASYNC. */
+
+ pr_flags = PR_ASYNC;
+
+ ioctl (fd, PIOCSET, &pr_flags);
}
-#else
-#if defined (PIOCSRLC) /* Original method */
- (void) ioctl (fd, PIOCSRLC, 0);
-#endif
-#endif
+#endif /* PR_ASYNC */
}
/*
gdb_flush (gdb_stdout);
}
- do_attach (pid);
- inferior_pid = pid;
+ inferior_pid = pid = do_attach (pid);
push_target (&procfs_ops);
}
/* NOTREACHED */
}
+ pid = pi -> pid;
+
/* Add new process to process info list */
pi->next = procinfo_list;
if (1 || query ("Process is currently running, stop it? "))
{
/* Make it run again when we close it. */
-#if defined (PIOCSET) /* New method */
- {
- long pr_flags;
- pr_flags = PR_RLC;
- result = ioctl (pi->fd, PIOCSET, &pr_flags);
- }
-#else
-#if defined (PIOCSRLC) /* Original method */
- result = ioctl (pi->fd, PIOCSRLC, 0);
-#endif
-#endif
- if (result < 0)
- {
- print_sys_errmsg (pi->pathname, errno);
- close_proc_file (pi);
- error ("PIOCSRLC or PIOCSET failed");
- }
+
+ modify_run_on_last_close_flag (pi->fd, 1);
+
if (ioctl (pi->fd, PIOCSTOP, &pi->prstatus) < 0)
{
print_sys_errmsg (pi->pathname, errno);
}
/* Make it run again when we close it. */
-#if defined (PIOCSET) /* New method */
- {
- long pr_flags;
- pr_flags = PR_RLC;
- result = ioctl (pi->fd, PIOCSET, &pr_flags);
- }
-#else
-#if defined (PIOCSRLC) /* Original method */
- result = ioctl (pi->fd, PIOCSRLC, 0);
-#endif
-#endif
- if (result)
- {
- print_sys_errmsg (pi->pathname, errno);
- printf_unfiltered ("PIOCSRLC or PIOCSET failed.\n");
- }
+
+ modify_run_on_last_close_flag (pi->fd, 1);
}
}
}
{
wait_again:
+ if (pi)
+ pi->had_event = 0;
+
pi = wait_fd ();
}
}
else if (pi->prstatus.pr_flags & (PR_STOPPED | PR_ISTOP))
{
- rtnval = pi->prstatus.pr_pid;
+ rtnval = pi->pid;
why = pi->prstatus.pr_why;
what = pi->prstatus.pr_what;
statval = (what << 8) | 0177;
break;
case PR_SYSENTRY:
- if (what != SYS_exit)
- error ("PR_SYSENTRY, unknown system call %d", what);
-
- pi->prrun.pr_flags = PRCFAULT;
-
- if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
- perror_with_name (pi->pathname);
-
- rtnval = wait (&statval);
-
- break;
case PR_SYSEXIT:
- switch (what)
- {
-#ifdef SYS_exec
- case SYS_exec:
-#endif
-#ifdef SYS_execve
- case SYS_execve:
-#endif
-#ifdef SYS_execv
- case SYS_execv:
-#endif
- statval = (SIGTRAP << 8) | 0177;
- break;
-#ifdef SYS_sproc
- case SYS_sproc:
-/* We've just detected the completion of an sproc system call. Now we need to
- setup a procinfo struct for this thread, and notify the thread system of the
- new arrival. */
-
-/* If sproc failed, then nothing interesting happened. Continue the process and
- go back to sleep. */
+ {
+ int i;
+ int found_handler = 0;
- if (pi->prstatus.pr_errno != 0)
+ for (i = 0; i < pi->num_syscall_handlers; i++)
+ if (pi->syscall_handlers[i].syscall_num == what)
{
- pi->prrun.pr_flags &= PRSTEP;
- pi->prrun.pr_flags |= PRCFAULT;
-
- if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
- perror_with_name (pi->pathname);
+ found_handler = 1;
+ if (!pi->syscall_handlers[i].func (pi, what, why,
+ &rtnval, &statval))
+ goto wait_again;
- goto wait_again;
+ break;
}
-/* At this point, the new thread is stopped at it's first instruction, and
- the parent is stopped at the exit from sproc. */
-
-/* Notify the caller of the arrival of a new thread. */
- create_procinfo (pi->prstatus.pr_rval1);
-
- rtnval = pi->prstatus.pr_rval1;
- statval = (SIGTRAP << 8) | 0177;
-
- break;
- case SYS_fork:
-#ifdef SYS_vfork
- case SYS_vfork:
-#endif
-/* At this point, we've detected the completion of a fork (or vfork) call in
- our child. The grandchild is also stopped because we set inherit-on-fork
- earlier. (Note that nobody has the grandchilds' /proc file open at this
- point.) We will release the grandchild from the debugger by opening it's
- /proc file and then closing it. Since run-on-last-close is set, the
- grandchild continues on its' merry way. */
-
- {
- struct procinfo *pitemp;
-
- pitemp = create_procinfo (pi->prstatus.pr_rval1);
- if (pitemp)
- close_proc_file (pitemp);
-
- if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
- perror_with_name (pi->pathname);
- }
- goto wait_again;
-#endif /* SYS_sproc */
-
- default:
- error ("PIOCSTATUS (PR_SYSEXIT): Unknown system call %d", what);
- }
+ if (!found_handler)
+ if (why == PR_SYSENTRY)
+ error ("PR_SYSENTRY, unhandled system call %d", what);
+ else
+ error ("PR_SYSEXIT, unhandled system call %d", what);
+ }
break;
case PR_REQUESTED:
statval = (SIGSTOP << 8) | 0177;
for (procinfo = procinfo_list; procinfo; procinfo = procinfo->next)
{
if (!procinfo->had_event)
- if (ioctl (procinfo->fd, PIOCSTOP, &procinfo->prstatus) < 0)
- {
- print_sys_errmsg (procinfo->pathname, errno);
- error ("PIOCSTOP failed");
- }
+ {
+ /* A bug in Solaris (2.5) causes us to hang when trying to
+ stop a stopped process. So, we have to check first in
+ order to avoid the hang. */
+ if (ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus) < 0)
+ {
+ print_sys_errmsg (procinfo->pathname, errno);
+ error ("PIOCSTATUS failed");
+ }
+ if (!(procinfo->prstatus.pr_flags & PR_STOPPED))
+ if (ioctl (procinfo->fd, PIOCSTOP, &procinfo->prstatus) < 0)
+ {
+ print_sys_errmsg (procinfo->pathname, errno);
+ error ("PIOCSTOP failed");
+ }
+ }
}
}
}
{
pi->prrun.pr_flags |= PRSTEP;
}
- if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
+
+ /* Don't try to start a process unless it's stopped on an
+ `event of interest'. Doing so will cause errors. */
+
+ if ((pi->prstatus.pr_flags & PR_ISTOP)
+ && ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
{
perror_with_name (pi->pathname);
/* NOTREACHED */
procinfo->prrun.pr_flags &= PRSTEP;
procinfo->prrun.pr_flags |= PRCFAULT | PRCSIG;
ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus);
- if (ioctl (procinfo->fd, PIOCRUN, &procinfo->prrun) < 0)
+
+ /* 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->fd, PIOCRUN, &procinfo->prrun) < 0)
{
if (ioctl (procinfo->fd, PIOCSTATUS, &procinfo->prstatus) < 0)
{
Note that the pathname is left intact, even when the open fails,
so that callers can use it to construct meaningful error messages
rather than just "file open failed".
+
+ Note that for Solaris, the process-id also includes an LWP-id, so we
+ actually attempt to open that. If we are handed a pid with a 0 LWP-id,
+ then we will ask the kernel what it is and add it to the pid. Hence,
+ the pid can be changed by us.
*/
static int
struct procinfo *pip;
int mode;
{
+ int tmp, tmpfd;
+
pip -> next = NULL;
pip -> had_event = 0;
pip -> pathname = xmalloc (32);
pip -> pid = pid;
- sprintf (pip -> pathname, PROC_NAME_FMT, pid);
- if ((pip -> fd = open (pip -> pathname, mode)) < 0)
+#ifndef PIOCOPENLWP
+ tmp = pid;
+#else
+ tmp = pid & 0xffff;
+#endif
+
+ sprintf (pip -> pathname, PROC_NAME_FMT, tmp);
+ if ((tmpfd = open (pip -> pathname, mode)) < 0)
return 0;
+#ifndef PIOCOPENLWP
+ pip -> fd = tmpfd;
+#else
+ tmp = (pid >> 16) & 0xffff; /* Extract thread id */
+
+ if (tmp == 0)
+ { /* Don't know thread id yet */
+ if (ioctl (tmpfd, PIOCSTATUS, &pip -> prstatus) < 0)
+ {
+ print_sys_errmsg (pip -> pathname, errno);
+ close (tmpfd);
+ error ("open_proc_file: PIOCSTATUS failed");
+ }
+
+ tmp = pip -> prstatus.pr_who; /* Get thread id from prstatus_t */
+ pip -> pid = (tmp << 16) | pid; /* Update pip */
+ }
+
+ if ((pip -> fd = ioctl (tmpfd, PIOCOPENLWP, &tmp)) < 0)
+ {
+ close (tmpfd);
+ return 0;
+ }
+
+#ifdef PIOCSET /* New method */
+ {
+ long pr_flags;
+ pr_flags = PR_ASYNC;
+ ioctl (pip -> fd, PIOCSET, &pr_flags);
+ }
+#endif
+
+ close (tmpfd); /* All done with main pid */
+#endif /* PIOCOPENLWP */
+
return 1;
}
{
QUIT;
if (syscall_table[syscallnum] != NULL)
- {
- printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
- printf_filtered ("%-8s ",
- prismember (&pip -> entryset, syscallnum)
- ? "on" : "off");
- printf_filtered ("%-8s ",
- prismember (&pip -> exitset, syscallnum)
- ? "on" : "off");
- printf_filtered ("\n");
- }
- }
+ printf_filtered ("\t%-12s ", syscall_table[syscallnum]);
+ else
+ printf_filtered ("\t%-12d ", syscallnum);
+
+ printf_filtered ("%-8s ",
+ prismember (&pip -> entryset, syscallnum)
+ ? "on" : "off");
+ printf_filtered ("%-8s ",
+ prismember (&pip -> exitset, syscallnum)
+ ? "on" : "off");
+ printf_filtered ("\n");
+ }
printf_filtered ("\n");
}
}
char *args;
int from_tty;
{
- int pid;
+ int pid = inferior_pid;
struct procinfo *pip;
struct cleanup *old_chain;
char **argv;
int id = 0;
int status = 0;
int all = 0;
+ int nlwp;
+ id_t *lwps;
old_chain = make_cleanup (null_cleanup, 0);
perror_with_name (pip -> pathname);
/* NOTREACHED */
}
+ pid = pip->pid;
make_cleanup (close_proc_file, pip);
}
else if (**argv != '\000')
error ("PIOCSTATUS failed");
}
- /* Print verbose information of the requested type(s), or just a summary
- of the information for all types. */
+#ifdef PIOCLWPIDS
+ nlwp = pip->prstatus.pr_nlwp;
+ lwps = alloca ((2 * nlwp + 2) * sizeof (id_t));
- printf_filtered ("\nInformation for %s:\n\n", pip -> pathname);
- if (summary || all || flags)
+ if (ioctl (pip->fd, PIOCLWPIDS, lwps))
{
- info_proc_flags (pip, summary);
+ print_sys_errmsg (pip -> pathname, errno);
+ error ("PIOCSTATUS failed");
}
- if (summary || all)
+#else /* PIOCLWPIDS */
+ nlwp = 1;
+ lwps = alloca ((2 * nlwp + 2) * sizeof (id_t));
+ lwps[0] = 0;
+#endif /* PIOCLWPIDS */
+
+ for (; nlwp > 0; nlwp--, lwps++)
{
- info_proc_stop (pip, summary);
+ pip = find_procinfo ((*lwps << 16) | pid, 1);
+
+ if (!pip)
+ {
+ pip = (struct procinfo *) xmalloc (sizeof (struct procinfo));
+ memset (pip, 0, sizeof (*pip));
+ if (!open_proc_file ((*lwps << 16) | pid, pip, O_RDONLY))
+ continue;
+
+ make_cleanup (close_proc_file, pip);
+
+ if (ioctl (pip -> fd, PIOCSTATUS, &(pip -> prstatus)) < 0)
+ {
+ print_sys_errmsg (pip -> pathname, errno);
+ error ("PIOCSTATUS failed");
+ }
+ }
+
+ /* Print verbose information of the requested type(s), or just a summary
+ of the information for all types. */
+
+ printf_filtered ("\nInformation for %s.%d:\n\n", pip -> pathname, *lwps);
+ if (summary || all || flags)
+ {
+ info_proc_flags (pip, summary);
+ }
+ if (summary || all)
+ {
+ info_proc_stop (pip, summary);
+ }
+ if (summary || all || signals || faults)
+ {
+ info_proc_siginfo (pip, summary);
+ }
+ if (summary || all || syscalls)
+ {
+ info_proc_syscalls (pip, summary);
+ }
+ if (summary || all || mappings)
+ {
+ info_proc_mappings (pip, summary);
+ }
+ if (summary || all || signals)
+ {
+ info_proc_signals (pip, summary);
+ }
+ if (summary || all || faults)
+ {
+ info_proc_faults (pip, summary);
+ }
+ printf_filtered ("\n");
+
+ /* All done, deal with closing any temporary process info structure,
+ freeing temporary memory , etc. */
+
+ do_cleanups (old_chain);
}
- if (summary || all || signals || faults)
+}
+
+/*
+
+LOCAL FUNCTION
+
+ modify_inherit_on_fork_flag - Change the inherit-on-fork flag
+
+SYNOPSIS
+
+ void modify_inherit_on_fork_flag (fd, flag)
+
+DESCRIPTION
+
+ Call this routine to modify the inherit-on-fork flag. This routine is
+ just a nice wrapper to hide the #ifdefs needed by various systems to
+ control this flag.
+
+ */
+
+static void
+modify_inherit_on_fork_flag (fd, flag)
+ int fd;
+ int flag;
+{
+ long pr_flags;
+ int retval;
+
+#ifdef PIOCSET /* New method */
+ pr_flags = PR_FORK;
+ if (flag)
+ retval = ioctl (fd, PIOCSET, &pr_flags);
+ else
+ retval = ioctl (fd, PIOCRESET, &pr_flags);
+
+#else
+#ifdef PIOCSFORK /* Original method */
+ if (flag)
+ retval = ioctl (fd, PIOCSFORK, NULL);
+ else
+ retval = ioctl (fd, PIOCRFORK, NULL);
+#else
+ Neither PR_FORK nor PIOCSFORK exist!!!
+#endif
+#endif
+
+ if (!retval)
+ return;
+
+ print_sys_errmsg ("modify_inherit_on_fork_flag", errno);
+ error ("PIOCSFORK or PR_FORK modification failed");
+}
+
+/*
+
+LOCAL FUNCTION
+
+ modify_run_on_last_close_flag - Change the run-on-last-close flag
+
+SYNOPSIS
+
+ void modify_run_on_last_close_flag (fd, flag)
+
+DESCRIPTION
+
+ Call this routine to modify the run-on-last-close flag. This routine
+ is just a nice wrapper to hide the #ifdefs needed by various systems to
+ control this flag.
+
+ */
+
+static void
+modify_run_on_last_close_flag (fd, flag)
+ int fd;
+ int flag;
+{
+ long pr_flags;
+ int retval;
+
+#ifdef PIOCSET /* New method */
+ pr_flags = PR_RLC;
+ if (flag)
+ retval = ioctl (fd, PIOCSET, &pr_flags);
+ else
+ retval = ioctl (fd, PIOCRESET, &pr_flags);
+
+#else
+#ifdef PIOCSRLC /* Original method */
+ if (flag)
+ retval = ioctl (fd, PIOCSRLC, NULL);
+ else
+ retval = ioctl (fd, PIOCRRLC, NULL);
+#else
+ Neither PR_RLC nor PIOCSRLC exist!!!
+#endif
+#endif
+
+ if (!retval)
+ return;
+
+ print_sys_errmsg ("modify_run_on_last_close_flag", errno);
+ error ("PIOCSRLC or PR_RLC modification failed");
+}
+
+/*
+
+LOCAL FUNCTION
+
+ procfs_clear_syscall_trap -- Deletes the trap for the specified system call.
+
+SYNOPSIS
+
+ void procfs_clear_syscall_trap (struct procinfo *, int syscall_num, int errok)
+
+DESCRIPTION
+
+ This function function disables traps for the specified system call.
+ errok is non-zero if errors should be ignored.
+ */
+
+static void
+procfs_clear_syscall_trap (pi, syscall_num, errok)
+ struct procinfo *pi;
+ int syscall_num;
+ int errok;
+{
+ sysset_t sysset;
+ int goterr, i;
+
+ goterr = ioctl (pi->fd, PIOCGENTRY, &sysset) < 0;
+
+ if (goterr && !errok)
{
- info_proc_siginfo (pip, summary);
+ print_sys_errmsg (pi->pathname, errno);
+ error ("PIOCGENTRY failed");
}
- if (summary || all || syscalls)
+
+ if (!goterr)
{
- info_proc_syscalls (pip, summary);
+ prdelset (&sysset, syscall_num);
+
+ if ((ioctl (pi->fd, PIOCSENTRY, &sysset) < 0) && !errok)
+ {
+ print_sys_errmsg (pi->pathname, errno);
+ error ("PIOCSENTRY failed");
+ }
}
- if (summary || all || mappings)
+
+ goterr = ioctl (pi->fd, PIOCGEXIT, &sysset) < 0;
+
+ if (goterr && !errok)
{
- info_proc_mappings (pip, summary);
+ procfs_clear_syscall_trap (pi, syscall_num, 1);
+ print_sys_errmsg (pi->pathname, errno);
+ error ("PIOCGEXIT failed");
}
- if (summary || all || signals)
+
+ if (!goterr)
{
- info_proc_signals (pip, summary);
+ praddset (&sysset, syscall_num);
+
+ if ((ioctl (pi->fd, PIOCSEXIT, &sysset) < 0) && !errok)
+ {
+ procfs_clear_syscall_trap (pi, syscall_num, 1);
+ print_sys_errmsg (pi->pathname, errno);
+ error ("PIOCSEXIT failed");
+ }
}
- if (summary || all || faults)
+
+ if (!pi->syscall_handlers)
{
- info_proc_faults (pip, summary);
+ if (!errok)
+ error ("procfs_clear_syscall_trap: syscall_handlers is empty");
+ return;
}
- printf_filtered ("\n");
- /* All done, deal with closing any temporary process info structure,
- freeing temporary memory , etc. */
+ /* Remove handler func from the handler list */
- do_cleanups (old_chain);
+ for (i = 0; i < pi->num_syscall_handlers; i++)
+ if (pi->syscall_handlers[i].syscall_num == syscall_num)
+ {
+ if (i + 1 != pi->num_syscall_handlers)
+ { /* Not the last entry.
+ Move subsequent entries fwd. */
+ memcpy (&pi->syscall_handlers[i], &pi->syscall_handlers[i + 1],
+ (pi->num_syscall_handlers - i - 1)
+ * sizeof (struct procfs_syscall_handler));
+ }
+
+ pi->syscall_handlers = xrealloc (pi->syscall_handlers,
+ (pi->num_syscall_handlers - 1)
+ * sizeof (struct procfs_syscall_handler));
+ pi->num_syscall_handlers--;
+ return;
+ }
+
+ if (!errok)
+ error ("procfs_clear_syscall_trap: Couldn't find handler for sys call %d",
+ syscall_num);
}
/*
LOCAL FUNCTION
- procfs_set_sproc_trap -- arrange for child to stop on sproc().
+ procfs_set_syscall_trap -- arrange for a function to be called when the
+ child executes the specified system call.
SYNOPSIS
- void procfs_set_sproc_trap (struct procinfo *)
+ void procfs_set_syscall_trap (struct procinfo *, int syscall_num, int flags,
+ syscall_func_t *function)
DESCRIPTION
- This function sets up a trap on sproc system call exits so that we can
- detect the arrival of a new thread. We are called with the new thread
- stopped prior to it's first instruction.
-
- Also note that we turn on the inherit-on-fork flag in the child process
- so that any grand-children start with all tracing flags set.
+ This function sets up an entry and/or exit trap for the specified system
+ call. When the child executes the specified system call, your function
+ will be called with the call #, a flag that indicates entry or exit, and
+ pointers to rtnval and statval (which are used by procfs_wait). The
+ function should return non-zero if something interesting happened, zero
+ otherwise.
*/
-#ifdef SYS_sproc
-
static void
-procfs_set_sproc_trap (pi)
+procfs_set_syscall_trap (pi, syscall_num, flags, func)
struct procinfo *pi;
+ int syscall_num;
+ int flags;
+ syscall_func_t *func;
{
- sysset_t exitset;
+ sysset_t sysset;
- if (ioctl (pi->fd, PIOCGEXIT, &exitset) < 0)
+ if (flags & PROCFS_SYSCALL_ENTRY)
{
- print_sys_errmsg (pi->pathname, errno);
- error ("PIOCGEXIT failed");
+ if (ioctl (pi->fd, PIOCGENTRY, &sysset) < 0)
+ {
+ print_sys_errmsg (pi->pathname, errno);
+ error ("PIOCGENTRY failed");
+ }
+
+ praddset (&sysset, syscall_num);
+
+ if (ioctl (pi->fd, PIOCSENTRY, &sysset) < 0)
+ {
+ print_sys_errmsg (pi->pathname, errno);
+ error ("PIOCSENTRY failed");
+ }
}
- praddset (&exitset, SYS_sproc);
+ if (flags & PROCFS_SYSCALL_EXIT)
+ {
+ if (ioctl (pi->fd, PIOCGEXIT, &sysset) < 0)
+ {
+ procfs_clear_syscall_trap (pi, syscall_num, 1);
+ print_sys_errmsg (pi->pathname, errno);
+ error ("PIOCGEXIT failed");
+ }
- /* We trap on fork() and vfork() in order to disable debugging in our grand-
- children and descendant processes. At this time, GDB can only handle
- threads (multiple processes, one address space). forks (and execs) result
- in the creation of multiple address spaces, which GDB can't handle yet. */
+ praddset (&sysset, syscall_num);
- praddset (&exitset, SYS_fork);
-#ifdef SYS_vfork
- praddset (&exitset, SYS_vfork);
-#endif
+ if (ioctl (pi->fd, PIOCSEXIT, &sysset) < 0)
+ {
+ procfs_clear_syscall_trap (pi, syscall_num, 1);
+ print_sys_errmsg (pi->pathname, errno);
+ error ("PIOCSEXIT failed");
+ }
+ }
- if (ioctl (pi->fd, PIOCSEXIT, &exitset) < 0)
+ if (!pi->syscall_handlers)
{
- print_sys_errmsg (pi->pathname, errno);
- error ("PIOCSEXIT failed");
+ pi->syscall_handlers = xmalloc (sizeof (struct procfs_syscall_handler));
+ pi->syscall_handlers[0].syscall_num = syscall_num;
+ pi->syscall_handlers[0].func = func;
+ pi->num_syscall_handlers = 1;
}
+ else
+ {
+ int i;
- /* Turn on inherit-on-fork flag so that all grand-children of gdb start with
- tracing flags set. */
+ for (i = 0; i < pi->num_syscall_handlers; i++)
+ if (pi->syscall_handlers[i].syscall_num == syscall_num)
+ {
+ pi->syscall_handlers[i].func = func;
+ return;
+ }
-#ifdef PIOCSET /* New method */
- {
- long pr_flags;
- pr_flags = PR_FORK;
- ioctl (pi->fd, PIOCSET, &pr_flags);
- }
-#else
-#ifdef PIOCSFORK /* Original method */
- ioctl (pi->fd, PIOCSFORK, NULL);
-#endif
-#endif
+ pi->syscall_handlers = xrealloc (pi->syscall_handlers, (i + 1)
+ * sizeof (struct procfs_syscall_handler));
+ pi->syscall_handlers[i].syscall_num = syscall_num;
+ pi->syscall_handlers[i].func = func;
+ pi->num_syscall_handlers++;
+ }
}
-#endif /* SYS_sproc */
+
+#ifdef SYS_lwp_create
+
+/*
+
+LOCAL FUNCTION
+
+ procfs_lwp_creation_handler - handle exit from the _lwp_create syscall
+
+SYNOPSIS
+
+ int procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
+
+DESCRIPTION
+
+ This routine is called both when an inferior process and it's new lwp
+ are about to finish a _lwp_create() system call. This is the system
+ call that Solaris uses to create a lightweight process. When the
+ target process gets this event, we can look at sysarg[2] to find the
+ new childs lwp ID, and create a procinfo struct from that. After that,
+ we pretend that we got a SIGTRAP, and return non-zero to tell
+ procfs_wait to wake up. Subsequently, wait_for_inferior gets woken up,
+ sees the new process and continues it.
+
+ When we see the child exiting from lwp_create, we just contine it,
+ since everything was handled when the parent trapped.
+
+NOTES
+ In effect, we are only paying attention to the parent's completion of
+ the lwp_create syscall. If we only paid attention to the child
+ instead, then we wouldn't detect the creation of a suspended thread.
+ */
+
+static int
+procfs_lwp_creation_handler (pi, syscall_num, why, rtnvalp, statvalp)
+ struct procinfo *pi;
+ int syscall_num;
+ int why;
+ int *rtnvalp;
+ int *statvalp;
+{
+ int lwp_id;
+ struct procinfo *childpi;
+
+ /* We've just detected the completion of an lwp_create system call. Now we
+ need to setup a procinfo struct for this thread, and notify the thread
+ system of the new arrival. */
+
+ /* If lwp_create failed, then nothing interesting happened. Continue the
+ process and go back to sleep. */
+
+ if (pi->prstatus.pr_reg[R_PSR] & PS_FLAG_CARRY)
+ { /* _lwp_create failed */
+ pi->prrun.pr_flags &= PRSTEP;
+ pi->prrun.pr_flags |= PRCFAULT;
+
+ if (ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
+ perror_with_name (pi->pathname);
+
+ return 0;
+ }
+
+ /* At this point, the new thread is stopped at it's first instruction, and
+ the parent is stopped at the exit from lwp_create. */
+
+ if (pi->new_child) /* Child? */
+ { /* Yes, just continue it */
+ pi->prrun.pr_flags &= PRSTEP;
+ pi->prrun.pr_flags |= PRCFAULT;
+
+ if ((pi->prstatus.pr_flags & PR_ISTOP)
+ && ioctl (pi->fd, PIOCRUN, &pi->prrun) != 0)
+ perror_with_name (pi->pathname);
+
+ pi->new_child = 0; /* No longer new */
+
+ return 0;
+ }
+
+ /* 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));
+
+ lwp_id = (lwp_id << 16) | PIDGET (pi->pid);
+
+ 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
+ that child. */
+
+ procfs_set_syscall_trap (childpi, SYS_lwp_create, PROCFS_SYSCALL_EXIT,
+ procfs_lwp_creation_handler);
+
+ childpi->new_child = 1; /* Flag this as an unseen child process */
+
+ *rtnvalp = lwp_id; /* the new arrival. */
+ *statvalp = (SIGTRAP << 8) | 0177;
+
+ return 1;
+}
+#endif /* SYS_lwp_create */
/* Fork an inferior process, and start debugging it with /proc. */
/* We are at the first instruction we care about. */
/* Pedal to the metal... */
- /* Setup traps on exit from sproc() */
-
-#ifdef SYS_sproc
- procfs_set_sproc_trap (current_procinfo);
-#endif
-
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
}
static int
procfs_can_run ()
{
- return(1);
+ /* This variable is controlled by modules that sit atop procfs that may layer
+ their own process structure atop that provided here. sol-thread.c does
+ this because of the Solaris two-level thread model. */
+
+ return !procfs_suppress_run;
}
#ifdef TARGET_HAS_HARDWARE_WATCHPOINTS
\f
}
#endif
+/* Why is this necessary? Shouldn't dead threads just be removed from the
+ thread database? */
+
+int
+procfs_thread_alive (pid)
+ int pid;
+{
+ return 1;
+}
+
/* Send a SIGINT to the process group. This acts just like the user typed a
^C on the controlling terminal.
procfs_mourn_inferior, /* to_mourn_inferior */
procfs_can_run, /* to_can_run */
procfs_notice_signals, /* to_notice_signals */
- 0, /* to_thread_alive */
+ procfs_thread_alive, /* to_thread_alive */
procfs_stop, /* to_stop */
process_stratum, /* to_stratum */
0, /* to_next */
--- /dev/null
+/* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
+ Copyright 1996 Free Software Foundation, Inc.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+
+
+#include "defs.h"
+
+#ifdef gregset_t
+#undef gregset_t
+#endif
+
+#ifdef fpregset_t
+#undef fpregset_t
+#endif
+
+#include "/usr/include/thread.h"
+#include <proc_service.h>
+#include <thread_db.h>
+#include "thread.h"
+#include "target.h"
+#include "inferior.h"
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+static void sol_thread_resume PARAMS ((int pid, int step,
+ enum target_signal signo));
+
+extern struct target_ops sol_thread_ops; /* Forward declaration */
+
+extern int procfs_suppress_run;
+
+struct ps_prochandle
+{
+ pid_t pid;
+};
+
+static struct ps_prochandle main_ph;
+static td_thragent_t *main_ta;
+
+static int sol_thread_active = 0;
+
+\f
+
+extern struct target_ops procfs_ops;
+
+/* Convert thread_id to an LWP id. */
+
+static int thread_to_lwp PARAMS ((int thread_id, int default_lwp));
+
+static int
+thread_to_lwp (thread_id, default_lwp)
+ int thread_id;
+ int default_lwp;
+{
+ td_thrinfo_t ti;
+ td_thrhandle_t th;
+ td_err_e val;
+ int pid;
+ int lwp;
+
+ if (!(thread_id & 0x80000000))
+ return thread_id; /* It's already an LWP id */
+
+ /* It's a thread. Convert to lwp */
+
+ pid = thread_id & 0xffff;
+ thread_id = (thread_id >> 16) & 0x7fff;
+
+ val = td_ta_map_id2thr (main_ta, thread_id, &th);
+ if (val != TD_OK)
+ error ("thread_to_lwp: td_ta_map_id2thr %d", val);
+
+ val = td_thr_get_info (&th, &ti);
+
+ if (val != TD_OK)
+ error ("thread_to_lwp: td_thr_get_info: %d", val);
+
+ if (ti.ti_state != TD_THR_ACTIVE)
+ {
+ if (default_lwp != -1)
+ return default_lwp;
+ error ("thread_to_lwp: thread state not active: %d", ti.ti_state);
+ }
+
+ lwp = (ti.ti_lid << 16) | pid;
+
+ return lwp;
+}
+
+/* Convert an LWP id to a thread. */
+
+static int lwp_to_thread PARAMS ((int lwp));
+
+static int
+lwp_to_thread (lwp)
+ int lwp;
+{
+ td_thrinfo_t ti;
+ td_thrhandle_t th;
+ td_err_e val;
+ int pid;
+ int thread_id;
+
+ if (lwp & 0x80000000)
+ return lwp; /* It's already a thread id */
+
+ /* It's an lwp. Convert it to a thread id. */
+
+ pid = lwp & 0xffff;
+ lwp = (lwp >> 16) & 0xffff;
+
+ val = td_ta_map_lwp2thr (main_ta, lwp, &th);
+ if (val != TD_OK)
+ error ("lwp_to_thread: td_thr_get_info: %d.", val);
+
+ val = td_thr_get_info (&th, &ti);
+
+ if (val != TD_OK)
+ error ("lwp_to_thread: td_thr_get_info: %d.", val);
+
+ thread_id = (ti.ti_tid << 16) | pid | 0x80000000;
+
+ return thread_id;
+}
+
+
+/* ARGSUSED */
+static void
+sol_thread_open (arg, from_tty)
+ char *arg;
+ int from_tty;
+{
+ procfs_ops.to_open (arg, from_tty);
+}
+
+/* Attach to process PID, then initialize for debugging it
+ and wait for the trace-trap that results from attaching. */
+
+static void
+sol_thread_attach (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ procfs_ops.to_attach (args, from_tty);
+
+ /* XXX - might want to iterate over all the threads and register them. */
+}
+
+/* Take a program previously attached to and detaches it.
+ The program resumes execution and will no longer stop
+ on signals, etc. We'd better not have left any breakpoints
+ in the program or it'll die when it hits one. For this
+ to work, it may be necessary for the process to have been
+ previously attached. It *might* work if the program was
+ started via the normal ptrace (PTRACE_TRACEME). */
+
+static void
+sol_thread_detach (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ procfs_ops.to_detach (args, from_tty);
+}
+
+/* Resume execution of process PID. If STEP is nozero, then
+ just single step it. If SIGNAL is nonzero, restart it with that
+ signal activated. */
+
+static void
+sol_thread_resume (pid, step, signo)
+ int pid;
+ int step;
+ enum target_signal signo;
+{
+ int save_pid;
+
+ save_pid = inferior_pid;
+
+ inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
+
+ if (pid != -1)
+ pid = thread_to_lwp (pid, -1);
+
+ procfs_ops.to_resume (pid, step, signo);
+
+ inferior_pid = save_pid;
+}
+
+/* Wait for any LWPs to stop */
+
+static int
+sol_thread_wait (pid, ourstatus)
+ int pid;
+ struct target_waitstatus *ourstatus;
+{
+ int statval;
+ int rtnval;
+ int save_pid;
+
+ if (!sol_thread_active)
+ return procfs_ops.to_wait (pid, ourstatus);
+
+ save_pid = inferior_pid;
+
+ inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
+
+ if (pid != -1)
+ pid = thread_to_lwp (pid, -1);
+
+ rtnval = procfs_ops.to_wait (pid, ourstatus);
+
+ if (rtnval != save_pid
+ && !in_thread_list (rtnval))
+ {
+ fprintf_unfiltered (gdb_stderr, "[New %s]\n",
+ target_pid_to_str (rtnval));
+ add_thread (rtnval);
+ }
+
+ inferior_pid = save_pid; /* XXX need to make a cleanup for this in case of error */
+
+ /* 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);
+
+ return rtnval;
+}
+
+static void
+sol_thread_fetch_registers (regno)
+ int regno;
+{
+ thread_t thread;
+ td_thrhandle_t thandle;
+ td_err_e val;
+ prgregset_t regset;
+ prfpregset_t fpregset;
+ int xregsize;
+ caddr_t xregset;
+
+ if (!sol_thread_active
+ || !(inferior_pid & 0x80000000))
+ {
+ procfs_ops.to_fetch_registers (regno);
+ return;
+ }
+
+ /* Convert inferior_pid into a td_thrhandle_t */
+
+ thread = (inferior_pid >> 16) & 0x7fff;
+
+ if (thread == 0)
+ error ("sol_thread_fetch_registers: thread == 0");
+
+ val = td_ta_map_id2thr (main_ta, thread, &thandle);
+ if (val != TD_OK)
+ error ("sol_thread_fetch_registers: td_ta_map_id2thr: %d", val);
+
+ /* Get the integer regs */
+
+ val = td_thr_getgregs (&thandle, regset);
+ if (val == TD_OK)
+ supply_gregset (regset);
+ else if (val == TD_PARTIALREG)
+ {
+ /* For the sparc, only i0->i7, l0->l7, pc and sp are saved by a thread
+ context switch. */
+
+ supply_gregset (regset); /* This is not entirely correct, as it sets
+ the valid bits for the o, g, ps, y, npc,
+ wim and tbr. That should be harmless
+ though, as the context switch routine
+ doesn't need to save them. */
+ }
+ else
+ error ("sol_thread_fetch_registers: td_thr_getgregs %d", val);
+
+ /* And, now the fp regs */
+
+ val = td_thr_getfpregs (&thandle, &fpregset);
+ if (val == TD_OK)
+ supply_fpregset (&fpregset);
+ else if (val != TD_NOFPREGS)
+ error ("sol_thread_fetch_registers: td_thr_getfpregs %d", val);
+
+#if 0
+/* thread_db doesn't seem to handle this right */
+ val = td_thr_getxregsize (&thandle, &xregsize);
+ if (val != TD_OK && val != TD_NOXREGS)
+ error ("sol_thread_fetch_registers: td_thr_getxregsize %d", val);
+
+ if (val == TD_OK)
+ {
+ xregset = alloca (xregsize);
+ val = td_thr_getxregs (&thandle, xregset);
+ if (val != TD_OK)
+ error ("sol_thread_fetch_registers: td_thr_getxregs %d", val);
+ }
+#endif
+}
+
+static void
+sol_thread_store_registers (regno)
+ int regno;
+{
+ thread_t thread;
+ td_thrhandle_t thandle;
+ td_err_e val;
+ prgregset_t regset;
+ prfpregset_t fpregset;
+ int xregsize;
+ caddr_t xregset;
+
+ if (!sol_thread_active
+ || !(inferior_pid & 0x80000000))
+ {
+ procfs_ops.to_store_registers (regno);
+ return;
+ }
+
+ /* Convert inferior_pid into a td_thrhandle_t */
+
+ thread = (inferior_pid >> 16) & 0x7fff;
+
+ val = td_ta_map_id2thr (main_ta, thread, &thandle);
+ if (val != TD_OK)
+ error ("sol_thread_store_registers: td_ta_map_id2thr %d", val);
+
+ if (regno != -1)
+ { /* Not writing all the regs */
+ val = td_thr_getgregs (&thandle, regset);
+ if (val != TD_OK)
+ error ("sol_thread_store_registers: td_thr_getgregs %d", val);
+ val = td_thr_getfpregs (&thandle, &fpregset);
+ if (val != TD_OK)
+ error ("sol_thread_store_registers: td_thr_getfpregs %d", val);
+
+#if 0
+/* thread_db doesn't seem to handle this right */
+ val = td_thr_getxregsize (&thandle, &xregsize);
+ if (val != TD_OK && val != TD_NOXREGS)
+ error ("sol_thread_store_registers: td_thr_getxregsize %d", val);
+
+ if (val == TD_OK)
+ {
+ xregset = alloca (xregsize);
+ val = td_thr_getxregs (&thandle, xregset);
+ if (val != TD_OK)
+ error ("sol_thread_store_registers: td_thr_getxregs %d", val);
+ }
+#endif
+ }
+
+ fill_gregset (regset, regno);
+ fill_fpregset (&fpregset, regno);
+
+ val = td_thr_setgregs (&thandle, regset);
+ if (val != TD_OK)
+ error ("sol_thread_store_registers: td_thr_setgregs %d", val);
+ val = td_thr_setfpregs (&thandle, &fpregset);
+ if (val != TD_OK)
+ error ("sol_thread_store_registers: td_thr_setfpregs %d", val);
+
+#if 0
+/* thread_db doesn't seem to handle this right */
+ val = td_thr_getxregsize (&thandle, &xregsize);
+ if (val != TD_OK && val != TD_NOXREGS)
+ error ("sol_thread_store_registers: td_thr_getxregsize %d", val);
+
+ /* Should probably do something about writing the xregs here, but what are
+ they? */
+#endif
+}
+
+/* Get ready to modify the registers array. On machines which store
+ individual registers, this doesn't need to do anything. On machines
+ which store all the registers in one fell swoop, this makes sure
+ that registers contains all the registers from the program being
+ debugged. */
+
+static void
+sol_thread_prepare_to_store ()
+{
+ procfs_ops.to_prepare_to_store ();
+}
+
+static int
+sol_thread_xfer_memory (memaddr, myaddr, len, dowrite, target)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+ int dowrite;
+ struct target_ops *target; /* ignored */
+{
+ int retval;
+ int save_pid;
+
+ save_pid = inferior_pid;
+
+ if (inferior_pid & 0x80000000)
+ inferior_pid = main_ph.pid; /* It's a thread. Convert to lwp */
+
+ retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, target);
+
+ inferior_pid = save_pid;
+
+ return retval;
+}
+
+/* Print status information about what we're accessing. */
+
+static void
+sol_thread_files_info (ignore)
+ struct target_ops *ignore;
+{
+ procfs_ops.to_files_info (ignore);
+}
+
+static void
+sol_thread_kill_inferior ()
+{
+ procfs_ops.to_kill ();
+}
+
+static void
+sol_thread_notice_signals (pid)
+ int 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
+sol_thread_create_inferior (exec_file, allargs, env)
+ char *exec_file;
+ char *allargs;
+ char **env;
+{
+ procfs_ops.to_create_inferior (exec_file, allargs, env);
+
+ if (sol_thread_active)
+ {
+ td_thrhandle_t thandle;
+ td_err_e val;
+ td_thrinfo_t ti;
+
+ main_ph.pid = inferior_pid; /* Save for xfer_memory */
+
+ push_target (&sol_thread_ops);
+
+ inferior_pid = lwp_to_thread (inferior_pid);
+
+ add_thread (inferior_pid);
+ }
+}
+
+/* This routine is called whenever a new symbol table is read in, or when all
+ symbol tables are removed. */
+
+void
+sol_thread_new_objfile (objfile)
+ struct objfile *objfile;
+{
+ td_err_e val;
+
+ if (!objfile)
+ {
+ sol_thread_active = 0;
+
+ 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. */
+
+ val = td_init ();
+ if (val != TD_OK)
+ error ("target_new_objfile: td_init: %d", val);
+
+ val = td_ta_new (&main_ph, &main_ta);
+ if (val == TD_NOLIBTHREAD)
+ return;
+ else if (val != TD_OK)
+ error ("target_new_objfile: td_ta_new: %d", val);
+
+ sol_thread_active = 1;
+}
+
+/* Clean up after the inferior dies. */
+
+static void
+sol_thread_mourn_inferior ()
+{
+ procfs_ops.to_mourn_inferior ();
+}
+
+/* Mark our target-struct as eligible for stray "run" and "attach" commands. */
+static int
+sol_thread_can_run ()
+{
+ return procfs_suppress_run;
+}
+
+int
+sol_thread_alive (pid)
+ int pid;
+{
+ return 1;
+}
+
+void
+sol_thread_stop ()
+{
+ procfs_ops.to_stop ();
+}
+
+/* Service routines we must supply to libthread_db */
+
+struct lwp_map
+{
+ struct lwp_map *next;
+ pid_t pid;
+ lwpid_t lwp;
+ int lwpfd;
+};
+
+#if 0
+struct lwp_map *lwp_map;
+
+/* Create a /proc file descriptor for the given LWPID */
+
+static ps_err_e
+get_lwp_fd (const struct ps_prochandle *ph, const lwpid_t lwpid, int *fd)
+{
+ struct lwp_map *lp;
+
+ for (lp = lwp_map; lp; lp = lp->next)
+ if (lp->pid = ph->pid
+ && lp->lwp == lwpid)
+ {
+ *fd = lp->lwpfd;
+
+ return PS_OK;
+ }
+
+ lp = xmalloc (sizeof (struct lwp_map));
+
+ if ((lp->lwpfd = ioctl (ph->fd, PIOCOPENLWP, &lwpid)) < 0)
+ {
+ print_sys_errmsg ("get_lwp_fd (): PIOCOPENLWP", errno);
+ return PS_BADLID;
+ }
+
+ lp->pid = ph->pid;
+ lp->lwp = lwpid;
+ lp->next = lwp_map;
+ lwp_map = lp;
+
+ *fd = lp->lwpfd;
+
+ return PS_OK;
+}
+#endif
+
+ps_err_e
+ps_pstop (const struct ps_prochandle *ph)
+{
+#if 0
+ if (ioctl (ph->fd, PIOCSTOP, NULL))
+ {
+ print_sys_errmsg ("ps_pstop (): PIOCSTOP", errno);
+ return PS_ERR;
+ }
+#endif
+ return PS_OK;
+}
+
+ps_err_e
+ps_pcontinue (const struct ps_prochandle *ph)
+{
+#if 0
+ if (ioctl (ph->fd, PIOCRUN, NULL))
+ {
+ print_sys_errmsg ("ps_pcontinue (): PIOCRUN", errno);
+ return PS_ERR;
+ }
+#endif
+ return PS_OK;
+}
+
+ps_err_e
+ps_lstop (const struct ps_prochandle *ph, lwpid_t lwpid)
+{
+ int lwp_fd;
+ ps_err_e val;
+
+#if 0
+ val = get_lwp_fd (ph, lwpid, &lwp_fd);
+ if (val != PS_OK)
+ return val;
+
+ if (ioctl (lwp_fd, PIOCSTOP, NULL))
+ {
+ print_sys_errmsg ("ps_lstop (): PIOCSTOP", errno);
+ return PS_ERR;
+ }
+#endif
+
+ return PS_OK;
+}
+
+ps_err_e
+ps_lcontinue (const struct ps_prochandle *ph, lwpid_t lwpid)
+{
+ int lwp_fd;
+ ps_err_e val;
+
+#if 0
+ val = get_lwp_fd (ph, lwpid, &lwp_fd);
+ if (val != PS_OK)
+ return val;
+
+ if (ioctl (lwp_fd, PIOCRUN, NULL))
+ {
+ print_sys_errmsg ("ps_lcontinue (): PIOCRUN", errno);
+ return PS_ERR;
+ }
+#endif
+
+ return PS_OK;
+}
+
+ps_err_e
+ps_pglobal_lookup (const struct ps_prochandle *ph, const char *ld_object_name,
+ const char *ld_symbol_name, paddr_t *ld_symbol_addr)
+{
+ struct minimal_symbol *ms;
+
+ ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
+
+ if (!ms)
+ return PS_NOSYM;
+
+ *ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
+
+ return PS_OK;
+}
+
+static ps_err_e
+rw_common (int dowrite, const struct ps_prochandle *ph, paddr_t addr,
+ char *buf, int size)
+{
+ int save_pid;
+
+ save_pid = inferior_pid;
+
+ if (inferior_pid & 0x80000000)
+ inferior_pid = main_ph.pid; /* It's a thread. Convert to lwp */
+
+ while (size > 0)
+ {
+ int cc;
+
+ cc = procfs_ops.to_xfer_memory (addr, buf, size, dowrite, &procfs_ops);
+
+ if (cc < 0)
+ {
+ if (dowrite == 0)
+ print_sys_errmsg ("ps_pdread (): read", errno);
+ else
+ print_sys_errmsg ("ps_pdread (): write", errno);
+
+ inferior_pid = save_pid;
+
+ return PS_ERR;
+ }
+ size -= cc;
+ buf += cc;
+ }
+
+ inferior_pid = save_pid;
+
+ return PS_OK;
+}
+
+ps_err_e
+ps_pdread (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
+{
+ return rw_common (0, ph, addr, buf, size);
+}
+
+ps_err_e
+ps_pdwrite (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
+{
+ return rw_common (1, ph, addr, buf, size);
+}
+
+ps_err_e
+ps_ptread (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
+{
+ return rw_common (0, ph, addr, buf, size);
+}
+
+ps_err_e
+ps_ptwrite (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
+{
+ return rw_common (1, ph, addr, buf, size);
+}
+
+ps_err_e
+ps_lgetregs (const struct ps_prochandle *ph, lwpid_t lwpid,
+ prgregset_t gregset)
+{
+ int save_pid;
+
+ save_pid = inferior_pid;
+
+ inferior_pid = (lwpid << 16) | (inferior_pid & 0xffff);
+
+ procfs_ops.to_fetch_registers (-1);
+ fill_gregset (gregset, -1);
+
+ inferior_pid = save_pid;
+
+ return PS_OK;
+}
+
+ps_err_e
+ps_lsetregs (const struct ps_prochandle *ph, lwpid_t lwpid,
+ const prgregset_t gregset)
+{
+ int save_pid;
+
+ save_pid = inferior_pid;
+
+ inferior_pid = (lwpid << 16) | (inferior_pid & 0xffff);
+
+ supply_gregset (gregset);
+ procfs_ops.to_store_registers (-1);
+
+ inferior_pid = save_pid;
+
+ return PS_OK;
+}
+
+void
+ps_plog (const char *fmt, ...)
+{
+ va_list args;
+
+ va_start (args, fmt);
+
+ vfprintf_filtered (gdb_stderr, fmt, args);
+}
+
+ps_err_e
+ps_lgetxregsize (const struct ps_prochandle *ph, lwpid_t lwpid, int *xregsize)
+{
+ int lwp_fd;
+ int regsize;
+ ps_err_e val;
+
+#if 0
+ val = get_lwp_fd (ph, lwpid, &lwp_fd);
+ if (val != PS_OK)
+ return val;
+
+ if (ioctl (lwp_fd, PIOCGXREGSIZE, ®size))
+ {
+ if (errno == EINVAL)
+ return PS_NOFREGS; /* XXX Wrong code, but this is the closest
+ thing in proc_service.h */
+
+ print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno);
+ return PS_ERR;
+ }
+#endif
+
+ return PS_OK;
+}
+
+ps_err_e
+ps_lgetxregs (const struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
+{
+ int lwp_fd;
+ ps_err_e val;
+
+#if 0
+ val = get_lwp_fd (ph, lwpid, &lwp_fd);
+ if (val != PS_OK)
+ return val;
+
+ if (ioctl (lwp_fd, PIOCGXREG, xregset))
+ {
+ print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno);
+ return PS_ERR;
+ }
+#endif
+
+ return PS_OK;
+}
+
+ps_err_e
+ps_lsetxregs (const struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
+{
+ int lwp_fd;
+ ps_err_e val;
+
+#if 0
+ val = get_lwp_fd (ph, lwpid, &lwp_fd);
+ if (val != PS_OK)
+ return val;
+
+ if (ioctl (lwp_fd, PIOCSXREG, xregset))
+ {
+ print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno);
+ return PS_ERR;
+ }
+#endif
+
+ return PS_OK;
+}
+
+ps_err_e
+ps_lgetfpregs (const struct ps_prochandle *ph, lwpid_t lwpid,
+ prfpregset_t *fpregset)
+{
+ int save_pid;
+
+ save_pid = inferior_pid;
+
+ inferior_pid = (lwpid << 16) | (inferior_pid & 0xffff);
+
+ procfs_ops.to_fetch_registers (-1);
+ fill_fpregset (fpregset, -1);
+
+ inferior_pid = save_pid;
+
+ return PS_OK;
+}
+
+ps_err_e
+ps_lsetfpregs (const struct ps_prochandle *ph, lwpid_t lwpid,
+ const prfpregset_t *fpregset)
+{
+ int save_pid;
+
+ save_pid = inferior_pid;
+
+ inferior_pid = (lwpid << 16) | (inferior_pid & 0xffff);
+
+ supply_gregset (fpregset);
+ procfs_ops.to_store_registers (-1);
+
+ inferior_pid = save_pid;
+
+ return PS_OK;
+}
+\f
+char *
+solaris_pid_to_str (pid)
+ int pid;
+{
+ static char buf[100];
+
+ if (pid & 0x80000000)
+ {
+ int lwp;
+
+ lwp = thread_to_lwp (pid, -2);
+
+ if (lwp != -2)
+ sprintf (buf, "Thread %d (LWP %d)", (pid >> 16) & 0x7fff,
+ (lwp >> 16) & 0xffff);
+ else
+ sprintf (buf, "Thread %d ", (pid >> 16) & 0x7fff);
+ }
+ else
+ sprintf (buf, "LWP %d ", (pid >> 16) & 0xffff);
+
+ return buf;
+}
+\f
+struct target_ops sol_thread_ops = {
+ "solaris-threads", /* to_shortname */
+ "Solaris threads and pthread.", /* to_longname */
+ "Solaris threads and pthread support.", /* to_doc */
+ sol_thread_open, /* to_open */
+ 0, /* to_close */
+ sol_thread_attach, /* to_attach */
+ sol_thread_detach, /* to_detach */
+ sol_thread_resume, /* to_resume */
+ sol_thread_wait, /* to_wait */
+ sol_thread_fetch_registers, /* to_fetch_registers */
+ sol_thread_store_registers, /* to_store_registers */
+ sol_thread_prepare_to_store, /* to_prepare_to_store */
+ sol_thread_xfer_memory, /* to_xfer_memory */
+ sol_thread_files_info, /* to_files_info */
+ memory_insert_breakpoint, /* to_insert_breakpoint */
+ memory_remove_breakpoint, /* to_remove_breakpoint */
+ terminal_init_inferior, /* to_terminal_init */
+ terminal_inferior, /* to_terminal_inferior */
+ terminal_ours_for_output, /* to_terminal_ours_for_output */
+ terminal_ours, /* to_terminal_ours */
+ child_terminal_info, /* to_terminal_info */
+ sol_thread_kill_inferior, /* to_kill */
+ 0, /* to_load */
+ 0, /* to_lookup_symbol */
+ sol_thread_create_inferior, /* to_create_inferior */
+ sol_thread_mourn_inferior, /* to_mourn_inferior */
+ sol_thread_can_run, /* to_can_run */
+ sol_thread_notice_signals, /* to_notice_signals */
+ sol_thread_alive, /* to_thread_alive */
+ sol_thread_stop, /* to_stop */
+ process_stratum, /* to_stratum */
+ 0, /* to_next */
+ 1, /* to_has_all_memory */
+ 1, /* to_has_memory */
+ 1, /* to_has_stack */
+ 1, /* to_has_registers */
+ 1, /* to_has_execution */
+ 0, /* sections */
+ 0, /* sections_end */
+ OPS_MAGIC /* to_magic */
+};
+
+void
+_initialize_sol_thread ()
+{
+ add_target (&sol_thread_ops);
+
+ procfs_suppress_run = 1;
+}
projects / deliverable / binutils-gdb.git / commitdiff
