8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / 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);
}