lib/libtnfctl/comb.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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) 1994, by Sun Microsytems, Inc.
 */

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

/*
 * Functions that know how to create and decode combinations that are
 * used for connecting probe functions.
 */

#ifndef DEBUG
#define	NDEBUG	1
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <search.h>
#include <assert.h>
#include <sys/types.h>

#include "tnfctl_int.h"
#include "dbg.h"


/*
 * Typedefs
 */

typedef struct comb_callinfo {
	unsigned	offset;
	unsigned	shift;	/* shift right <n> bits */
	unsigned	mask;

} comb_callinfo_t;

typedef struct comb_calltmpl {
	uintptr_t	entry;
	uintptr_t	down;
	uintptr_t	next;
	uintptr_t	end;

} comb_calltmpl_t;

typedef struct comb_key {
	comb_op_t	op;
	uintptr_t	down;
	uintptr_t	next;
	uintptr_t	comb;
} comb_key_t;

typedef struct decode_key {
	uintptr_t	addr;
	char		**name_ptrs;
	uintptr_t	*func_addrs;
} decode_key_t;


/*
 * Global - defined in assembler file
 */
extern comb_callinfo_t prb_callinfo;

extern void	 prb_chain_entry(void);
extern void	 prb_chain_down(void);
extern void	 prb_chain_next(void);
extern void	 prb_chain_end(void);

static comb_calltmpl_t calltmpl[PRB_COMB_COUNT] = {
{
		(uintptr_t) prb_chain_entry,
		(uintptr_t) prb_chain_down,
		(uintptr_t) prb_chain_next,
		(uintptr_t) prb_chain_end}
};

/*
 * Declarations
 */

static tnfctl_errcode_t decode(tnfctl_handle_t *hndl, uintptr_t addr,
	char ***func_names, uintptr_t **func_addrs);
static boolean_t find(tnfctl_handle_t *hndl, comb_op_t op, uintptr_t down,
	uintptr_t next, uintptr_t * comb_p);
static tnfctl_errcode_t build(tnfctl_handle_t *hndl, comb_op_t op,
	uintptr_t down, uintptr_t next, uintptr_t * comb_p);
static tnfctl_errcode_t add(tnfctl_handle_t *hndl, comb_op_t op, uintptr_t down,
	uintptr_t next, uintptr_t comb);
static int comb_compare(const void *a, const void *b);
static int decode_compare(const void *v0p, const void *v1p);
static tnfctl_errcode_t iscomb(tnfctl_handle_t *hndl, uintptr_t addr,
	uintptr_t *down_p, uintptr_t *next_p, boolean_t *ret_val);
static tnfctl_errcode_t findname(tnfctl_handle_t *hndl, uintptr_t addr,
	char **ret_name);


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

/*
 * _tnfctl_comb_build() - finds (or builds) a combination satisfing the op,
 * down and next constraints of the caller.
 */
tnfctl_errcode_t
_tnfctl_comb_build(tnfctl_handle_t *hndl, comb_op_t op,
	uintptr_t down, uintptr_t next, uintptr_t *comb_p)
{
	tnfctl_errcode_t	prexstat;

	*comb_p = NULL;

	DBG_TNF_PROBE_0(_tnfctl_comb_build_start, "libtnfctl",
			"start _tnfctl_comb_build; sunw%verbosity 1");

	if (find(hndl, op, down, next, comb_p)) {

		DBG_TNF_PROBE_1(_tnfctl_comb_build_end, "libtnfctl",
			"end _tnfctl_comb_build; sunw%verbosity 1",
			tnf_opaque, found_comb_at, *comb_p);

		return (TNFCTL_ERR_NONE);
	}
	prexstat = build(hndl, op, down, next, comb_p);

	DBG_TNF_PROBE_1(_tnfctl_comb_build_end, "libtnfctl",
			"end _tnfctl_comb_build; sunw%verbosity 1",
			tnf_opaque, built_comb_at, *comb_p);

	return (prexstat);
}


/*
 * _tnfctl_comb_decode() - returns a string describing the probe functions
 * NOTE - the string is for reference purposes ONLY, it should not be freed
 * by the client.
 */
tnfctl_errcode_t
_tnfctl_comb_decode(tnfctl_handle_t *hndl, uintptr_t addr, char ***func_names,
	uintptr_t **func_addrs)
{
	tnfctl_errcode_t prexstat;

	DBG_TNF_PROBE_0(_tnfctl_comb_decode_start, "libtnfctl",
			"start _tnfctl_comb_decode; sunw%verbosity 2");

	prexstat = decode(hndl, addr, func_names, func_addrs);

	DBG_TNF_PROBE_0(_tnfctl_comb_decode_end, "libtnfctl",
			"end _tnfctl_comb_decode; sunw%verbosity 2");

	return (prexstat);
}


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

/*
 * if combination has been decoded, return decoded info., else
 * decode combination and cache information
 */
static tnfctl_errcode_t
decode(tnfctl_handle_t *hndl, uintptr_t addr, char ***func_names,
	uintptr_t **func_addrs)
{
	tnfctl_errcode_t	prexstat = TNFCTL_ERR_NONE;
	decode_key_t	key;
	decode_key_t	*new_p = NULL;
	decode_key_t	**find_pp;
	uintptr_t	down;
	uintptr_t	next;
	char 		*thisname = NULL;
	boolean_t	is_combination;

	/* see if we can find the previously decoded answer */
	key.addr = addr;
	find_pp = (decode_key_t **) tfind(&key, &hndl->decoderoot,
			decode_compare);
	if (find_pp) {
		DBG_TNF_PROBE_0(decode_1, "libtnfctl",
			"sunw%verbosity 2; sunw%debug 'found existing'");
		*func_names = (*find_pp)->name_ptrs;
		*func_addrs = (*find_pp)->func_addrs;
		return (TNFCTL_ERR_NONE);
	}

	new_p = (decode_key_t *) calloc(1, sizeof (decode_key_t));
	if (!new_p)
		return (TNFCTL_ERR_ALLOCFAIL);
	new_p->addr = addr;

	prexstat = iscomb(hndl, addr, &down, &next, &is_combination);
	if (prexstat)
		goto Error;

	if (is_combination) {
		char **nextnames;
		uintptr_t *nextaddrs;
		char **name_pp;
		uintptr_t *addr_p;
		int count, j;

		DBG_TNF_PROBE_2(decode_2, "libtnfctl", "sunw%verbosity 2;",
			tnf_opaque, down, down,
			tnf_opaque, next, next);

		prexstat = findname(hndl, down, &thisname);
		if (prexstat == TNFCTL_ERR_USR1) {
			/*
			 * should never happen - combination should not
			 * point at the end function
			 */
			prexstat = TNFCTL_ERR_INTERNAL;
			goto Error;
		} else if (prexstat)
			goto Error;

		prexstat = decode(hndl, next, &nextnames, &nextaddrs);
		if (prexstat)
			goto Error;

		/* count number of elements - caution: empty 'for' loop */
		for (count = 0; nextnames[count]; count++);
		count++;	/* since it was 0 based */

		/* allocate one more for new function name */
		new_p->name_ptrs = malloc((count + 1) *
					sizeof (new_p->name_ptrs[0]));
		if (new_p->name_ptrs == NULL) {
			prexstat = TNFCTL_ERR_ALLOCFAIL;
			goto Error;
		}
		new_p->func_addrs = malloc((count + 1) *
					sizeof (new_p->func_addrs[0]));
		if (new_p->func_addrs == NULL) {
			prexstat = TNFCTL_ERR_ALLOCFAIL;
			goto Error;
		}
		name_pp = new_p->name_ptrs;
		addr_p = new_p->func_addrs;
		addr_p[0] = down;
		name_pp[0] = thisname;
		for (j = 0; j < count; j++) {
			name_pp[j + 1] = nextnames[j];
			addr_p[j + 1] = nextaddrs[j];
		}
	} else {
		prexstat = findname(hndl, addr, &thisname);
		if (prexstat != TNFCTL_ERR_USR1) {
			/*
			 * base case - end function is the only function
			 * that can be pointed at directly
			 */
			if (prexstat == TNFCTL_ERR_NONE)
				prexstat = TNFCTL_ERR_NONE;
			goto Error;
		}
		new_p->name_ptrs = malloc(sizeof (new_p->name_ptrs[0]));
		if (new_p->name_ptrs == NULL) {
			prexstat = TNFCTL_ERR_ALLOCFAIL;
			goto Error;
		}
		new_p->func_addrs = malloc(sizeof (new_p->func_addrs[0]));
		if (new_p->func_addrs == NULL) {
			prexstat = TNFCTL_ERR_ALLOCFAIL;
			goto Error;
		}
		new_p->name_ptrs[0] = NULL;
		new_p->func_addrs[0] = NULL;
	}

	DBG_TNF_PROBE_1(decode_3, "libtnfctl",
			"sunw%verbosity 2; sunw%debug 'decode built'",
			tnf_string, func_name,
				(thisname) ? (thisname) : "end_func");

	find_pp = (decode_key_t **) tsearch(new_p,
		&hndl->decoderoot, decode_compare);
	assert(*find_pp == new_p);
	*func_names = new_p->name_ptrs;
	*func_addrs = new_p->func_addrs;
	return (TNFCTL_ERR_NONE);

Error:
	if (new_p) {
		if (new_p->name_ptrs)
			free(new_p->name_ptrs);
		if (new_p->func_addrs)
			free(new_p->func_addrs);
		free(new_p);
	}
	return (prexstat);
}


/*
 * iscomb() - determine whether the pointed to function is a combination.  If
 * it is, return the down and next pointers
 */
static tnfctl_errcode_t
iscomb(tnfctl_handle_t *hndl,
	uintptr_t addr, uintptr_t *down_p, uintptr_t *next_p,
	boolean_t *ret_val)
{
	int		type;
	boolean_t	matched = B_FALSE;

	for (type = 0; type < PRB_COMB_COUNT; type++) {
		size_t		size;
		int		miscstat;
		char		*targ_p;
		char		*ptr;
		char		*tptr;
		uintptr_t	downaddr;
		uintptr_t	nextaddr;
		int		num_bits = 0;
		int		tmp_bits = prb_callinfo.mask;

		/* allocate room to copy the target code */
		size = (size_t) (calltmpl[type].end - calltmpl[type].entry);
		targ_p = (char *) malloc(size);
		if (!targ_p)
			return (TNFCTL_ERR_ALLOCFAIL);

		/* copy code from target */
		miscstat = hndl->p_read(hndl->proc_p, addr, targ_p, size);
		if (miscstat) {
			free(targ_p);
			return (TNFCTL_ERR_INTERNAL);
		}

		/* find the number of bits before the highest bit in mask */
		while (tmp_bits > 0) {
			num_bits++;
			tmp_bits <<= 1;
		}

		/* loop over all the words */
		tptr = (char *) calltmpl[type].entry;
		for (ptr = targ_p; ptr < (targ_p + size); ptr++, tptr++) {
			int			 downbits;
			int			 nextbits;
		/* LINTED pointer cast may result in improper alignment */
			int			*uptr = (int *) ptr;

			/*
			 * If we are pointing at one of the words that we
			 * patch, * (down or next displ) then read that value
			 * in. * Otherwise make sure the words match.
			 */
			if ((uintptr_t) tptr == calltmpl[type].down +
				prb_callinfo.offset) {
				downbits = *uptr;
				downbits &= prb_callinfo.mask;
				/* sign extend */
				downbits  = (downbits << num_bits) >> num_bits;
				downbits <<= prb_callinfo.shift;
				downaddr = addr + (ptr - targ_p) + downbits;
#if defined(i386)
				downaddr += 4;
				/* intel is relative to *next* instruction */
#endif

				ptr += 3;
				tptr += 3;
			} else if ((uintptr_t) tptr == calltmpl[type].next +
				prb_callinfo.offset) {
				nextbits = *uptr;
				nextbits &= prb_callinfo.mask;
				/* sign extend */
				nextbits  = (nextbits << num_bits) >> num_bits;
				nextbits <<= prb_callinfo.shift;
				nextaddr = addr + (ptr - targ_p) + nextbits;
#if defined(i386)
				nextaddr += 4;
				/* intel is relative to *next* instruction */
#endif

				ptr += 3;
				tptr += 3;
			} else {
				/* the byte better match or we bail */
				if (*ptr != *tptr)
					goto NextComb;
			}
		}

		/* YOWSA! - its a match */
		matched = B_TRUE;

NextComb:
		/* free allocated memory */
		if (targ_p)
			free(targ_p);

		if (matched) {
			*down_p = downaddr;
			*next_p = nextaddr;
			*ret_val = B_TRUE;
			return (TNFCTL_ERR_NONE);
		}
	}

	*ret_val = B_FALSE;
	return (TNFCTL_ERR_NONE);
}


#define	FUNC_BUF_SIZE	32
/*
 * findname() - find a name for a function given its address.
 */
static tnfctl_errcode_t
findname(tnfctl_handle_t *hndl, uintptr_t addr, char **ret_name)
{
	char		*symname;
	tnfctl_errcode_t prexstat;

	symname = NULL;
	prexstat = _tnfctl_sym_findname(hndl, addr, &symname);
	if ((prexstat == TNFCTL_ERR_NONE) && (symname != NULL)) {
		/* found a name */

		/*
		 * SPECIAL CASE
		 * If we find "tnf_trace_end" then we should not report it
		 * as this is the "end-cap" function and should be hidden
		 * from the user.  Return a null string instead ...
		 */
		if (strcmp(symname, TRACE_END_FUNC) == 0) {
			return (TNFCTL_ERR_USR1);
		} else {
			*ret_name = symname;
			return (TNFCTL_ERR_NONE);
		}
	} else {
		char *buffer;

		buffer = malloc(FUNC_BUF_SIZE);
		if (buffer == NULL)
			return (TNFCTL_ERR_ALLOCFAIL);

		/* no name found, use the address */
		(void) sprintf(buffer, "func@0x%p", addr);
		*ret_name = buffer;
		return (TNFCTL_ERR_NONE);
	}
}


/*
 * find() - try to find an existing combination that satisfies ...
 */
static boolean_t
find(tnfctl_handle_t *hndl, comb_op_t op, uintptr_t down, uintptr_t next,
	uintptr_t * comb_p)
{
	comb_key_t	key;
	comb_key_t	**find_pp;

	key.op = op;
	key.down = down;
	key.next = next;
	key.comb = NULL;

	find_pp = (comb_key_t **) tfind(&key, &hndl->buildroot, comb_compare);
	if (find_pp) {
		*comb_p = (*find_pp)->comb;
		return (B_TRUE);
	} else
		return (B_FALSE);
}


/*
 * add() - adds a combination to combination cache
 */
static tnfctl_errcode_t
add(tnfctl_handle_t *hndl, comb_op_t op, uintptr_t down, uintptr_t next,
	uintptr_t comb)
{
	comb_key_t	 *new_p;
	/* LINTED set but not used in function */
	comb_key_t	**ret_pp;

	new_p = (comb_key_t *) malloc(sizeof (comb_key_t));
	if (!new_p)
		return (TNFCTL_ERR_ALLOCFAIL);

	new_p->op = op;
	new_p->down = down;
	new_p->next = next;
	new_p->comb = comb;

	ret_pp = (comb_key_t **) tsearch(new_p, &hndl->buildroot,
			comb_compare);
	assert(*ret_pp == new_p);
	return (TNFCTL_ERR_NONE);
}


/*
 * decode_compare() - comparison function used for tree search for
 * combinations
 */
static int
decode_compare(const void *v0p, const void *v1p)
{
	decode_key_t   *k0p = (decode_key_t *) v0p;
	decode_key_t   *k1p = (decode_key_t *) v1p;

	return (int) ((uintptr_t) k1p->addr - (uintptr_t) k0p->addr);
}				/* end decode_compare */


/*
 * comb_compare() - comparison function used for tree search for combinations
 */
static int
comb_compare(const void *v0p, const void *v1p)
{
	comb_key_t	 *k0p = (comb_key_t *) v0p;
	comb_key_t	 *k1p = (comb_key_t *) v1p;

	if (k0p->op != k1p->op)
		return ((k0p->op < k1p->op) ? -1 : 1);

	if (k0p->down != k1p->down)
		return ((k0p->down < k1p->down) ? -1 : 1);

	if (k0p->next != k1p->next)
		return ((k0p->next < k1p->next) ? -1 : 1);

	return (0);

}				/* end comb_compare */

/*
 * build() - build a composition
 */
static tnfctl_errcode_t
build(tnfctl_handle_t *hndl, comb_op_t op, uintptr_t down, uintptr_t next,
	uintptr_t *comb_p)
{
	size_t		size;
	uintptr_t	addr;
	char		*buffer_p = NULL;
	uintptr_t	offset;
	uintptr_t	contents;
	unsigned	*word_p;
	int		miscstat;
	tnfctl_errcode_t	prexstat;

#if 0
	(void) fprintf(stderr, "off=0x%x shift=0x%x mask=0x%x size=%d\n",
		prb_callinfo.offset,
		prb_callinfo.shift,
		prb_callinfo.mask,
		calltmpl[op].end - calltmpl[op].entry);
#endif

	*comb_p = NULL;
	size = calltmpl[op].end - calltmpl[op].entry;

	/* allocate memory in the target process */
	prexstat = _tnfctl_targmem_alloc(hndl, size, &addr);
	if (prexstat) {
		DBG((void) fprintf(stderr,
			"build: trouble allocating target memory:\n"));
		goto Error;
	}

	/* allocate a scratch buffer, copy the template into it */
	buffer_p = malloc(size);
	if (!buffer_p) {
		DBG((void) fprintf(stderr, "build: alloc failed\n"));
		prexstat = TNFCTL_ERR_ALLOCFAIL;
		goto Error;
	}
	(void) memcpy(buffer_p, (void *) calltmpl[op].entry, size);

	/* poke the down address */
	offset = calltmpl[op].down - calltmpl[op].entry;
	/*LINTED pointer cast may result in improper alignment*/
	word_p = (unsigned *) (buffer_p + offset + prb_callinfo.offset);
	contents = down - (addr + offset);
#if defined(i386)
	contents -= 5;		/* intel offset is relative to *next* instr */
#endif

	DBG_TNF_PROBE_4(build_1, "libtnfctl", "sunw%verbosity 3",
			tnf_opaque, down, down,
			tnf_opaque, contents, contents,
			tnf_opaque, word_p, word_p,
			tnf_long, offset, offset);

	*word_p &= ~prb_callinfo.mask;	/* clear the relevant field */
	*word_p |= ((contents >> prb_callinfo.shift) & prb_callinfo.mask);

	/* poke the next address */
	offset = calltmpl[op].next - calltmpl[op].entry;
	/*LINTED pointer cast may result in improper alignment*/
	word_p = (unsigned *) (buffer_p + offset + prb_callinfo.offset);
	contents = next - (addr + offset);
#if defined(i386)
	contents -= 5;		/* intel offset is relative to *next* instr */
#endif

	DBG_TNF_PROBE_4(build_2, "libtnfctl", "sunw%verbosity 3",
			tnf_opaque, next, next,
			tnf_opaque, contents, contents,
			tnf_opaque, word_p, word_p,
			tnf_long, offset, offset);

	*word_p &= ~prb_callinfo.mask;	/* clear the relevant field */
	*word_p |= ((contents >> prb_callinfo.shift) & prb_callinfo.mask);

	/* copy the combination template into target memory */
	miscstat = hndl->p_write(hndl->proc_p, addr, buffer_p, size);
	if (miscstat) {
		DBG((void) fprintf(stderr,
			"build: trouble writing combination: \n"));
		prexstat = TNFCTL_ERR_INTERNAL;
		goto Error;
	}
	*comb_p = addr;
	prexstat = add(hndl, op, down, next, addr);

Error:
	if (buffer_p)
		free(buffer_p);
	return (prexstat);
}