usr/src/lib/libtnfprobe/probe_cntl.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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * Includes
 */

#ifndef DEBUG
#define	NDEBUG	1
#endif

#include <thread.h>
#include <pthread.h>
#include <sys/lwp.h>
#include <synch.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <errno.h>
#ifdef sparc
#include <setjmp.h>
#endif /* sparc */

#include "tnf_trace.h"

/*
 * Typedefs
 */

typedef tnf_ops_t *(*tnf_context_t)(void);

typedef void * (*start_func_t)(void *arg);

typedef int (*tnf_thr_create_func_t)(void		*stk,
				size_t			stksize,
				start_func_t		startfunc,
				void			*arg,
				long			flags,
				thread_t		*newthread);

typedef int (*tnf_pthread_create_func_t)(pthread_t	*thr,
				const pthread_attr_t	*attr,
				start_func_t		startfunc,
				void *			arg);

typedef void (*tnf_thr_exit_func_t)(void *) __NORETURN;

typedef void (*tnf_pthread_exit_func_t)(void *) __NORETURN;

typedef pid_t (*fork_t)(void);

typedef int (*tnf_thr_stksegment_func_t)(stack_t *s);

typedef struct args {
	start_func_t		real_func;
	void 			*real_arg;
} args_t;

/*
 * Local Declarations
 */

static void * tnf_threaded_test(void 			*dummy,
				tnf_probe_control_t 	*probe_p,
				tnf_probe_setup_t 	*set_p);
static void * tnf_non_threaded_test(void 			*dummy,
					tnf_probe_control_t	*probe_p,
					tnf_probe_setup_t	*set_p);
static tnf_ops_t *tnf_probe_getfunc(void);
static void *probestart(void *arg);
static pid_t common_fork(fork_t real_fork);
static void probe_setup(void *data);
static tnf_ops_t *tnf_get_ops();

/*
 * Static Globals
 */

extern tnf_ops_t 	tnf_trace_initial_tpd;
static void 		*tpd = &tnf_trace_initial_tpd;
#ifdef sparc
static size_t		tnf_probe_dsize = 0;
#endif /* sparc */

/*
 * Project Private interfaces:
 * 	These are interfaces between prex and libtnfw, or
 * 	between libtnfw and libtthread.
 */

/* variable indicates if libtnfw has sync'ed up with libthread or not */
long			__tnf_probe_thr_sync		= 0;

/* head of the list that is used to chain all probes */
tnf_probe_control_t	*__tnf_probe_list_head		= NULL;
int			__tnf_probe_list_valid		= 0;

/* notify function that libthread calls after primordial thread is created */
void __tnf_probe_notify(void);

tnf_probe_test_func_t tnf_threaded_test_addr = tnf_threaded_test;
tnf_probe_test_func_t tnf_non_threaded_test_addr = tnf_non_threaded_test;


/*
 * Externs
 */
#pragma weak thr_probe_getfunc_addr
extern tnf_context_t	thr_probe_getfunc_addr;

#pragma weak thr_probe_setup
extern void thr_probe_setup(void *);

/* ---------------------------------------------------------------- */
/* ----------------------- Public Functions ----------------------- */
/* ---------------------------------------------------------------- */

/*
 * probe_setup() - the thread probe setup function for the non-threaded
 * case.
 */
static void
probe_setup(void *data)
{
#ifdef DEBUG
	/* #### - TEMPORARY */
	fprintf(stderr, "probe_setup: \n");
#endif
	tpd = data;

}   /* end probe_setup */

/*
 * __tnf_probe_notify() - libthread calls this function to notify us
 * that the primordial thread has been created.
 */

void
__tnf_probe_notify(void)
{
	tnf_probe_control_t		*prbctl_p;
	tnf_probe_test_func_t		test_func;

	/* paranoia: thr_probe_setup should be defined */
	assert(thr_probe_setup != 0);
	if (thr_probe_setup != 0) thr_probe_setup(tpd);

	/*
	 * no race with prex if we set flag first
	 *		- this is an idempotent operation
	 */
	__tnf_probe_thr_sync = 1;

#ifdef DEBUG
	{
		char tmp_buf[512];
		(void) sprintf(tmp_buf, "__tnf_probe_notify: \n");
		(void) write(2, tmp_buf, strlen(tmp_buf));
	}
#endif
	/*
	 * Use dlsym to test for the present of "thr_probe_getfunc_addr" .
	 */

	test_func = (((int(*)())dlsym(RTLD_DEFAULT,
		"thr_probe_getfunc_addr")) != NULL) ? tnf_threaded_test : 0;

	assert(test_func);

	/*
	 * I think in this case that we do not need to check the
	 * __tnf_probe_list_valid flag since __tnf_probe_notify is
	 * called very early.
	 */

	/* replace all existing test functions with libthread's test func */
	for (prbctl_p = __tnf_probe_list_head; prbctl_p;
					prbctl_p = prbctl_p->next)
		if (prbctl_p->test_func)
			prbctl_p->test_func = test_func;

	return;

}   /* end __tnf_probe_notify */

/*
 * _tnf_fork_thread_setup - function called by buffering layer
 * whenever it finds a thread in the newly forked process that
 * hasn't been re-initialized in this process.
 */
void
_tnf_fork_thread_setup(void)
{
	tnf_ops_t	*ops;

#ifdef DEBUGFUNCS
	{
		char tmp_buf[512];
		(void) sprintf(tmp_buf, "in _tnf_fork_thread_setup: \n");
		(void) write(2, tmp_buf, strlen(tmp_buf));
	}
#endif
	/* get the tpd */
	ops = tnf_get_ops();
	if (!ops)
		return;
	/* null out tag_index, so that a new one is initialized and written */
	ops->schedule.record_p = 0;
	return;

}

/* ---------------------------------------------------------------- */
/* ---------------------- Interposed Functions -------------------- */
/* ---------------------------------------------------------------- */

/*
 * thr_create() - this function is interposed in front of the
 * actual thread create function in libthread.
 */

int
thr_create(void 		*stk,
	size_t		stksize,
	void *		(*real_func)(void *),
	void		*real_arg,
	long		flags,
	thread_t	*new_thread)
{
	static tnf_thr_create_func_t real_thr_create = NULL;
	args_t *arg_p;

#ifdef VERYVERBOSE
	fprintf(stderr, "hello from the interposed thr_create parent\n");
#endif

	/* use dlsym to find the address of the "real" thr_create function */
	if (real_thr_create == NULL) {
		real_thr_create = (tnf_thr_create_func_t)
					dlsym(RTLD_NEXT, "thr_create");
	}
	assert(real_thr_create);

	/* set up the interposed argument block */
	arg_p = (args_t *)malloc(sizeof (args_t));
	assert(arg_p);
	arg_p->real_func = real_func;
	arg_p->real_arg  = real_arg;

	return ((*real_thr_create)(stk, stksize, probestart, (void *) arg_p,
					flags, new_thread));

}   /* end thr_create */


int
pthread_create(pthread_t *new_thread_id,
	const pthread_attr_t *attr,
	void *		(*real_func)(void *),
	void		*real_arg)
{
	static tnf_pthread_create_func_t real_pthread_create = NULL;
	args_t *arg_p;

#ifdef VERYVERBOSE
	fprintf(stderr, "hello from the interposed pthread_create parent\n");
#endif

	/* use dlsym to find the address of the "real" pthread_create func */
	if (real_pthread_create == NULL) {
		real_pthread_create = (tnf_pthread_create_func_t)
					dlsym(RTLD_NEXT, "pthread_create");
	}
	assert(real_pthread_create);

	/* set up the interposed argument block */
	arg_p = (args_t *)malloc(sizeof (args_t));
	assert(arg_p);
	arg_p->real_func = real_func;
	arg_p->real_arg  = real_arg;

	return ((*real_pthread_create)(new_thread_id, attr, probestart,
			(void *) arg_p));

}   /* end pthread_create */

void
thr_exit(void * status)
{
	static tnf_thr_exit_func_t real_thr_exit = NULL;
	/* use dlsym to find the address of the "real" pthread_create func */
	if (real_thr_exit == NULL) {
		real_thr_exit = (tnf_thr_exit_func_t)
		dlsym(RTLD_NEXT, "thr_exit");
	}
	assert(real_thr_exit);


	/*
	 * Calling tnf_thread_disable() whenever a thread exits...
	 * This has the side-effect of unlocking our currently
	 * locked block in the trace buffer.  This keeps a dying
	 * thread from taking a block with it when it dies, but
	 * it means that we won't be able to trace events from
	 * the thread-specific data destructors.  We will lose
	 * out on any events a thread spits out AFTER is calls thr_exit().
	 * This code was added to fix a bug where tracing breaks when trying
	 * to trace a program with large numbers of thread-ids.
	 *
	 * Addendum:
	 * Now you can't get events for thr_exit using an interposition library.
	 * Since thr_exit is a really helpful event, this is a problem.
	 * Also, breaking this interposition will probably break
	 * BAT, the DevPro TNF perf tool.
	 *
	 * Addendum:
	 * Correction:  You can get interposition events if the interposition
	 * library comes BEFORE libtnfprobe.so.  But not, if the interp.
	 * library comes AFTER libtnfprobe.so.  This is a more difficult
	 * constraint that it might sound like because of the following:
	 * The tnfctl functional interface and the prex command line
	 * interface provide convenience features where you can supply
	 * a character string argument which will be put into LD_PRELOAD
	 * for you.  Unfortunately, this string gets appended AFTER
	 * libtnfprobe.so by the tnfctl library(and also hence by the
	 * prex -l option).
	 * Luckily, when libtnfprobe is added by the tnfctl library, it is
	 * added AFTER an existing contents of the LD_PRELOAD variable.
	 *
	 * Therefore, if you are using an interposition library to collect
	 * thr_exit and pthread_exit events, THEN you should NOT use 'prex -l'
	 * or the 'ld_preload' argument to tnfctl_exec_open(), instead, you
	 * should be sure to put the interposition library into the LD_PRELOAD
	 * variable yourself.
	 *
	 */

	tnf_thread_disable();

	((*real_thr_exit)(status));
}

void
pthread_exit(void * status)
{
	static tnf_pthread_exit_func_t real_pthread_exit = NULL;
	/* use dlsym to find the address of the "real" pthread_create func */
	if (real_pthread_exit == NULL) {
		real_pthread_exit = (tnf_pthread_exit_func_t)
		dlsym(RTLD_NEXT, "pthread_exit");
	}
	assert(real_pthread_exit);
	/* see the comment in thr_exit about tnf_thread_disable() */
	tnf_thread_disable();
	((*real_pthread_exit)(status));
}

/*
 * function to be interposed in front of _resume.  We invalidate the
 * schedule record in case the lwpid changes the next time this
 * thread is scheduled.
 */

#pragma weak _resume_ret = _tnf_resume_ret
void
_tnf_resume_ret(void *arg1)
{
	static void (*real_resume_ret)(void *) = NULL;
	tnf_ops_t	*ops;

	if (real_resume_ret == NULL) {
		real_resume_ret = (void (*)(void *)) dlsym(RTLD_NEXT,
					"_resume_ret");
	}
	assert(real_resume_ret);

	ops = tnf_get_ops();
	if (ops) {
		/*
		 * invalidate the schedule record.  This forces it
		 * to get re-initialized with the new lwpid the next
		 * time this thread gets scheduled
		 */
		if (ops->schedule.lwpid != _lwp_self())
			ops->schedule.record_p = 0;
	}

	real_resume_ret(arg1);
}

/*
 * Functions to be interposed in front of fork and fork1.
 *
 * NOTE: we can't handle vfork, because the child would ruin the parent's
 * data structures.  We therefore don't interpose, letting the child's
 * events appear as though they were the parent's.  A slightly cleaner
 * way to handle vfork would be to interpose on vfork separately to
 * change the pid and anything else needed to show any events caused
 * by the child as its events, and then interpose on the exec's as
 * well to set things back to the way they should be for the parent.
 * But this is a lot of work, and it makes almost no difference, since the
 * child typically exec's very quickly after a vfork.
 */

#pragma weak fork = _tnf_fork
pid_t
_tnf_fork(void)
{
	static fork_t real_fork = NULL;

	if (real_fork == NULL) {
		real_fork = (fork_t)dlsym(RTLD_NEXT, "fork");
	}
	assert(real_fork);
	return (common_fork(real_fork));
}

#pragma weak fork1 = _tnf_fork1
pid_t
_tnf_fork1(void)
{
	static fork_t real_fork = NULL;

	if (real_fork == NULL) {
		real_fork = (fork_t)dlsym(RTLD_NEXT, "fork1");
	}
	assert(real_fork);
	return (common_fork(real_fork));
}

#ifdef sparc
/*
 * Function to be interposed in front of thr_stksegment
 * _tnf_thr_stksegment() - used to hide the probestart() allocated data
 * on the thread stack, ensuring that the caller receives a pointer to the
 * true bottom (ie, usable) portion of the stack, and the size thereof.
 *
 * NOTE:  On sparc systems, failure to allow for the presense of tnf data
 * on the stack would cause TNF probes to fail across doorfs calls.  The
 * i386 version of door_return decides to "skip over some slop", so no
 * interpose function is required for x86;  if the 512 byte 'slop skip'
 * is ever removed from the i386 door_return, then it will also need
 * interpose function intervention.
 *
 * Note: Instead of making this function static, we reduce it to local
 * scope in the mapfile. That allows the linker to prevent it from
 * appearing in the .SUNW_dynsymsort section.
 */
#pragma weak thr_stksegment = _tnf_thr_stksegment
int
_tnf_thr_stksegment(stack_t *s)
{
	static tnf_thr_stksegment_func_t real_thr_stksegment = NULL;
	int	err;

#ifdef VERYVERBOSE
	fprintf(stderr, "hello from the interposed thr_stksegment\n");
#endif

	if (real_thr_stksegment == NULL) {
		real_thr_stksegment = (tnf_thr_stksegment_func_t)
		    dlsym(RTLD_NEXT, "thr_stksegment");
	}
	assert(real_thr_stksegment);

	err = ((*real_thr_stksegment)(s));
	if (err == 0) {
		s->ss_sp = (void *)((caddr_t)s->ss_sp - tnf_probe_dsize);
		s->ss_size -= tnf_probe_dsize;
	}
	return (err);
}
#endif /* sparc */

/* ---------------------------------------------------------------- */
/* ----------------------- Private Functions ---------------------- */
/* ---------------------------------------------------------------- */

/*
 * tnf_probe_getfunc() - default test function if libthread is not
 * present
 */
static tnf_ops_t *
tnf_probe_getfunc(void)
{
	/* test function to be used if libthread is not linked in */
#ifdef DEBUGFUNCS
	{
		char tmp_buf[512];
		(void) sprintf(tmp_buf, "tnf_probe_getfunc: \n");
		(void) write(2, tmp_buf, strlen(tmp_buf));
	}
#endif
	return (tpd);
}   /* end tnf_probe_getfunc */


/*
 * probestart() - this function is called as the start_func by the
 * interposed thr_create() and pthread_create().  It calls the real start
 * function.
 */

static void *
probestart(void * arg)
{
	args_t 		*args_p = (args_t *)arg;
	start_func_t	real_func;
	void		*real_arg;
	tnf_ops_t	ops;		/* allocated on stack */
	void		*real_retval;

#ifdef VERYVERBOSE
	fprintf(stderr, "hello from the interposed thr_create child\n");
#endif
#ifdef sparc
	/*
	 * if the size of the probe data has not yet been calculated,
	 * initialize a jmpbuffer and calculate the amount of stack space
	 * used by probestart:  %fp - %sp from jmp_buf
	 * Not expecting anything to actually longjmp here, so that is
	 * handled as an error condition.
	 */
	if (tnf_probe_dsize == 0) {
		jmp_buf tnf_jmpbuf;
		if (setjmp(tnf_jmpbuf) != 0) {
			(void) write(2,
			    "probestart:  unexpected longjmp\n", 32);
			assert(0);
		}
		tnf_probe_dsize = (size_t)(tnf_jmpbuf[3] - tnf_jmpbuf[1]);
	}
#endif /* sparc */

	/* initialize ops */
	(void) memset(&ops, 0, sizeof (ops));	/* zero ops */
	ops.mode = TNF_ALLOC_REUSABLE;
	ops.alloc = tnfw_b_alloc;
	ops.commit = tnfw_b_xcommit;
	ops.rollback = tnfw_b_xabort;

	/* copy (and free) the allocated arg block */
	real_func = args_p->real_func;
	real_arg  = args_p->real_arg;
	free(args_p);

	/* paranoia: thr_probe_setup should be defined */
	assert(thr_probe_setup != 0);
	if (thr_probe_setup != 0) thr_probe_setup(&ops);

#ifdef VERYVERBOSE
	fprintf(stderr, "in middle of interposed start procedure\n");
#endif

	real_retval = (*real_func)(real_arg);

	/*
	 * we need to write a NULL into the tpd pointer to disable
	 * tracing for this thread.
	 * CAUTION: never make this function tail recursive because
	 * tpd is allocated on stack.
	 */

	/* This should be handled by the call to tnf_thread_disable() */
	/* if (thr_probe_setup != 0) */
	/* thr_probe_setup(NULL); */

	/* see the comment in thr_exit about tnf_thread_disable */
	tnf_thread_disable();

	return (real_retval);

}   /* end probestart */


static thread_key_t tpd_key = THR_ONCE_KEY;
static tnf_ops_t *stashed_tpd = NULL;

/*
 * tnf_thread_disable: API to disable a thread
 */
void
tnf_thread_disable(void)
{
	tnf_ops_t		*ops;

	if (thr_probe_setup != 0) {
		/* threaded client */

		/* REMIND: destructor function ? */
		(void) thr_keycreate_once(&tpd_key, NULL);
		/* get the tpd */
		ops = thr_probe_getfunc_addr();
		/* check ops to ensure function is idempotent */
		if (ops != NULL) {
			/* unlock currently held blocks */
			tnfw_b_release_block(&ops->wcb);
			/* disable the thread */
			thr_probe_setup(NULL);
			/* stash the tpd */
			(void) thr_setspecific(tpd_key, ops);
		}
	} else {
		/* non-threaded client */

		/* get the tpd */
		ops = tnf_probe_getfunc();
		if (ops != NULL) {
			/* disable the process */
			probe_setup(NULL);
			/* stash the tpd */
			stashed_tpd = ops;
		}
	}
}

/*
 * tnf_thread_enable: API to enable a thread
 */
void
tnf_thread_enable(void)
{
	tnf_ops_t *ops;

	if (thr_probe_setup != 0) {
		/* threaded client */

		ops = pthread_getspecific(tpd_key);
		if (ops)
			thr_probe_setup(ops);
	} else {
		/* non-threaded client */

		ops = stashed_tpd;
		if (ops)
			probe_setup(ops);
	}
}

/*
 * common_fork - code that is common among the interpositions of
 * fork, fork1, and vfork
 */
static pid_t
common_fork(fork_t real_fork)
{
	pid_t		 retval;
	tnf_ops_t	*ops;
	tnf_tag_data_t	*metatag_data;

#ifdef DEBUGFUNCS
	{
		char tmp_buf[512];
		(void) sprintf(tmp_buf, "in interposed fork: \n");
		(void) write(2, tmp_buf, strlen(tmp_buf));
	}
#endif
	if ((_tnfw_b_control->tnf_state == TNFW_B_NOBUFFER) &&
				(tnf_trace_file_name[0] != '\0')) {
		/*
		 * if no buffer has been allocated yet, and prex plugged in
		 * name...
		 */
		ops = tnf_get_ops();
		if (ops == NULL) {
			/*
			 * get it from stashed location
			 * don't enable thread though
			 */
			if (thr_probe_setup != 0) {
				/* threaded client */
				ops = pthread_getspecific(tpd_key);
			} else {
				/* non-threaded client */
				ops = stashed_tpd;
			}
		}

		/*
		 * ops shouldn't be NULL.  But, if it is, then we don't
		 * initialize tracing.  In the child, tracing will be
		 * set to broken.
		 */
		if (ops) {
			/* initialize tracing */
			ops->busy = 1;
			metatag_data = TAG_DATA(tnf_struct_type);
			metatag_data->tag_desc(ops, metatag_data);
			/* commit the data */
			(void) ops->commit(&(ops->wcb));
			ops->busy = 0;
		}
	}

	retval = real_fork();
	if (retval == 0) {
		/* child process */
		_tnfw_b_control->tnf_pid = getpid();
		if ((_tnfw_b_control->tnf_state == TNFW_B_NOBUFFER) &&
				(tnf_trace_file_name[0] != '\0')) {
			/*
			 * race condition, prex attached after condition was
			 * checked in parent, so both parent and child point at
			 * the same file name and will overwrite each other.
			 * So, we set tracing to broken in child.  We could
			 * invent a new state called RACE and use prex to
			 * reset it, if needed...
			 */
			tnf_trace_file_name[0] = '\0';
			_tnfw_b_control->tnf_state = TNFW_B_BROKEN;
		} else if (_tnfw_b_control->tnf_state == TNFW_B_RUNNING) {
			/* normal expected condition */
			_tnfw_b_control->tnf_state = TNFW_B_FORKED;
		}
	}
	return (retval);
}

/*
 * tnf_threaded_test
 */
/*ARGSUSED0*/
static void *
tnf_threaded_test(void *dummy, tnf_probe_control_t *probe_p,
			tnf_probe_setup_t *set_p)
{
	tnf_ops_t *tpd_p;

	tpd_p = thr_probe_getfunc_addr();
	if (tpd_p) {
		return (probe_p->alloc_func(tpd_p, probe_p, set_p));
	}
	return (NULL);
}


/*
 * tnf_non_threaded_test
 */
/*ARGSUSED0*/
static void *
tnf_non_threaded_test(void *dummy, tnf_probe_control_t *probe_p,
				tnf_probe_setup_t *set_p)
{
	tnf_ops_t *tpd_p;

	tpd_p = tnf_probe_getfunc();
	if (tpd_p) {
		return (probe_p->alloc_func(tpd_p, probe_p, set_p));
	}
	return (NULL);
}

/*
 * tnf_get_ops() returns the ops pointer (thread-private data), or NULL
 * if tracing is disabled for this thread.
 */
static tnf_ops_t *
tnf_get_ops()
{
	tnf_context_t	*test_func_p = &thr_probe_getfunc_addr;
	tnf_context_t	 test_func;

	/*
	 * IMPORTANT: this test to see whether thr_probe_getfunc_addr
	 * is bound is tricky.  The compiler currently has a bug
	 * (1263684) that causes the test to be optimized away unless
	 * coded with an intermediate pointer (test_func_p).  This
	 * causes the process to SEGV when the variable is not bound.
	 */

	test_func = test_func_p ? *test_func_p : tnf_probe_getfunc;
	return ((*test_func)());
}