cmd/truss/actions.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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1988 AT&T	*/
/*	  All Rights Reserved  	*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <memory.h>
#include <errno.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stack.h>
#include <signal.h>
#include <sys/isa_defs.h>
#include <libproc.h>
#include <priv.h>
#include "ramdata.h"
#include "systable.h"
#include "print.h"
#include "proto.h"

/*
 * Actions to take when process stops.
 */

/*
 * Function prototypes for static routines in this module.
 */
int	stopsig(private_t *);
void	showpaths(private_t *, const struct systable *);
void	showargs(private_t *, int);
void	dumpargs(private_t *, long, const char *);

/*
 * Report an lwp to be sleeping (if true).
 */
void
report_sleeping(private_t *pri, int dotrace)
{
	const lwpstatus_t *Lsp = pri->lwpstat;
	int sys = Lsp->pr_syscall;

	if (!prismember(&trace, sys) || !dotrace ||
	    !(Lsp->pr_flags & (PR_ASLEEP|PR_VFORKP))) {
		/* Make sure we catch sysexit even if we're not tracing it. */
		(void) Psysexit(Proc, sys, TRUE);
		return;
	}

	pri->length = 0;
	pri->Errno = 0;
	pri->ErrPriv = PRIV_NONE;
	pri->Rval1 = pri->Rval2 = 0;
	(void) sysentry(pri, dotrace);
	make_pname(pri, 0);
	putpname(pri);
	timestamp(pri);
	pri->length += printf("%s", pri->sys_string);
	pri->sys_leng = 0;
	*pri->sys_string = '\0';
	pri->length >>= 3;
	if (Lsp->pr_flags & PR_VFORKP)
		pri->length += 2;
	if (pri->length >= 4)
		(void) fputc(' ', stdout);
	for (; pri->length < 4; pri->length++)
		(void) fputc('\t', stdout);
	if (Lsp->pr_flags & PR_VFORKP)
		(void) fputs("(waiting for child to exit()/exec()...)\n",
		    stdout);
	else
		(void) fputs("(sleeping...)\n", stdout);
	pri->length = 0;
	if (prismember(&verbose, sys)) {
		int raw = prismember(&rawout, sys);
		pri->Errno = 1;
		expound(pri, 0, raw);
		pri->Errno = 0;
	}
	Flush();
}

/*
 * requested() gets called for these reasons:
 *	flag == JOBSIG:		report nothing; change state to JOBSTOP
 *	flag == JOBSTOP:	report "Continued ..."
 *	default:		report sleeping system call
 *
 * It returns a new flag:  JOBSTOP or SLEEPING or 0.
 */
int
requested(private_t *pri, int flag, int dotrace)
{
	const lwpstatus_t *Lsp = pri->lwpstat;
	int sig = Lsp->pr_cursig;
	int newflag = 0;

	switch (flag) {
	case JOBSIG:
		return (JOBSTOP);

	case JOBSTOP:
		if (dotrace && !cflag && prismember(&signals, sig)) {
			pri->length = 0;
			putpname(pri);
			timestamp(pri);
			(void) printf("    Continued with signal #%d, %s",
			    sig, signame(pri, sig));
			if (Lsp->pr_action.sa_handler == SIG_DFL)
				(void) printf(" [default]");
			else if (Lsp->pr_action.sa_handler == SIG_IGN)
				(void) printf(" [ignored]");
			else
				(void) printf(" [caught]");
			(void) fputc('\n', stdout);
			Flush();
		}
		newflag = 0;
		break;

	default:
		newflag = SLEEPING;
		if (!cflag)
			report_sleeping(pri, dotrace);
		break;
	}

	return (newflag);
}

int
jobcontrol(private_t *pri, int dotrace)
{
	const lwpstatus_t *Lsp = pri->lwpstat;
	int sig = stopsig(pri);

	if (sig == 0)
		return (0);

	if (dotrace && !cflag &&		/* not just counting */
	    prismember(&signals, sig)) {	/* tracing this signal */
		int sys;

		pri->length = 0;
		putpname(pri);
		timestamp(pri);
		(void) printf("    Stopped by signal #%d, %s",
		    sig, signame(pri, sig));
		if ((Lsp->pr_flags & PR_ASLEEP) &&
		    (sys = Lsp->pr_syscall) > 0 && sys <= PRMAXSYS)
			(void) printf(", in %s()",
			    sysname(pri, sys, getsubcode(pri)));
		(void) fputc('\n', stdout);
		Flush();
	}

	return (JOBSTOP);
}

/*
 * Return the signal the process stopped on iff process is already stopped on
 * PR_JOBCONTROL or is stopped on PR_SIGNALLED or PR_REQUESTED with a current
 * signal that will cause a JOBCONTROL stop when the process is set running.
 */
int
stopsig(private_t *pri)
{
	const lwpstatus_t *Lsp = pri->lwpstat;
	int sig = 0;

	if (Lsp->pr_flags & PR_STOPPED) {
		switch (Lsp->pr_why) {
		case PR_JOBCONTROL:
			sig = Lsp->pr_what;
			if (sig < 0 || sig > PRMAXSIG)
				sig = 0;
			break;
		case PR_SIGNALLED:
		case PR_REQUESTED:
			if (Lsp->pr_action.sa_handler == SIG_DFL) {
				switch (Lsp->pr_cursig) {
				case SIGSTOP:
					sig = SIGSTOP;
					break;
				case SIGTSTP:
				case SIGTTIN:
				case SIGTTOU:
					if (!(Lsp->pr_flags & PR_ORPHAN))
						sig = Lsp->pr_cursig;
					break;
				}
			}
			break;
		}
	}

	return (sig);
}

int
signalled(private_t *pri, int flag, int dotrace)
{
	const lwpstatus_t *Lsp = pri->lwpstat;
	int sig = Lsp->pr_what;

	if (sig <= 0 || sig > PRMAXSIG)	/* check bounds */
		return (0);

	if (dotrace && cflag) {			/* just counting */
		(void) mutex_lock(&count_lock);
		Cp->sigcount[sig]++;
		(void) mutex_unlock(&count_lock);
	}

	if (sig == SIGCONT && (flag == JOBSIG || flag == JOBSTOP))
		flag = requested(pri, JOBSTOP, dotrace);
	else if ((flag = jobcontrol(pri, dotrace)) == 0 &&
	    !cflag && dotrace &&
	    prismember(&signals, sig)) {
		int sys;

		pri->length = 0;
		putpname(pri);
		timestamp(pri);
		(void) printf("    Received signal #%d, %s",
		    sig, signame(pri, sig));
		if ((Lsp->pr_flags & PR_ASLEEP) &&
		    (sys = Lsp->pr_syscall) > 0 && sys <= PRMAXSYS)
			(void) printf(", in %s()",
			    sysname(pri, sys, getsubcode(pri)));
		if (Lsp->pr_action.sa_handler == SIG_DFL)
			(void) printf(" [default]");
		else if (Lsp->pr_action.sa_handler == SIG_IGN)
			(void) printf(" [ignored]");
		else
			(void) printf(" [caught]");
		(void) fputc('\n', stdout);
		if (Lsp->pr_info.si_code != 0 ||
		    Lsp->pr_info.si_pid != 0)
			print_siginfo(pri, &Lsp->pr_info);
		Flush();
	}

	if (flag == JOBSTOP)
		flag = JOBSIG;
	return (flag);
}

int
faulted(private_t *pri, int dotrace)
{
	const lwpstatus_t *Lsp = pri->lwpstat;
	int flt = Lsp->pr_what;

	if ((uint_t)flt > PRMAXFAULT || !prismember(&faults, flt) || !dotrace)
		return (0);

	(void) mutex_lock(&count_lock);
	Cp->fltcount[flt]++;
	(void) mutex_unlock(&count_lock);

	if (cflag)		/* just counting */
		return (1);

	pri->length = 0;
	putpname(pri);
	timestamp(pri);

	(void) printf("    Incurred fault #%d, %s  %%pc = 0x%.8lX",
	    flt, proc_fltname(flt, pri->flt_name, sizeof (pri->flt_name)),
	    (long)Lsp->pr_reg[R_PC]);

	if (flt == FLTPAGE)
		(void) printf("  addr = 0x%.8lX",
		    (long)Lsp->pr_info.si_addr);
	(void) fputc('\n', stdout);
	if (Lsp->pr_info.si_signo != 0)
		print_siginfo(pri, &Lsp->pr_info);
	Flush();
	return (1);
}

/*
 * Set up pri->sys_nargs and pri->sys_args[] (syscall args).
 */
void
setupsysargs(private_t *pri, int what)
{
	const lwpstatus_t *Lsp = pri->lwpstat;
	int nargs;
	int i;

#if sparc
	/* determine whether syscall is indirect */
	pri->sys_indirect = (Lsp->pr_reg[R_G1] == SYS_syscall)? 1 : 0;
#else
	pri->sys_indirect = 0;
#endif

	(void) memset(pri->sys_args, 0, sizeof (pri->sys_args));
	if (what != Lsp->pr_syscall) {	/* assertion */
		(void) printf("%s\t*** Inconsistent syscall: %d vs %d ***\n",
		    pri->pname, what, Lsp->pr_syscall);
	}
	nargs = Lsp->pr_nsysarg;
	for (i = 0;
	    i < nargs && i < sizeof (pri->sys_args) / sizeof (pri->sys_args[0]);
	    i++)
		pri->sys_args[i] = Lsp->pr_sysarg[i];
	pri->sys_nargs = nargs;
}

#define	ISREAD(code) \
	((code) == SYS_read || (code) == SYS_pread || \
	(code) == SYS_pread64 || (code) == SYS_readv || \
	(code) == SYS_recv || (code) == SYS_recvfrom)
#define	ISWRITE(code) \
	((code) == SYS_write || (code) == SYS_pwrite || \
	(code) == SYS_pwrite64 || (code) == SYS_writev || \
	(code) == SYS_send || (code) == SYS_sendto)

/*
 * Return TRUE iff syscall is being traced.
 */
int
sysentry(private_t *pri, int dotrace)
{
	pid_t pid = Pstatus(Proc)->pr_pid;
	const lwpstatus_t *Lsp = pri->lwpstat;
	long arg;
	int nargs;
	int i;
	int x;
	int len;
	char *s;
	const struct systable *stp;
	int what = Lsp->pr_what;
	int subcode;
	int istraced;
	int raw;

	/* for reporting sleeping system calls */
	if (what == 0 && (Lsp->pr_flags & (PR_ASLEEP|PR_VFORKP)))
		what = Lsp->pr_syscall;

	/* protect ourself from operating system error */
	if (what <= 0 || what > PRMAXSYS)
		what = 0;

	/*
	 * Set up the system call arguments (pri->sys_nargs & pri->sys_args[]).
	 */
	setupsysargs(pri, what);
	nargs = pri->sys_nargs;

	/* get systable entry for this syscall */
	subcode = getsubcode(pri);
	stp = subsys(what, subcode);

	if (nargs > stp->nargs)
		nargs = stp->nargs;
	pri->sys_nargs = nargs;

	/*
	 * Fetch and remember first argument if it's a string,
	 * or second argument if SYS_openat or SYS_openat64.
	 */
	pri->sys_valid = FALSE;
	if ((nargs > 0 && stp->arg[0] == STG) ||
	    (nargs > 1 && (what == SYS_openat || what == SYS_openat64))) {
		long offset;
		uint32_t offset32;

		/*
		 * Special case for exit from exec().
		 * The address in pri->sys_args[0] refers to the old process
		 * image.  We must fetch the string from the new image.
		 */
		if (Lsp->pr_why == PR_SYSEXIT && what == SYS_execve) {
			psinfo_t psinfo;
			long argv;
			auxv_t auxv[32];
			int naux;

			offset = 0;
			naux = proc_get_auxv(pid, auxv, 32);
			for (i = 0; i < naux; i++) {
				if (auxv[i].a_type == AT_SUN_EXECNAME) {
					offset = (long)auxv[i].a_un.a_ptr;
					break;
				}
			}
			if (offset == 0 &&
			    proc_get_psinfo(pid, &psinfo) == 0) {
				argv = (long)psinfo.pr_argv;
				if (data_model == PR_MODEL_LP64)
					(void) Pread(Proc, &offset,
					    sizeof (offset), argv);
				else {
					offset32 = 0;
					(void) Pread(Proc, &offset32,
					    sizeof (offset32), argv);
					offset = offset32;
				}
			}
		} else if (stp->arg[0] == STG) {
			offset = pri->sys_args[0];
		} else {
			offset = pri->sys_args[1];
		}
		if ((s = fetchstring(pri, offset, PATH_MAX)) != NULL) {
			pri->sys_valid = TRUE;
			len = strlen(s);
			/* reallocate if necessary */
			while (len >= pri->sys_psize) {
				free(pri->sys_path);
				pri->sys_path = my_malloc(pri->sys_psize *= 2,
				    "pathname buffer");
			}
			(void) strcpy(pri->sys_path, s); /* remember pathname */
		}
	}

	istraced = dotrace && prismember(&trace, what);
	raw = prismember(&rawout, what);

	/* force tracing of read/write buffer dump syscalls */
	if (!istraced && nargs > 2) {
		int fdp1 = (int)pri->sys_args[0] + 1;

		if (ISREAD(what)) {
			if (prismember(&readfd, fdp1))
				istraced = TRUE;
		} else if (ISWRITE(what)) {
			if (prismember(&writefd, fdp1))
				istraced = TRUE;
		}
	}

	pri->sys_leng = 0;
	if (cflag || !istraced)		/* just counting */
		*pri->sys_string = 0;
	else {
		int argprinted = FALSE;
		const char *name;

		name = sysname(pri, what, raw? -1 : subcode);
		grow(pri, strlen(name) + 1);
		pri->sys_leng = snprintf(pri->sys_string, pri->sys_ssize,
		    "%s(", name);
		for (i = 0; i < nargs; i++) {
			arg = pri->sys_args[i];
			x = stp->arg[i];

			if (!raw && pri->sys_valid &&
			    ((i == 0 && x == STG) ||
			    (i == 1 && (what == SYS_openat ||
			    what == SYS_openat64)))) {	/* already fetched */
				escape_string(pri, pri->sys_path);
				argprinted = TRUE;
			} else if (x != HID || raw) {
				if (argprinted)
					outstring(pri, ", ");
				if (x == LLO)
					(*Print[x])(pri, raw, arg,
					    pri->sys_args[++i]);
				else
					(*Print[x])(pri, raw, arg);
				/*
				 * if nothing printed, then don't print ", "
				 */
				if (x == NOV)
					argprinted = FALSE;
				else
					argprinted = TRUE;
			}
		}
		outstring(pri, ")");
	}

	return (istraced);
}
#undef	ISREAD
#undef	ISWRITE

/*
 * sysexit() returns non-zero if anything was printed.
 */
int
sysexit(private_t *pri, int dotrace)
{
	const lwpstatus_t *Lsp = pri->lwpstat;
	int what = Lsp->pr_what;
	struct syscount *scp;
	const struct systable *stp;
	int subcode;
	int istraced;
	int raw;

	/* protect ourself from operating system error */
	if (what <= 0 || what > PRMAXSYS)
		return (0);

	/*
	 * If we aren't supposed to be tracing this one, then
	 * delete it from the traced signal set.  We got here
	 * because the process was sleeping in an untraced syscall.
	 */
	if (!prismember(&traceeven, what)) {
		(void) Psysexit(Proc, what, FALSE);
		return (0);
	}

	/* pick up registers & set pri->Errno before anything else */
	pri->Errno = Lsp->pr_errno;
	pri->ErrPriv = Lsp->pr_errpriv;
	pri->Rval1 = Lsp->pr_rval1;
	pri->Rval2 = Lsp->pr_rval2;

	switch (what) {
	case SYS_exit:		/* these are traced on entry */
	case SYS_lwp_exit:
	case SYS_context:
		istraced = dotrace && prismember(&trace, what);
		break;
	case SYS_execve:	/* this is normally traced on entry */
		istraced = dotrace && prismember(&trace, what);
		if (pri->exec_string && *pri->exec_string) {
			if (!cflag && istraced) { /* print exec() string now */
				if (pri->exec_pname[0] != '\0')
					(void) fputs(pri->exec_pname, stdout);
				timestamp(pri);
				(void) fputs(pri->exec_string, stdout);
			}
			pri->exec_pname[0] = '\0';
			pri->exec_string[0] = '\0';
			break;
		}
		/* FALLTHROUGH */
	default:
		/* we called sysentry() in main() for these */
		if (what == SYS_openat || what == SYS_openat64 ||
		    what == SYS_open || what == SYS_open64)
			istraced = dotrace && prismember(&trace, what);
		else
			istraced = sysentry(pri, dotrace) && dotrace;
		pri->length = 0;
		if (!cflag && istraced) {
			putpname(pri);
			timestamp(pri);
			pri->length += printf("%s", pri->sys_string);
		}
		pri->sys_leng = 0;
		*pri->sys_string = '\0';
		break;
	}

	/* get systable entry for this syscall */
	subcode = getsubcode(pri);
	stp = subsys(what, subcode);

	if (cflag && istraced) {
		(void) mutex_lock(&count_lock);
		scp = Cp->syscount[what];
		if (what == SYS_forksys && subcode >= 3)
			scp += subcode - 3;
		else if (subcode != -1 &&
		    (what != SYS_openat && what != SYS_openat64 &&
		    what != SYS_open && what != SYS_open64 &&
		    what != SYS_lwp_create))
			scp += subcode;
		scp->count++;
		accumulate(&scp->stime, &Lsp->pr_stime, &pri->syslast);
		accumulate(&Cp->usrtotal, &Lsp->pr_utime, &pri->usrlast);
		pri->syslast = Lsp->pr_stime;
		pri->usrlast = Lsp->pr_utime;
		(void) mutex_unlock(&count_lock);
	}

	raw = prismember(&rawout, what);

	if (!cflag && istraced) {
		if ((what == SYS_vfork || what == SYS_forksys) &&
		    pri->Errno == 0 && pri->Rval2 != 0) {
			pri->length &= ~07;
			if (strlen(sysname(pri, what, raw? -1 : subcode)) < 6) {
				(void) fputc('\t', stdout);
				pri->length += 8;
			}
			pri->length +=
			    7 + printf("\t(returning as child ...)");
		}
		if (what == SYS_lwp_create &&
		    pri->Errno == 0 && pri->Rval1 == 0) {
			pri->length &= ~07;
			pri->length +=
			    7 + printf("\t(returning as new lwp ...)");
		}
		if (pri->Errno != 0 || what != SYS_execve) {
			/* prepare to print the return code */
			pri->length >>= 3;
			if (pri->length >= 6)
				(void) fputc(' ', stdout);
			for (; pri->length < 6; pri->length++)
				(void) fputc('\t', stdout);
		}
	}
	pri->length = 0;

	if (pri->Errno != 0) {		/* error in syscall */
		if (istraced) {
			if (cflag)
				scp->error++;
			else {
				const char *ename = errname(pri->Errno);
				const char *privname;

				(void) printf("Err#%d", pri->Errno);
				if (ename != NULL) {
					(void) fputc(' ', stdout);
					(void) fputs(ename, stdout);
				}
				switch (pri->ErrPriv) {
				case PRIV_NONE:
					privname = NULL;
					break;
				case PRIV_ALL:
					privname = "ALL";
					break;
				case PRIV_MULTIPLE:
					privname = "MULTIPLE";
					break;
				case PRIV_ALLZONE:
					privname = "ZONE";
					break;
				default:
					privname = priv_getbynum(pri->ErrPriv);
					break;
				}
				if (privname != NULL)
					(void) printf(" [%s]", privname);

				(void) fputc('\n', stdout);
			}
		}
	} else {
		/* show arguments on successful exec */
		if (what == SYS_execve) {
			if (!cflag && istraced)
				showargs(pri, raw);
		} else if (!cflag && istraced) {
			const char *fmt = NULL;
			long rv1 = pri->Rval1;
			long rv2 = pri->Rval2;

#ifdef _LP64
			/*
			 * 32-bit system calls return 32-bit values. We
			 * later mask out the upper bits if we want to
			 * print these as unsigned values.
			 */
			if (data_model == PR_MODEL_ILP32) {
				rv1 = (int)rv1;
				rv2 = (int)rv2;
			}
#endif

			switch (what) {
			case SYS_llseek:
				rv1 &= 0xffffffff;
				rv2 &= 0xffffffff;
#ifdef _LONG_LONG_LTOH	/* first long of a longlong is the low order */
				if (rv2 != 0) {
					long temp = rv1;
					fmt = "= 0x%lX%.8lX";
					rv1 = rv2;
					rv2 = temp;
					break;
				}
#else	/* the other way around */
				if (rv1 != 0) {
					fmt = "= 0x%lX%.8lX";
					break;
				}
				rv1 = rv2;	/* ugly */
#endif
				/* FALLTHROUGH */
			case SYS_lseek:
			case SYS_ulimit:
				if (rv1 & 0xff000000) {
#ifdef _LP64
					if (data_model == PR_MODEL_ILP32)
						rv1 &= 0xffffffff;
#endif
					fmt = "= 0x%.8lX";
				}
				break;
			case SYS_sigtimedwait:
				if (raw)
					/* EMPTY */;
				else if ((fmt = rawsigname(pri, rv1)) != NULL) {
					rv1 = (long)fmt;	/* filthy */
					fmt = "= %s";
				}
				break;
			case SYS_port:
#ifdef _LP64
				if (data_model == PR_MODEL_LP64) {
					rv2 = rv1 & 0xffffffff;
					rv1 = rv1 >> 32;
				}
#endif
				break;
			}

			if (fmt == NULL) {
				switch (stp->rval[0]) {
				case HEX:
#ifdef _LP64
					if (data_model == PR_MODEL_ILP32)
						rv1 &= 0xffffffff;
#endif
					fmt = "= 0x%.8lX";
					break;
				case HHX:
#ifdef _LP64
					if (data_model == PR_MODEL_ILP32)
						rv1 &= 0xffffffff;
#endif
					fmt = "= 0x%.4lX";
					break;
				case OCT:
#ifdef _LP64
					if (data_model == PR_MODEL_ILP32)
						rv1 &= 0xffffffff;
#endif
					fmt = "= %#lo";
					break;
				case UNS:
#ifdef _LP64
					if (data_model == PR_MODEL_ILP32)
						rv1 &= 0xffffffff;
#endif
					fmt = "= %lu";
					break;
				default:
					fmt = "= %ld";
					break;
				}
			}

			(void) printf(fmt, rv1, rv2);

			switch (stp->rval[1]) {
			case NOV:
				fmt = NULL;
				break;
			case HEX:
#ifdef _LP64
				if (data_model == PR_MODEL_ILP32)
					rv2 &= 0xffffffff;
#endif
				fmt = " [0x%.8lX]";
				break;
			case HHX:
#ifdef _LP64
				if (data_model == PR_MODEL_ILP32)
					rv2 &= 0xffffffff;
#endif
				fmt = " [0x%.4lX]";
				break;
			case OCT:
#ifdef _LP64
				if (data_model == PR_MODEL_ILP32)
					rv2 &= 0xffffffff;
#endif
				fmt = " [%#lo]";
				break;
			case UNS:
#ifdef _LP64
				if (data_model == PR_MODEL_ILP32)
					rv2 &= 0xffffffff;
#endif
				fmt = " [%lu]";
				break;
			default:
				fmt = " [%ld]";
				break;
			}

			if (fmt != NULL)
				(void) printf(fmt, rv2);
			(void) fputc('\n', stdout);
		}

		if (what == SYS_vfork || what == SYS_forksys) {
			if (pri->Rval2 == 0)		/* child was created */
				pri->child = pri->Rval1;
			else if (cflag && istraced)	/* this is the child */
				scp->count--;
		}
		if (what == SYS_lwp_create && pri->Rval1 == 0 &&
		    cflag && istraced)		/* this is the created lwp */
			scp->count--;
	}

#define	ISREAD(code) \
	((code) == SYS_read || (code) == SYS_pread || (code) == SYS_pread64 || \
	(code) == SYS_recv || (code) == SYS_recvfrom)
#define	ISWRITE(code) \
	((code) == SYS_write || (code) == SYS_pwrite || \
	(code) == SYS_pwrite64 || (code) == SYS_send || (code) == SYS_sendto)

	if (!cflag && istraced) {
		int fdp1 = (int)pri->sys_args[0] + 1; /* filedescriptor + 1 */

		if (raw) {
			if (what != SYS_execve)
				showpaths(pri, stp);
			if (ISREAD(what) || ISWRITE(what)) {
				if (pri->iob_buf[0] != '\0')
					(void) printf("%s     0x%.8lX: %s\n",
					    pri->pname, pri->sys_args[1],
					    pri->iob_buf);
			}
		}

		/*
		 * Show buffer contents for read()/pread() or write()/pwrite().
		 * IOBSIZE bytes have already been shown;
		 * don't show them again unless there's more.
		 */
		if ((ISREAD(what) && pri->Errno == 0 &&
		    prismember(&readfd, fdp1)) ||
		    (ISWRITE(what) && prismember(&writefd, fdp1))) {
			long nb = ISWRITE(what) ? pri->sys_args[2] : pri->Rval1;

			if (nb > IOBSIZE) {
				/* enter region of lengthy output */
				if (nb > MYBUFSIZ / 4)
					Eserialize();

				showbuffer(pri, pri->sys_args[1], nb);

				/* exit region of lengthy output */
				if (nb > MYBUFSIZ / 4)
					Xserialize();
			}
		}
#undef	ISREAD
#undef	ISWRITE
		/*
		 * Do verbose interpretation if requested.
		 * If buffer contents for read or write have been requested and
		 * this is a readv() or writev(), force verbose interpretation.
		 */
		if (prismember(&verbose, what) ||
		    ((what == SYS_readv || what == SYS_recvmsg) &&
		    pri->Errno == 0 && prismember(&readfd, fdp1)) ||
		    ((what == SYS_writev || what == SYS_sendfilev ||
		    what == SYS_sendmsg) &&
		    prismember(&writefd, fdp1)))
			expound(pri, pri->Rval1, raw);
	}

	return (!cflag && istraced);
}

void
showpaths(private_t *pri, const struct systable *stp)
{
	int what = pri->lwpstat->pr_what;
	int i;

	for (i = 0; i < pri->sys_nargs; i++) {
		if (stp->arg[i] == ATC && (int)pri->sys_args[i] == AT_FDCWD) {
			(void) printf("%s     0x%.8X: AT_FDCWD\n",
			    pri->pname, AT_FDCWD);
		} else if ((stp->arg[i] == STG) ||
		    (stp->arg[i] == RST && !pri->Errno) ||
		    (stp->arg[i] == RLK && !pri->Errno && pri->Rval1 > 0)) {
			long addr = pri->sys_args[i];
			int maxleng =
			    (stp->arg[i] == RLK)? (int)pri->Rval1 : PATH_MAX;
			char *s;

			if (pri->sys_valid &&
			    ((i == 0 && stp->arg[0] == STG) ||
			    (i == 1 && (what == SYS_openat ||
			    what == SYS_openat64))))	/* already fetched */
				s = pri->sys_path;
			else
				s = fetchstring(pri, addr,
				    maxleng > PATH_MAX ? PATH_MAX : maxleng);

			if (s != (char *)NULL)
				(void) printf("%s     0x%.8lX: \"%s\"\n",
				    pri->pname, addr, s);
		}
	}
}

/*
 * Display arguments to successful exec().
 */
void
showargs(private_t *pri, int raw)
{
	const lwpstatus_t *Lsp = pri->lwpstat;
	int nargs;
	long ap;
	int ptrsize;
	int fail;

	pri->length = 0;
	ptrsize = (data_model == PR_MODEL_LP64)? 8 : 4;

#if defined(__i386) || defined(__amd64)	/* XX64 */
	ap = (long)Lsp->pr_reg[R_SP];
	fail = (Pread(Proc, &nargs, sizeof (nargs), ap) != sizeof (nargs));
	ap += ptrsize;
#endif /* i386 */

#if sparc
	if (data_model == PR_MODEL_LP64) {
		int64_t xnargs;
		ap = (long)(Lsp->pr_reg[R_SP]) + 16 * sizeof (int64_t)
		    + STACK_BIAS;
		fail = (Pread(Proc, &xnargs, sizeof (xnargs), ap) !=
		    sizeof (xnargs));
		nargs = (int)xnargs;
	} else {
		ap = (long)(Lsp->pr_reg[R_SP]) + 16 * sizeof (int32_t);
		fail = (Pread(Proc, &nargs, sizeof (nargs), ap) !=
		    sizeof (nargs));
	}
	ap += ptrsize;
#endif /* sparc */

	if (fail) {
		(void) printf("\n%s\t*** Bad argument list? ***\n", pri->pname);
		return;
	}

	(void) printf("  argc = %d\n", nargs);
	if (raw)
		showpaths(pri, &systable[SYS_execve]);

	show_cred(pri, FALSE);

	if (aflag || eflag) {		/* dump args or environment */

		/* enter region of (potentially) lengthy output */
		Eserialize();

		if (aflag)		/* dump the argument list */
			dumpargs(pri, ap, "argv:");
		ap += (nargs+1) * ptrsize;
		if (eflag)		/* dump the environment */
			dumpargs(pri, ap, "envp:");

		/* exit region of lengthy output */
		Xserialize();
	}
}

void
dumpargs(private_t *pri, long ap, const char *str)
{
	char *string;
	unsigned int leng = 0;
	int ptrsize;
	long arg = 0;
	char *argaddr;
	char badaddr[32];

	if (interrupt)
		return;

#ifdef _LP64
	if (data_model == PR_MODEL_LP64) {
		argaddr = (char *)&arg;
		ptrsize = 8;
	} else {
#if defined(_LITTLE_ENDIAN)
		argaddr = (char *)&arg;
#else
		argaddr = (char *)&arg + 4;
#endif
		ptrsize = 4;
	}
#else
	argaddr = (char *)&arg;
	ptrsize = 4;
#endif
	putpname(pri);
	(void) fputc(' ', stdout);
	(void) fputs(str, stdout);
	leng += 1 + strlen(str);

	while (!interrupt) {
		if (Pread(Proc, argaddr, ptrsize, ap) != ptrsize) {
			(void) printf("\n%s\t*** Bad argument list? ***\n",
			    pri->pname);
			return;
		}
		ap += ptrsize;

		if (arg == 0)
			break;
		string = fetchstring(pri, arg, PATH_MAX);
		if (string == NULL) {
			(void) sprintf(badaddr, "BadAddress:0x%.8lX", arg);
			string = badaddr;
		}
		if ((leng += strlen(string)) < 63) {
			(void) fputc(' ', stdout);
			leng++;
		} else {
			(void) fputc('\n', stdout);
			leng = 0;
			putpname(pri);
			(void) fputs("  ", stdout);
			leng += 2 + strlen(string);
		}
		(void) fputs(string, stdout);
	}
	(void) fputc('\n', stdout);
}

/*
 * Display contents of read() or write() buffer.
 */
void
showbuffer(private_t *pri, long offset, long count)
{
	char buffer[320];
	int nbytes;
	char *buf;
	int n;

	while (count > 0 && !interrupt) {
		nbytes = (count < sizeof (buffer))? count : sizeof (buffer);
		if ((nbytes = Pread(Proc, buffer, nbytes, offset)) <= 0)
			break;
		count -= nbytes;
		offset += nbytes;
		buf = buffer;
		while (nbytes > 0 && !interrupt) {
			char obuf[65];

			n = (nbytes < 32)? nbytes : 32;
			showbytes(buf, n, obuf);

			putpname(pri);
			(void) fputs("  ", stdout);
			(void) fputs(obuf, stdout);
			(void) fputc('\n', stdout);
			nbytes -= n;
			buf += n;
		}
	}
}

void
showbytes(const char *buf, int n, char *obuf)
{
	int c;

	while (--n >= 0) {
		int c1 = '\\';
		int c2;

		switch (c = (*buf++ & 0xff)) {
		case '\0':
			c2 = '0';
			break;
		case '\b':
			c2 = 'b';
			break;
		case '\t':
			c2 = 't';
			break;
		case '\n':
			c2 = 'n';
			break;
		case '\v':
			c2 = 'v';
			break;
		case '\f':
			c2 = 'f';
			break;
		case '\r':
			c2 = 'r';
			break;
		default:
			if (isprint(c)) {
				c1 = ' ';
				c2 = c;
			} else {
				c1 = c>>4;
				c1 += (c1 < 10)? '0' : 'A'-10;
				c2 = c&0xf;
				c2 += (c2 < 10)? '0' : 'A'-10;
			}
			break;
		}
		*obuf++ = (char)c1;
		*obuf++ = (char)c2;
	}

	*obuf = '\0';
}