dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / lib / abi / apptrace / common / apptrace.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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <link.h>
#include <dlfcn.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/resource.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <regex.h>
#include <signal.h>
#include <synch.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <apptrace.h>
#include <libintl.h>
#include <locale.h>
#include <limits.h>
#include <sys/sysmacros.h>
#include "abienv.h"
#include "mach.h"

#include <libproc.h>
#include <libctf.h>

#define NUM_ARGS 40

extern const char       *type_name(ctf_file_t *, ctf_id_t, char *, size_t);
extern void             print_value(ctf_file_t *, ctf_id_t, ulong_t);

static struct ps_prochandle     *proc_hdl = NULL;

static Liblist  *bindto_list;
static Liblist  *bindto_excl;
static Liblist  *bindfrom_list;
static Liblist  *bindfrom_excl;
static Liblist  *intlib_list;
static uint_t   pidout;
static Intlist  *trace_list;
static Intlist  *trace_excl;
static Intlist  *verbose_list;
static Intlist  *verbose_excl;

/*
 * Required for calls to build_env_list1 where
 * things are added to the end of the list (preserving
 * search order implied by the setting of env variables
 * in apptracecmd.c)
 */
static Liblist  *intlib_listend;

/*
 * These globals are sought and used by interceptlib.c
 * which goes into all interceptor objects.
 */
FILE            *ABISTREAM;
sigset_t        abisigset;

/*
 * Strings are printed with "%.*s", abi_strpsz, string
 */
int             abi_strpsz = 20;

/*
 * Special function pointers that'll be set up to point at the
 * libc/libthread versions in the _application's_ link map (as opposed
 * to our own).
 *
 * Additionally, it is impossible to generalize the programmatic
 * creation of interceptor functions for variable argument list
 * functions.  However, in the case of the printf family, there is a
 * vprintf equivalent.  The interceptors for the printf family live in
 * interceptor.c and they call the appropriate vprintf interface
 * instead of the printf interface that they're intercepting.  The
 * link map issue remains, however, so function pointers for the
 * vprintf family in the application's link map are set up here.
 *
 * The interceptors also need to examine errno which also needs to be
 * extracted from the base link map.
 *
 * All of these pointers are initialized in la_preinit().
 */

thread_t (*abi_thr_self)(void);
int (*abi_thr_main)(void);

int (*ABI_VFPRINTF)(FILE *, char const *, va_list);
int (*ABI_VFWPRINTF)(FILE *, const wchar_t *, va_list);
int (*ABI_VPRINTF)(char const *, va_list);
int (*ABI_VSNPRINTF)(char *, size_t, char const *, va_list);
int (*ABI_VSPRINTF)(char *, char const *, va_list);
int (*ABI_VSWPRINTF)(wchar_t *, size_t, const wchar_t *, va_list);
int (*ABI_VWPRINTF)(const wchar_t *, va_list);
int *(*__abi_real_errno)(void);

#if defined(__sparcv9)
static char const *libcpath             = "/lib/sparcv9/libc.so.1";
#elif defined(__amd64)
static char const *libcpath             = "/lib/amd64/libc.so.1";
#else
static char const *libcpath             = "/lib/libc.so.1";
#endif

/* Used as arguments later to dlsym */
static char const *thr_main_sym         = "thr_main";
static char const *thr_self_sym         = "thr_self";
static char const *vfprintf_sym         = "vfprintf";
static char const *vfwprintf_sym        = "vfwprintf";
static char const *vprintf_sym          = "vprintf";
static char const *vsnprintf_sym        = "vsnprintf";
static char const *vsprintf_sym         = "vsprintf";
static char const *vswprintf_sym        = "vswprintf";
static char const *vwprintf_sym         = "vwprintf";
static char const *errno_sym            = "___errno";

/*
 * The list of functions below are functions for which
 * apptrace.so will not perform any tracing.
 *
 * The user visible failure of tracing these functions
 * is a core dump of the application under observation.
 *
 * This list was originally discovered during sotruss
 * development.  Attempts lacking sufficient determination
 * to shrink this list have failed.
 *
 * There are a number of different kinds of issues here.
 *
 * The .stretX functions have to do with the relationship
 * that the caller and callee has with functions that
 * return structures and the altered calling convention
 * that results.
 *
 * We cannot trace *setjmp because the caller of these routines
 * is not allow to return which is exactly what an interceptor
 * function is going to do.
 *
 * The *context functions are on the list because we cannot trace
 * netscape without them on the list, but the exact mechanics of the
 * failure are not known at this time.
 *
 * The leaf functions *getsp can probably be removed given the
 * presence of an interceptor but that experiment has not been
 * conducted.
 *
 * NOTE: this list *must* be maintained in alphabetical order.
 *       if this list ever became too 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",
        NULL
};

uint_t
la_version(uint_t version)
{
        char            *str;
        FILE            *fp;

        ABISTREAM = stderr;

        if (version > LAV_CURRENT)
                (void) fprintf(stderr,
                                dgettext(TEXT_DOMAIN,
                                        "apptrace: unexpected version: %u\n"),
                                version);

        build_env_list(&bindto_list, "APPTRACE_BINDTO");
        build_env_list(&bindto_excl, "APPTRACE_BINDTO_EXCLUDE");

        build_env_list(&bindfrom_list, "APPTRACE_BINDFROM");
        build_env_list(&bindfrom_excl, "APPTRACE_BINDFROM_EXCLUDE");

        if (checkenv("APPTRACE_PID") != NULL) {
                pidout = 1;
        } else {
                char *str = "LD_AUDIT=";
                char *str2 = "LD_AUDIT64=";
                /*
                 * This disables apptrace output in subsequent exec'ed
                 * processes.
                 */
                (void) putenv(str);
                (void) putenv(str2);
        }

        if ((str = checkenv("APPTRACE_OUTPUT")) != NULL) {
                int fd, newfd, targetfd, lowerlimit;
                struct rlimit rl;

                if (getrlimit(RLIMIT_NOFILE, &rl) == -1) {
                        (void) fprintf(stderr,
                                        dgettext(TEXT_DOMAIN,
                                                "apptrace: getrlimit: %s\n"),
                                        strerror(errno));
                        exit(EXIT_FAILURE);
                }

                fd = open(str, O_WRONLY|O_CREAT|O_TRUNC, 0666);
                if (fd == -1) {
                        (void) fprintf(stderr,
                                        dgettext(TEXT_DOMAIN,
                                                "apptrace: %s: %s\n"),
                                        str,
                                        strerror(errno));
                        exit(EXIT_FAILURE);
                }

                /*
                 * Those fans of dup2 should note that dup2 cannot
                 * be used below because dup2 closes the target file
                 * descriptor.  Thus, if we're apptracing say, ksh
                 * we'd have closed the fd it uses for the history
                 * file (63 on my box).
                 *
                 * fcntl with F_DUPFD returns first available >= arg3
                 * so we iterate from the top until we find a available
                 * fd.
                 *
                 * Not finding an fd after 10 tries is a failure.
                 *
                 * Since the _file member of the FILE structure is an
                 * unsigned char, we must clamp our fd request to
                 * UCHAR_MAX
                 */
                lowerlimit = ((rl.rlim_cur >
                    UCHAR_MAX) ? UCHAR_MAX : rl.rlim_cur) - 10;

                for (targetfd = lowerlimit + 10;
                    targetfd > lowerlimit; targetfd--) {
                        if ((newfd = fcntl(fd, F_DUPFD, targetfd)) != -1)
                                break;
                }

                if (newfd == -1) {
                        (void) fprintf(stderr,
                                        dgettext(TEXT_DOMAIN,
                                                "apptrace: F_DUPFD: %s\n"),
                                        strerror(errno));
                        exit(EXIT_FAILURE);
                }
                (void) close(fd);

                if (fcntl(newfd, F_SETFD, FD_CLOEXEC) == -1) {
                        (void) fprintf(stderr,
                                        dgettext(TEXT_DOMAIN,
                                        "apptrace: fcntl FD_CLOEXEC: %s\n"),
                                        strerror(errno));
                        exit(EXIT_FAILURE);
                }

                if ((fp = fdopen(newfd, "wF")) != NULL) {
                        ABISTREAM = fp;
                } else {
                        (void) fprintf(stderr,
                                        dgettext(TEXT_DOMAIN,
                                                "apptrace: fdopen: %s\n"),
                                        strerror(errno));
                        exit(EXIT_FAILURE);
                }
        }

#if defined(_LP64)
        build_env_list1(&intlib_list, &intlib_listend,
            "APPTRACE_INTERCEPTORS64");
#else
        build_env_list1(&intlib_list, &intlib_listend,
            "APPTRACE_INTERCEPTORS");
#endif

        /* Set up lists interfaces to trace or ignore */
        env_to_intlist(&trace_list, "APPTRACE_INTERFACES");
        env_to_intlist(&trace_excl, "APPTRACE_INTERFACES_EXCLUDE");
        env_to_intlist(&verbose_list, "APPTRACE_VERBOSE");
        env_to_intlist(&verbose_excl, "APPTRACE_VERBOSE_EXCLUDE");

        return (LAV_CURRENT);
}

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

        /*
         * If this is the first time in, then l_name is the app
         * and unless the user gave an explict from list
         * we will trace calls from it.
         */
        if (first && bindfrom_list == NULL) {
                flags = LA_FLG_BINDFROM | LA_FLG_BINDTO;
                first = 0;
                goto work;
        }

        /*
         * If we have no bindto_list, then we assume that we
         * bindto everything (apptrace -T \*)
         *
         * Otherwise we make sure that l_name is on the list.
         */
        flags = 0;
        if (bindto_list == NULL) {
                flags = LA_FLG_BINDTO;
        } else if (check_list(bindto_list, lmp->l_name) != NULL) {
                flags |= LA_FLG_BINDTO;
        }

        /*
         * If l_name is on the exclusion list, zero the bit.
         */
        if ((bindto_excl != NULL) &&
            check_list(bindto_excl, lmp->l_name) != NULL) {
                flags &= ~LA_FLG_BINDTO;
        }

        /*
         * If l_name is on the bindfrom list then trace
         */
        if (check_list(bindfrom_list, lmp->l_name) != NULL) {
                flags |= LA_FLG_BINDFROM;
        }

        /*
         * If l_name is on the exclusion list, zero the bit
         * else trace, (this allows "-F !foo" to imply
         * "-F '*' -F !foo")
         */
        if (check_list(bindfrom_excl, lmp->l_name) != NULL) {
                flags &= ~LA_FLG_BINDFROM;
        } else if (bindfrom_excl != NULL && bindfrom_list == NULL) {
                flags |= LA_FLG_BINDFROM;
        }

work:
        if (flags) {
                *cookie = (uintptr_t)abibasename(lmp->l_name);

                /*
                 * only call Pgrab() once to get the ps_prochandle
                 */
                if (proc_hdl == NULL)
                        proc_hdl = Pgrab(getpid(), PGRAB_RDONLY, &perr);
        }

        return (flags);
}

static void
apptrace_preinit_fail(void)
{
        (void) fprintf(stderr,
                        dgettext(TEXT_DOMAIN, "apptrace: la_preinit: %s\n"),
                        dlerror());
        exit(EXIT_FAILURE);
}

/* ARGSUSED */
void
la_preinit(uintptr_t *cookie)
{
        void    *h = NULL;

        (void) sigfillset(&abisigset);

        h = dlmopen(LM_ID_BASE, libcpath, RTLD_LAZY | RTLD_NOLOAD);
        if (h == NULL)
                apptrace_preinit_fail();

        if ((abi_thr_self =
            (thread_t (*)(void)) dlsym(h, thr_self_sym)) == NULL)
                apptrace_preinit_fail();
        if ((abi_thr_main =
            (int (*)(void)) dlsym(h, thr_main_sym)) == NULL)
                apptrace_preinit_fail();

        /* Do printf style pointers */
        if ((ABI_VFPRINTF =
            (int (*)(FILE *, char const *, va_list))
            dlsym(h, vfprintf_sym)) == NULL)
                apptrace_preinit_fail();

        if ((ABI_VFWPRINTF =
            (int (*)(FILE *, const wchar_t *, va_list))
            dlsym(h, vfwprintf_sym)) == NULL)
                apptrace_preinit_fail();

        if ((ABI_VPRINTF =
            (int (*)(char const *, va_list))
            dlsym(h, vprintf_sym)) == NULL)
                apptrace_preinit_fail();

        if ((ABI_VSNPRINTF =
            (int (*)(char *, size_t, char const *, va_list))
            dlsym(h, vsnprintf_sym)) == NULL)
                apptrace_preinit_fail();

        if ((ABI_VSPRINTF =
            (int (*)(char *, char const *, va_list))
            dlsym(h, vsprintf_sym)) == NULL)
                apptrace_preinit_fail();

        if ((ABI_VSWPRINTF =
            (int (*)(wchar_t *, size_t, const wchar_t *, va_list))
            dlsym(h, vswprintf_sym)) == NULL)
                apptrace_preinit_fail();

        if ((ABI_VWPRINTF =
            (int (*)(const wchar_t *, va_list))
            dlsym(h, vwprintf_sym)) == NULL)
                apptrace_preinit_fail();

        if ((__abi_real_errno =
            (int *(*)(void))
            dlsym(h, errno_sym)) == NULL)
                apptrace_preinit_fail();

        (void) dlclose(h);
}

/* ARGSUSED1 */
#if defined(_LP64)
uintptr_t
la_symbind64(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcook,
    uintptr_t *defcook, uint_t *sb_flags, char const *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)
        char const *sym_name = (char const *) symp->st_name;
#endif
        int intercept = 0, verbose = 0;
        uintptr_t ret = symp->st_value;
        uint_t ndx;
        char *str;

#if defined(_LP64)
        if (ELF64_ST_TYPE(symp->st_info) != STT_FUNC)
                goto end;
#else
        /* If we're not looking at a function, bug out */
        if (ELF32_ST_TYPE(symp->st_info) != STT_FUNC)
                goto end;
#endif

        if (verbose_list != NULL) {
                /* apptrace ... -v verbose_list ... cmd */
                if (check_intlist(verbose_list, sym_name))
                        verbose = 1;
        }
        if (verbose_excl != NULL) {
                /* apptrace ... -v !verbose_excl ... cmd */
                if (check_intlist(verbose_excl, sym_name))
                        verbose = 0;
                else if (verbose_list == NULL && trace_list == NULL &&
                    trace_excl == NULL)
                        /* apptrace -v !verbose_excl cmd */
                        intercept = 1;
        }
        if (trace_list != NULL) {
                /* apptrace ... -t trace_list ... cmd */
                if (check_intlist(trace_list, sym_name))
                        intercept = 1;
        } else if (verbose_list == NULL && verbose_excl == NULL)
                /* default (implies -t '*'):  apptrace cmd */
                intercept = 1;

        if (trace_excl != NULL) {
                /* apptrace ... -t !trace_excl ... cmd */
                if (check_intlist(trace_excl, sym_name))
                        intercept = 0;
        }

        if (verbose == 0 && intercept == 0) {
                *sb_flags |= (LA_SYMB_NOPLTEXIT | LA_SYMB_NOPLTENTER);
                goto end;
        }

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

end:
        return (ret);
}

/* 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,
        char const *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,
        char const *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            *defname = (char *)(*defcookie);
        char            *refname = (char *)(*refcookie);
        sigset_t        omask;
#if     !defined(_LP64)
        char const      *sym_name = (char const *)symp->st_name;
#endif

        char            buf[256];
        GElf_Sym        sym;
        prsyminfo_t     si;
        ctf_file_t      *ctfp;
        ctf_funcinfo_t  finfo;
        int             argc;
        ctf_id_t        argt[NUM_ARGS];
        ulong_t         argv[NUM_ARGS];
        int             i;
        char            *sep = "";
        ctf_id_t        type, rtype;
        int             kind;

        abilock(&omask);

        if (pidout)
                (void) fprintf(ABISTREAM, "%7u:", (unsigned int)getpid());

        if ((ctfp = Pname_to_ctf(proc_hdl, defname)) == NULL)
                goto fail;

        if (Pxlookup_by_name(proc_hdl, PR_LMID_EVERY, defname, sym_name,
            &sym, &si) != 0)
                goto fail;

        if (ctf_func_info(ctfp, si.prs_id, &finfo) == CTF_ERR)
                goto fail;

        (void) type_name(ctfp, finfo.ctc_return, buf, sizeof (buf));
        (void) fprintf(ABISTREAM, "-> %-8s -> %8s:%s %s(",
            refname, defname, buf, sym_name);

        /*
         * According to bug in la_pltexit(), it can't return
         * if the type is just a struct/union.  So, if the return
         * type is a struct/union, la_pltexit() should be off.
         */
        rtype = ctf_type_resolve(ctfp, finfo.ctc_return);
        type = ctf_type_reference(ctfp, rtype);
        rtype = ctf_type_resolve(ctfp, type);
        kind = ctf_type_kind(ctfp, rtype);
        if ((kind == CTF_K_STRUCT || kind == CTF_K_UNION) &&
            strpbrk(buf, "*") == NULL)
                *sb_flags |= LA_SYMB_NOPLTEXIT;

        argc = MIN(sizeof (argt) / sizeof (argt[0]), finfo.ctc_argc);
        (void) ctf_func_args(ctfp, si.prs_id, argc, argt);

        argv[0] = GETARG0(regset);
        if (argc > 1)
                argv[1] = GETARG1(regset);
        if (argc > 2)
                argv[2] = GETARG2(regset);
        if (argc > 3)
                argv[3] = GETARG3(regset);
        if (argc > 4)
                argv[4] = GETARG4(regset);
        if (argc > 5)
                argv[5] = GETARG5(regset);
        if (argc > 6) {
                for (i = 6; i < argc; i++)
                        argv[i] = GETARG_6NUP(i, regset);
        }

        for (i = 0; i < argc; i++) {
                (void) type_name(ctfp, argt[i], buf, sizeof (buf));
                (void) fprintf(ABISTREAM, "%s%s = ", sep, buf);
                rtype = ctf_type_resolve(ctfp, argt[i]);
                type = ctf_type_reference(ctfp, rtype);
                rtype = ctf_type_resolve(ctfp, type);
                kind = ctf_type_kind(ctfp, rtype);
                if (kind == CTF_K_STRUCT || kind == CTF_K_UNION)
                        (void) fprintf(ABISTREAM, "0x%p", (void *)argv[i]);
                else
                        print_value(ctfp, argt[i], argv[i]);
                sep = ", ";
        }

        if (finfo.ctc_flags & CTF_FUNC_VARARG)
                (void) fprintf(ABISTREAM, "%s...", sep);
        else if (argc == 0)
                (void) fprintf(ABISTREAM, "void");

        if ((*sb_flags & LA_SYMB_NOPLTEXIT) != 0)
                (void) fprintf(ABISTREAM, ") ** ST\n");
        else
                (void) fprintf(ABISTREAM, ")\n");

        if (verbose_list != NULL &&
            check_intlist(verbose_list, sym_name) != 0) {
                for (i = 0; i < argc; i++) {
                        (void) type_name(ctfp, argt[i], buf, sizeof (buf));
                        (void) fprintf(ABISTREAM, "\targ%d = (%s) ", i, buf);
                        print_value(ctfp, argt[i], argv[i]);
                        (void) fprintf(ABISTREAM, "\n");
                }
                if ((*sb_flags & LA_SYMB_NOPLTEXIT) != 0) {
                        if (kind == CTF_K_STRUCT)
                                (void) fprintf(ABISTREAM,
                                    "\treturn = (struct), apptrace "
                                    "will not trace the return\n");
                        else
                                (void) fprintf(ABISTREAM,
                                    "\treturn = (union), apptrace "
                                    "will not trace the return\n");
                }
        }

        (void) fflush(ABISTREAM);
        abiunlock(&omask);
        return (symp->st_value);

fail:
        (void) fprintf(ABISTREAM,
            "-> %-8s -> %8s:%s(0x%lx, 0x%lx, 0x%lx) ** NR\n",
            refname, defname, sym_name,
            (ulong_t)GETARG0(regset),
            (ulong_t)GETARG1(regset),
            (ulong_t)GETARG2(regset));

        *sb_flags |= LA_SYMB_NOPLTEXIT;
        (void) fflush(ABISTREAM);
        abiunlock(&omask);
        return (symp->st_value);
}

/* ARGSUSED */
#if     defined(_LP64)
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
{
#if     !defined(_LP64)
        const char      *sym_name = (const char *)symp->st_name;
#endif
        sigset_t        omask;
        char            buf[256];
        GElf_Sym        sym;
        prsyminfo_t     si;
        ctf_file_t      *ctfp;
        ctf_funcinfo_t  finfo;
        char            *defname = (char *)(*defcookie);
        char            *refname = (char *)(*refcookie);

        abilock(&omask);

        if (pidout)
                (void) fprintf(ABISTREAM, "%7u:", (unsigned int)getpid());

        if (retval == 0) {
                if (verbose_list == NULL) {
                        (void) fprintf(ABISTREAM, "<- %-8s -> %8s:%s()\n",
                            refname, defname, sym_name);
                        (void) fflush(ABISTREAM);
                }
                abiunlock(&omask);
                return (retval);
        }

        if ((ctfp = Pname_to_ctf(proc_hdl, defname)) == NULL)
                goto fail;

        if (Pxlookup_by_name(proc_hdl, PR_LMID_EVERY, defname,
            sym_name, &sym, &si) != 0)
                goto fail;

        if (ctf_func_info(ctfp, si.prs_id, &finfo) == CTF_ERR)
                goto fail;

        if (verbose_list != NULL) {
                if (check_intlist(verbose_list, sym_name) != 0) {
                        (void) type_name(ctfp, finfo.ctc_return, buf,
                            sizeof (buf));
                        (void) fprintf(ABISTREAM, "\treturn = (%s) ", buf);
                        print_value(ctfp, finfo.ctc_return, retval);
                        (void) fprintf(ABISTREAM, "\n");
                        (void) fprintf(ABISTREAM, "<- %-8s -> %8s:%s()",
                            refname, defname, sym_name);
                        (void) fprintf(ABISTREAM, " = 0x%p\n", (void *)retval);
                }
        } else {
                (void) fprintf(ABISTREAM, "<- %-8s -> %8s:%s()",
                    refname, defname, sym_name);
                (void) fprintf(ABISTREAM, " = 0x%p\n", (void *)retval);
        }

        (void) fflush(ABISTREAM);
        abiunlock(&omask);
        return (retval);

fail:
        if (verbose_list != NULL) {
                if (check_intlist(verbose_list, sym_name) != 0) {
                        (void) fprintf(ABISTREAM,
                            "\treturn = 0x%p\n", (void *)retval);
                        (void) fprintf(ABISTREAM, "<- %-8s -> %8s:%s()",
                            refname, defname, sym_name);
                        (void) fprintf(ABISTREAM, " = 0x%p\n", (void *)retval);
                }
        } else {
                (void) fprintf(ABISTREAM, "<- %-8s -> %8s:%s()",
                    refname, defname, sym_name);
                (void) fprintf(ABISTREAM, " = 0x%p\n", (void *)retval);
        }

        (void) fflush(ABISTREAM);
        abiunlock(&omask);
        return (retval);
}