OpenSolaris_b135/lib/libc/i386/sys/ptrace.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * ptrace(2) interface built on top of proc(4).
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#pragma weak _ptrace = ptrace

#include "lint.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <signal.h>
#include <sys/siginfo.h>
#include <sys/fault.h>
#include <sys/syscall.h>
#include <procfs.h>
#include <sys/psw.h>
#include <sys/user.h>
/*
 * mtlib.h must precede thread.h
 */
#include <mtlib.h>
#include <thread.h>
#include <synch.h>

static mutex_t pt_lock = DEFAULTMUTEX;

#define	TRUE	1
#define	FALSE	0

/*
 * All my children...
 */
typedef struct cstatus {
	struct cstatus	*next;		/* linked list			*/
	pid_t		pid;		/* process-id			*/
	int		asfd;		/* /proc/<pid>/as		*/
	int		ctlfd;		/* /proc/<pid>/ctl		*/
	int		statusfd;	/* /proc/<pid>/status		*/
	int		flags;		/* see below			*/
	pstatus_t	pstatus;	/* from /proc/<pid>/status	*/
	user_t		user;		/* manufactured u-block		*/
} cstatus_t;

/* flags */
#define	CS_SETREGS	0x01		/* set registers on run		*/
#define	CS_PSARGS	0x02		/* u_psargs[] has been fetched	*/
#define	CS_SIGNAL	0x04		/* u_signal[] has been fetched	*/

#define	NULLCP	((cstatus_t *)0)

static cstatus_t *childp = NULLCP;

/* fake u-block offsets */
#define	UP		((user_t *)NULL)
#define	U_REG		((int)(&UP->u_reg[0]))
#define	U_AR0		((int)(&UP->u_ar0))
#define	U_PSARGS	((int)(&UP->u_psargs[0]))
#define	U_SIGNAL	((int)(&UP->u_signal[0]))
#define	U_CODE		((int)(&UP->u_code))
#define	U_ADDR		((int)(&UP->u_addr))
#define	U_END		((int)sizeof (user_t))
#define	REGADDR		0xffff0000	/* arbitrary kernel address for u_ar0 */

/* external routines defined in this module */
extern	int	ptrace(int, pid_t, int, int);
/* static routines defined in this module */
static	cstatus_t *FindProc(pid_t);
static	void	CheckAllProcs(void);
static	int	Dupfd(int, int);
static	void	MakeProcName(char *, pid_t);
static	int	OpenProc(cstatus_t *);
static	void	CloseProc(cstatus_t *);
static	cstatus_t *GrabProc(pid_t);
static	void	ReleaseProc(cstatus_t *);
static	int	ProcUpdate(cstatus_t *);
static	void	MakeUser(cstatus_t *);
static	void	GetPsargs(cstatus_t *);
static	void	GetSignal(cstatus_t *);

#if PTRACE_DEBUG
/* for debugging */
static char *
map(int request)
{
	static char name[20];

	switch (request) {
	case 0:	return ("PTRACE_TRACEME");
	case 1:	return ("PTRACE_PEEKTEXT");
	case 2:	return ("PTRACE_PEEKDATA");
	case 3:	return ("PTRACE_PEEKUSER");
	case 4:	return ("PTRACE_POKETEXT");
	case 5:	return ("PTRACE_POKEDATA");
	case 6:	return ("PTRACE_POKEUSER");
	case 7:	return ("PTRACE_CONT");
	case 8:	return ("PTRACE_KILL");
	case 9:	return ("PTRACE_SINGLESTEP");
	}
	(void) sprintf(name, "%d", request);
	return (name);
}
#endif

int
ptrace(int request, pid_t pid, int addr, int data)
{
	pstatus_t *ps;
	cstatus_t *cp;
	unsigned xaddr;
	struct {
		long cmd;
		union {
			long flags;
			sigset_t signals;
			fltset_t faults;
			sysset_t syscalls;
			siginfo_t siginfo;
		} arg;
	} ctl;

#if PTRACE_DEBUG
	fprintf(stderr, " ptrace(%s, 0x%X, 0x%X, 0x%X)\n",
	    map(request), pid, addr, data);
#endif

	(void) mutex_lock(&pt_lock);

	if (request == 0) {	/* PTRACE_TRACEME, executed by traced process */
		/*
		 * Set stop-on-all-signals and nothing else.
		 * Turn off inherit-on-fork flag (grandchildren run away).
		 * Set ptrace-compatible flag.
		 */
		char procname[64];	/* /proc/<pid>/ctl */
		int fd;

		MakeProcName(procname, getpid());
		(void) strcat(procname, "/ctl");
		if ((fd = open(procname, O_WRONLY, 0)) < 0)
			exit(255);
		ctl.cmd = PCSTRACE;
		prfillset(&ctl.arg.signals);
		if (write(fd, (char *)&ctl, sizeof (long)+sizeof (sigset_t))
		    != sizeof (long)+sizeof (sigset_t))
			exit(255);
		ctl.cmd = PCSFAULT;
		premptyset(&ctl.arg.faults);
		if (write(fd, (char *)&ctl, sizeof (long)+sizeof (fltset_t))
		    != sizeof (long)+sizeof (fltset_t))
			exit(255);
		ctl.cmd = PCSENTRY;
		premptyset(&ctl.arg.syscalls);
		if (write(fd, (char *)&ctl, sizeof (long)+sizeof (sysset_t))
		    != sizeof (long)+sizeof (sysset_t))
			exit(255);
		ctl.cmd = PCSEXIT;
		premptyset(&ctl.arg.syscalls);
		if (write(fd, (char *)&ctl, sizeof (long)+sizeof (sysset_t))
		    != sizeof (long)+sizeof (sysset_t))
			exit(255);
		ctl.cmd = PCUNSET;
		ctl.arg.flags = PR_FORK;
		if (write(fd, (char *)&ctl, sizeof (long)+sizeof (long))
		    != sizeof (long)+sizeof (long))
			exit(255);
		ctl.cmd = PCSET;
		ctl.arg.flags = PR_PTRACE;
		if (write(fd, (char *)&ctl, sizeof (long)+sizeof (long))
		    != sizeof (long)+sizeof (long))
			exit(255);
		if (close(fd) != 0)
			exit(255);

		(void) mutex_unlock(&pt_lock);
		return (0);
	}

again:
	errno = 0;

	/* find the cstatus structure corresponding to pid */
	if ((cp = GrabProc(pid)) == NULLCP)
		goto esrch;

	ps = &cp->pstatus;
	if (!(ps->pr_flags & PR_ISTOP)) {
		if (ProcUpdate(cp) != 0) {
			ReleaseProc(cp);
			goto esrch;
		}
		if (!(ps->pr_flags & PR_ISTOP))
			goto esrch;
	}

	/*
	 * Process the request.
	 */
	errno = 0;
	switch (request) {
	case 1:		/* PTRACE_PEEKTEXT */
	case 2:		/* PTRACE_PEEKDATA */
		if (addr & 03)
			goto eio;
		if (pread(cp->asfd, (char *)&data, sizeof (data), (off_t)addr)
		    == sizeof (data)) {
			(void) mutex_unlock(&pt_lock);
			return (data);
		}
		goto eio;

	case 3:		/* PTRACE_PEEKUSER */
		if (addr & 03)
			goto eio;
		xaddr = addr;
		if (xaddr >= REGADDR && xaddr < REGADDR+sizeof (gregset_t))
			xaddr -= REGADDR-U_REG;
		if (xaddr >= U_PSARGS && xaddr < U_PSARGS+sizeof (UP->u_psargs))
			GetPsargs(cp);
		if (xaddr >= U_SIGNAL && xaddr < U_SIGNAL+sizeof (UP->u_signal))
			GetSignal(cp);
		if ((int)xaddr >= 0 && xaddr < U_END) {
			/* LINTED pointer alignment */
			data = *((int *)((caddr_t)(&cp->user) + xaddr));
			(void) mutex_unlock(&pt_lock);
			return (data);
		}
		goto eio;

	case 4:		/* PTRACE_POKETEXT */
	case 5:		/* PTRACE_POKEDATA */
		if (addr & 03)
			goto eio;
		if (pwrite(cp->asfd, (char *)&data, sizeof (data), (off_t)addr)
		    == sizeof (data)) {
			(void) mutex_unlock(&pt_lock);
			return (data);
		}
		goto eio;

	case 6:		/* PTRACE_POKEUSER */
		if (addr & 03)
			goto eio;
		xaddr = addr;
		if (xaddr >= REGADDR && xaddr < REGADDR+sizeof (gregset_t))
			xaddr -= REGADDR-U_REG;
		if ((int)xaddr >= U_REG && xaddr < U_REG+sizeof (gregset_t)) {
			int rx = (xaddr-U_REG)/sizeof (greg_t);
			if (rx == EFL)
				data = (cp->user.u_reg[EFL] & ~PSL_USERMASK) |
				    (data & PSL_USERMASK);
			cp->user.u_reg[rx] = data;
			cp->flags |= CS_SETREGS;
			(void) mutex_unlock(&pt_lock);
			return (data);
		}
		goto eio;

	case 7:		/* PTRACE_CONT */
	case 9:		/* PTRACE_SINGLESTEP */
	{
		long runctl[3];

		if (cp->flags & CS_SETREGS) {
			long cmd;
			iovec_t iov[2];

			ps->pr_lwp.pr_reg[GS] = cp->user.u_reg[GS];
			ps->pr_lwp.pr_reg[FS] = cp->user.u_reg[FS];
			ps->pr_lwp.pr_reg[ES] = cp->user.u_reg[ES];
			ps->pr_lwp.pr_reg[DS] = cp->user.u_reg[DS];
			ps->pr_lwp.pr_reg[EDI] = cp->user.u_reg[EDI];
			ps->pr_lwp.pr_reg[ESI] = cp->user.u_reg[ESI];
			ps->pr_lwp.pr_reg[EBP] = cp->user.u_reg[EBP];
			ps->pr_lwp.pr_reg[ESP] = cp->user.u_reg[ESP];
			ps->pr_lwp.pr_reg[EBX] = cp->user.u_reg[EBX];
			ps->pr_lwp.pr_reg[EDX] = cp->user.u_reg[EDX];
			ps->pr_lwp.pr_reg[ECX] = cp->user.u_reg[ECX];
			ps->pr_lwp.pr_reg[EAX] = cp->user.u_reg[EAX];
			ps->pr_lwp.pr_reg[TRAPNO] = cp->user.u_reg[TRAPNO];
			ps->pr_lwp.pr_reg[ERR] = cp->user.u_reg[ERR];
			ps->pr_lwp.pr_reg[EIP] = cp->user.u_reg[EIP];
			ps->pr_lwp.pr_reg[CS] = cp->user.u_reg[CS];
			ps->pr_lwp.pr_reg[EFL] = cp->user.u_reg[EFL];
			ps->pr_lwp.pr_reg[UESP] = cp->user.u_reg[UESP];
			ps->pr_lwp.pr_reg[SS] = cp->user.u_reg[SS];
			cmd = PCSREG;
			iov[0].iov_base = (caddr_t)&cmd;
			iov[0].iov_len = sizeof (long);
			iov[1].iov_base = (caddr_t)&ps->pr_lwp.pr_reg[0];
			iov[1].iov_len = sizeof (ps->pr_lwp.pr_reg);
			if (writev(cp->ctlfd, iov, 2) < 0)
				goto tryagain;
		}
		if (addr != 1 &&	/* new virtual address */
		    addr != cp->user.u_reg[EIP]) {
			runctl[0] = PCSVADDR;
			runctl[1] = addr;
			if (write(cp->ctlfd, (char *)runctl, 2*sizeof (long))
			    != 2*sizeof (long))
				goto tryagain;
		}
		/* make data the current signal */
		if (data != 0 && data != ps->pr_lwp.pr_cursig) {
			(void) memset((char *)&ctl.arg.siginfo, 0,
			    sizeof (siginfo_t));
			ctl.arg.siginfo.si_signo = data;
			ctl.cmd = PCSSIG;
			if (write(cp->ctlfd, (char *)&ctl,
			    sizeof (long)+sizeof (siginfo_t))
			    != sizeof (long)+sizeof (siginfo_t))
				goto tryagain;
		}
		if (data == 0)
			runctl[0] = PCCSIG;
		else
			runctl[0] = PCNULL;
		runctl[1] = PCRUN;
		runctl[2] = (request == 9)? PRSTEP : 0;
		if (write(cp->ctlfd, (char *)runctl, 3*sizeof (long))
		    != 3*sizeof (long)) {
			if (errno == ENOENT) {
				/* current signal must have killed it */
				ReleaseProc(cp);
				(void) mutex_unlock(&pt_lock);
				return (data);
			}
			goto tryagain;
		}
		(void) memset((char *)ps, 0, sizeof (pstatus_t));
		cp->flags = 0;
		(void) mutex_unlock(&pt_lock);
		return (data);
	}

	case 8:		/* PTRACE_KILL */
		/* overkill? */
		(void) memset((char *)&ctl.arg.siginfo, 0, sizeof (siginfo_t));
		ctl.arg.siginfo.si_signo = SIGKILL;
		ctl.cmd = PCSSIG;
		(void) write(cp->ctlfd, (char *)&ctl,
		    sizeof (long)+sizeof (siginfo_t));
		(void) kill(pid, SIGKILL);
		ReleaseProc(cp);
		(void) mutex_unlock(&pt_lock);
		return (0);

	default:
		goto eio;
	}

tryagain:
	if (errno == EAGAIN) {
		if (OpenProc(cp) == 0)
			goto again;
		ReleaseProc(cp);
	}
eio:
	errno = EIO;
	(void) mutex_unlock(&pt_lock);
	return (-1);
esrch:
	errno = ESRCH;
	(void) mutex_unlock(&pt_lock);
	return (-1);
}

/*
 * Find the cstatus structure corresponding to pid.
 */
static cstatus_t *
FindProc(pid_t pid)
{
	cstatus_t *cp;

	for (cp = childp; cp != NULLCP; cp = cp->next)
		if (cp->pid == pid)
			break;

	return (cp);
}

/*
 * Check every proc for existence, release those that are gone.
 * Be careful about the linked list; ReleaseProc() changes it.
 */
static void
CheckAllProcs()
{
	cstatus_t *cp = childp;

	while (cp != NULLCP) {
		cstatus_t *next = cp->next;

		if (ProcUpdate(cp) != 0)
			ReleaseProc(cp);
		cp = next;
	}
}

/*
 * Utility for OpenProc().
 */
static int
Dupfd(int fd, int dfd)
{
	/*
	 * Make sure fd not one of 0, 1, or 2 to avoid stdio interference.
	 * Also, if dfd is greater than 2, dup fd to be exactly dfd.
	 */
	if (dfd > 2 || (0 <= fd && fd <= 2)) {
		if (dfd > 2 && fd != dfd)
			(void) close(dfd);
		else
			dfd = 3;
		if (fd != dfd) {
			dfd = fcntl(fd, F_DUPFD, (intptr_t)dfd);
			(void) close(fd);
			fd = dfd;
		}
	}
	/*
	 * Mark filedescriptor close-on-exec.
	 * Should also be close-on-return-from-fork-in-child.
	 */
	(void) fcntl(fd, F_SETFD, (intptr_t)1);
	return (fd);
}

/*
 * Construct the /proc directory name:  "/proc/<pid>"
 * The name buffer passed by the caller must be large enough.
 */
static void
MakeProcName(char *procname, pid_t pid)
{
	(void) sprintf(procname, "/proc/%ld", pid);
}

/*
 * Open/reopen the /proc/<pid> files.
 */
static int
OpenProc(cstatus_t *cp)
{
	char procname[64];		/* /proc/nnnnn/fname */
	char *fname;
	int fd;
	int omode;

	MakeProcName(procname, cp->pid);
	fname = procname + strlen(procname);

	/*
	 * Use exclusive-open only if this is the first open.
	 */
	omode = (cp->asfd > 0)? O_RDWR : (O_RDWR|O_EXCL);
	(void) strcpy(fname, "/as");
	if ((fd = open(procname, omode, 0)) < 0 ||
	    (cp->asfd = Dupfd(fd, cp->asfd)) < 0)
		goto err;

	(void) strcpy(fname, "/ctl");
	if ((fd = open(procname, O_WRONLY, 0)) < 0 ||
	    (cp->ctlfd = Dupfd(fd, cp->ctlfd)) < 0)
		goto err;

	(void) strcpy(fname, "/status");
	if ((fd = open(procname, O_RDONLY, 0)) < 0 ||
	    (cp->statusfd = Dupfd(fd, cp->statusfd)) < 0)
		goto err;

	return (0);

err:
	CloseProc(cp);
	return (-1);
}

/*
 * Close the /proc/<pid> files.
 */
static void
CloseProc(cstatus_t *cp)
{
	if (cp->asfd > 0)
		(void) close(cp->asfd);
	if (cp->ctlfd > 0)
		(void) close(cp->ctlfd);
	if (cp->statusfd > 0)
		(void) close(cp->statusfd);
	cp->asfd = 0;
	cp->ctlfd = 0;
	cp->statusfd = 0;
}

/*
 * Take control of a child process.
 */
static cstatus_t *
GrabProc(pid_t pid)
{
	cstatus_t *cp;
	long ctl[2];
	pid_t ppid;

	if (pid <= 0)
		return (NULLCP);

	if ((cp = FindProc(pid)) != NULLCP)	/* already grabbed */
		return (cp);

	CheckAllProcs();	/* clean up before grabbing new process */

	cp = (cstatus_t *)malloc(sizeof (cstatus_t));
	if (cp == NULLCP)
		return (NULLCP);
	(void) memset((char *)cp, 0, sizeof (cstatus_t));
	cp->pid = pid;

	ppid = getpid();
	while (OpenProc(cp) == 0) {
		ctl[0] = PCSET;
		ctl[1] = PR_RLC;
		errno = 0;

		if (pread(cp->statusfd, (char *)&cp->pstatus,
		    sizeof (cp->pstatus), (off_t)0) == sizeof (cp->pstatus) &&
		    cp->pstatus.pr_ppid == ppid &&
		    (cp->pstatus.pr_flags & PR_PTRACE) &&
		    write(cp->ctlfd, (char *)ctl, 2*sizeof (long))
		    == 2*sizeof (long)) {
			cp->next = childp;
			childp = cp;
			MakeUser(cp);
			return (cp);
		}

		if (errno != EAGAIN)
			break;
	}

	free((char *)cp);
	return (NULLCP);
}

/*
 * Close the /proc/<pid> file, if open.
 * Deallocate the memory used by the cstatus_t structure.
 */
static void
ReleaseProc(cstatus_t *cp)
{
	CloseProc(cp);

	if (childp == cp)
		childp = cp->next;
	else {
		cstatus_t *pcp;

		for (pcp = childp; pcp != NULLCP; pcp = pcp->next) {
			if (pcp->next == cp) {
				pcp->next = cp->next;
				break;
			}
		}
	}

	free((char *)cp);
}

/*
 * Update process information from /proc.
 * Return 0 on success, -1 on failure.
 */
static int
ProcUpdate(cstatus_t *cp)
{
	pstatus_t *ps = &cp->pstatus;

	if (cp->flags & CS_SETREGS) {
		long cmd;
		iovec_t iov[2];

		ps->pr_lwp.pr_reg[GS]   = cp->user.u_reg[GS];
		ps->pr_lwp.pr_reg[FS]   = cp->user.u_reg[FS];
		ps->pr_lwp.pr_reg[ES]   = cp->user.u_reg[ES];
		ps->pr_lwp.pr_reg[DS]   = cp->user.u_reg[DS];
		ps->pr_lwp.pr_reg[EDI]  = cp->user.u_reg[EDI];
		ps->pr_lwp.pr_reg[ESI]  = cp->user.u_reg[ESI];
		ps->pr_lwp.pr_reg[EBP]  = cp->user.u_reg[EBP];
		ps->pr_lwp.pr_reg[ESP]  = cp->user.u_reg[ESP];
		ps->pr_lwp.pr_reg[EBX]  = cp->user.u_reg[EBX];
		ps->pr_lwp.pr_reg[EDX]  = cp->user.u_reg[EDX];
		ps->pr_lwp.pr_reg[ECX]  = cp->user.u_reg[ECX];
		ps->pr_lwp.pr_reg[EAX]  = cp->user.u_reg[EAX];
		ps->pr_lwp.pr_reg[TRAPNO] = cp->user.u_reg[TRAPNO];
		ps->pr_lwp.pr_reg[ERR]  = cp->user.u_reg[ERR];
		ps->pr_lwp.pr_reg[EIP]  = cp->user.u_reg[EIP];
		ps->pr_lwp.pr_reg[CS]   = cp->user.u_reg[CS];
		ps->pr_lwp.pr_reg[EFL]  = cp->user.u_reg[EFL];
		ps->pr_lwp.pr_reg[UESP] = cp->user.u_reg[UESP];
		ps->pr_lwp.pr_reg[SS]   = cp->user.u_reg[SS];
		cmd = PCSREG;
		iov[0].iov_base = (caddr_t)&cmd;
		iov[0].iov_len = sizeof (long);
		iov[1].iov_base = (caddr_t)&ps->pr_lwp.pr_reg[0];
		iov[1].iov_len = sizeof (ps->pr_lwp.pr_reg);
		(void) writev(cp->ctlfd, iov, 2);
		cp->flags &= ~CS_SETREGS;
	}

	while (pread(cp->statusfd, (char *)ps, sizeof (*ps), (off_t)0) < 0) {
		/* attempt to regain control */
		if (errno != EINTR &&
		    !(errno == EAGAIN && OpenProc(cp) == 0))
			return (-1);
	}

	if (ps->pr_flags & PR_ISTOP)
		MakeUser(cp);
	else
		(void) memset((char *)ps, 0, sizeof (pstatus_t));

	return (0);
}

/*
 * Manufacture the contents of the fake u-block.
 */
static void
MakeUser(cstatus_t *cp)
{
	pstatus_t *ps = &cp->pstatus;

	cp->user.u_reg[GS]   = ps->pr_lwp.pr_reg[GS];
	cp->user.u_reg[FS]   = ps->pr_lwp.pr_reg[FS];
	cp->user.u_reg[ES]   = ps->pr_lwp.pr_reg[ES];
	cp->user.u_reg[DS]   = ps->pr_lwp.pr_reg[DS];
	cp->user.u_reg[EDI]  = ps->pr_lwp.pr_reg[EDI];
	cp->user.u_reg[ESI]  = ps->pr_lwp.pr_reg[ESI];
	cp->user.u_reg[EBP]  = ps->pr_lwp.pr_reg[EBP];
	cp->user.u_reg[ESP]  = ps->pr_lwp.pr_reg[ESP];
	cp->user.u_reg[EBX]  = ps->pr_lwp.pr_reg[EBX];
	cp->user.u_reg[EDX]  = ps->pr_lwp.pr_reg[EDX];
	cp->user.u_reg[ECX]  = ps->pr_lwp.pr_reg[ECX];
	cp->user.u_reg[EAX]  = ps->pr_lwp.pr_reg[EAX];
	cp->user.u_reg[TRAPNO] = ps->pr_lwp.pr_reg[TRAPNO];
	cp->user.u_reg[ERR]  = ps->pr_lwp.pr_reg[ERR];
	cp->user.u_reg[EIP]  = ps->pr_lwp.pr_reg[EIP];
	cp->user.u_reg[CS]   = ps->pr_lwp.pr_reg[CS];
	cp->user.u_reg[EFL]  = ps->pr_lwp.pr_reg[EFL];
	cp->user.u_reg[UESP] = ps->pr_lwp.pr_reg[UESP];
	cp->user.u_reg[SS]   = ps->pr_lwp.pr_reg[SS];
	cp->user.u_ar0 = (greg_t *)REGADDR;
	cp->user.u_code = ps->pr_lwp.pr_info.si_code;
	cp->user.u_addr = ps->pr_lwp.pr_info.si_addr;
	cp->flags &= ~(CS_PSARGS|CS_SIGNAL);
}

/*
 * Fetch the contents of u_psargs[].
 */
static void
GetPsargs(cstatus_t *cp)
{
	char procname[64];	/* /proc/<pid>/psinfo */
	int fd;

	MakeProcName(procname, cp->pid);
	(void) strcat(procname, "/psinfo");
	if ((fd = open(procname, O_RDONLY, 0)) < 0) {
		(void) memset(cp->user.u_psargs, 0, PSARGSZ);
		return;
	}
	(void) pread(fd, cp->user.u_psargs, PSARGSZ,
	    (off_t)((psinfo_t *)0)->pr_psargs);
	(void) close(fd);

	cp->flags |= CS_PSARGS;
}

/*
 * Fetch the contents of u_signal[].
 */
static void
GetSignal(cstatus_t *cp)
{
	char procname[64];	/* /proc/<pid>/sigact */
	int fd;
	struct sigaction action[MAXSIG];
	int i;

	MakeProcName(procname, cp->pid);
	(void) strcat(procname, "/sigact");
	(void) memset((char *)action, 0, sizeof (action));
	if ((fd = open(procname, O_RDONLY, 0)) >= 0) {
		(void) read(fd, (char *)action, sizeof (action));
		(void) close(fd);
	}
	for (i = 0; i < MAXSIG; i++)
		cp->user.u_signal[i] = action[i].sa_handler;
	cp->flags |= CS_SIGNAL;
}