/*

 * 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 (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;