xref: /illumos-gate/usr/src/cmd/sgs/link_audit/common/truss.c (revision 78f67f4e)

/*
 * 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) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
 */
#include <link.h>
#include <sys/types.h>
#include <sys/param.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include "env.h"
#include "mach.h"

static Elist		*bindto_list = NULL;
static Elist		*bindfrom_list = NULL;

static uint_t		pidout = 0;
static pid_t		pid;
static FILE		*outfile = stderr;
static uint_t		indent = 1;
static uint_t		indent_level = 1;
static uint_t		trussall = 0;
static uint_t		noexit = 0;
static sigset_t		iset;

/*
 * It's not possible to gather the return code on routines
 * which actually have a dependence on the 'stack frame structure'.
 * Below is a list of known symbols which have this dependency,
 * truss.so will disable the la_pltexit() entry point for these
 * routines, which will remove the requirement for the extra
 * stackframe that the link_auditing interface creates.
 *
 * NOTE: this list *must* be mainted in alphabetical order.
 *	 if this list ever became to long a faster search mechanism
 *	 should be considered.
 */
static char	*spec_sym[] = {
#if	defined(__sparc)
	".stret1",
	".stret2",
	".stret4",
	".stret8",
#endif
	"__getcontext",
	"_getcontext",
	"_getsp",
	"_longjmp",
	"_setcontext",
	"_setjmp",
	"_siglongjmp",
	"_sigsetjmp",
	"_vfork",
	"getcontext",
	"getsp",
	"longjmp",
	"setcontext",
	"setjmp",
	"siglongjmp",
	"sigsetjmp",
	"vfork",
	(char *)0
};

uint_t
la_version(uint_t version)
{
	char	*str;

	if (version > LAV_CURRENT)
		(void) fprintf(stderr, "truss.so: unexpected version: %d\n",
		    version);

	build_env_list(&bindto_list, (const char *)"TRUSS_BINDTO");
	build_env_list(&bindfrom_list, (const char *)"TRUSS_BINDFROM");

	if (checkenv((const char *)"TRUSS_PID")) {
		pidout = 1;
		pid = getpid();
	} else {
		char	*str = "LD_AUDIT=";
		/*
		 * This disables truss output in subsequent fork()/exec
		 * processes.
		 */
		(void) putenv(str);
	}

	if (checkenv((const char *)"TRUSS_NOEXIT")) {
		noexit++;
		indent = 0;
	}

	if (checkenv((const char *)"TRUSS_NOINDENT"))
		indent = 0;

	if (checkenv((const char *)"TRUSS_ALL"))
		trussall++;

	str = checkenv((const char *)"TRUSS_OUTPUT");
	if (str != NULL) {
		FILE	*fp;
		char	fname[MAXPATHLEN];

		if (pidout)
			(void) snprintf(fname, MAXPATHLEN, "%s.%d", str,
			    (int)pid);
		else
			(void) strncpy(fname, str, MAXPATHLEN);

		fp = fopen(fname, (const char *)"w");
		if (fp != NULL) {
			outfile = fp;
		} else {
			(void) fprintf(stderr,
			    "truss.so: unable to open file=`%s': %s\n",
			    fname, strerror(errno));
		}
	}

	/*
	 * Initalize iset to the full set of signals to be masked durring
	 * pltenter/pltexit
	 */
	(void) sigfillset(&iset);

	return (LAV_CURRENT);
}

/* ARGSUSED1 */
uint_t
la_objopen(Link_map *lmp, Lmid_t lmid, uintptr_t *cookie)
{
	uint_t	flags;
	char	*basename;
	static int	first = 1;

	if ((bindto_list == NULL) || (trussall))
		flags = LA_FLG_BINDTO;
	else if (check_list(bindto_list, lmp->l_name))
		flags = LA_FLG_BINDTO;
	else
		flags = 0;

	if (((bindfrom_list == NULL) && first) || trussall ||
	    (check_list(bindfrom_list, lmp->l_name)))
		flags |= LA_FLG_BINDFROM;

	first = 0;

	if (flags) {
		if ((basename = strrchr(lmp->l_name, '/')) != NULL)
			basename++;
		else
			basename = lmp->l_name;
		*cookie = (uintptr_t)basename;
	}

	return (flags);
}

/* ARGSUSED1 */
#if	defined(_LP64)
uintptr_t
la_symbind64(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcook,
    uintptr_t *defcook, uint_t *sb_flags, const char *sym_name)
#else
uintptr_t
la_symbind32(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcook,
    uintptr_t *defcook, uint_t *sb_flags)
#endif
{
#if	!defined(_LP64)
	const char	*sym_name = (const char *)symp->st_name;
#endif


	if (noexit)
		*sb_flags |= LA_SYMB_NOPLTEXIT;

	/*
	 * Check to see if this symbol is one of the 'special' symbols.
	 * If so we disable PLTEXIT calls for that symbol.
	 */
	if ((*sb_flags & LA_SYMB_NOPLTEXIT) == 0) {
		uint_t	ndx;
		char	*str;
		for (ndx = 0; (str = spec_sym[ndx]) != NULL; ndx++) {
			int	cmpval;
			cmpval = strcmp(sym_name, str);
			if (cmpval < 0)
				break;
			if (cmpval == 0) {
				*sb_flags |= LA_SYMB_NOPLTEXIT;
				break;
			}
		}
	}
	return (symp->st_value);
}

/* ARGSUSED1 */
#if	defined(__sparcv9)
uintptr_t
la_sparcv9_pltenter(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcookie,
    uintptr_t *defcookie, La_sparcv9_regs *regset, uint_t *sb_flags,
    const char *sym_name)
#elif	defined(__sparc)
uintptr_t
la_sparcv8_pltenter(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcookie,
    uintptr_t *defcookie, La_sparcv8_regs *regset, uint_t *sb_flags)
#elif   defined(__amd64)
uintptr_t
la_amd64_pltenter(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcookie,
    uintptr_t *defcookie, La_amd64_regs *regset, uint_t *sb_flags,
    const char *sym_name)
#elif   defined(__i386)
uintptr_t
la_i86_pltenter(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcookie,
    uintptr_t *defcookie, La_i86_regs *regset, uint_t *sb_flags)
#endif
{
	char		*istr;
	char		*defname = (char *)(*defcookie);
	char		*refname = (char *)(*refcookie);
#if	!defined(_LP64)
	const char	*sym_name = (const char *)symp->st_name;
#endif
	sigset_t	oset;

	(void) sigprocmask(SIG_BLOCK, &iset, &oset);

	if (pidout)
		(void) fprintf(outfile, "%5d:", (int)getpid());

	if ((*sb_flags & LA_SYMB_NOPLTEXIT) == 0)
		istr = "";
	else
		istr = "*";

	(void) fprintf(outfile, "%-15s -> %15s:%-*s%s(0x%lx, 0x%lx, 0x%lx)\n",
	    refname, defname, indent_level, istr, sym_name,
	    (long)GETARG0(regset), (long)GETARG1(regset),
	    (long)GETARG2(regset));

	(void) fflush(outfile);
	if (indent && ((*sb_flags & LA_SYMB_NOPLTEXIT) == 0))
		indent_level++;
	(void) sigprocmask(SIG_SETMASK, &oset, NULL);
	return (symp->st_value);
}

/* ARGSUSED1 */
#if	defined(_LP64)
/* ARGSUSED */
uintptr_t
la_pltexit64(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcookie,
    uintptr_t *defcookie, uintptr_t retval, const char *sym_name)
#else
uintptr_t
la_pltexit(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcookie,
    uintptr_t *defcookie, uintptr_t retval)
#endif
{
	char		*defname = (char *)(*defcookie);
	char		*refname = (char *)(*refcookie);
	sigset_t	oset;
#if	!defined(_LP64)
	const char	*sym_name = (const char *)symp->st_name;
#endif

	(void) sigprocmask(SIG_BLOCK, &iset, &oset);

	if (pidout)
		(void) fprintf(outfile, "%5d:", (int)pid);
	if (indent)
		indent_level--;
	(void) fprintf(outfile, "%-15s -> %15s:%*s%s - 0x%lx\n", refname,
	    defname, indent_level, "", sym_name, (ulong_t)retval);
	(void) fflush(outfile);
	(void) sigprocmask(SIG_SETMASK, &oset, NULL);
	return (retval);
}