8158 Want named threads API

[unleashed.git] / usr / src / cmd / ptools / pstack / pstack.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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2018 Joyent, Inc.
 */

#include <sys/isa_defs.h>

#include <stdio.h>
#include <stdio_ext.h>
#include <fcntl.h>
#include <ctype.h>
#include <string.h>
#include <signal.h>
#include <dirent.h>
#include <errno.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/stack.h>
#include <link.h>
#include <limits.h>
#include <libelf.h>
#include <thread_db.h>
#include <libproc.h>
#include <setjmp.h>

static  char    *command;
static  int     Fflag;
static  int     is64;
static  GElf_Sym sigh;

/*
 * To keep the list of user-level threads for a multithreaded process.
 */
struct threadinfo {
        struct threadinfo *next;
        id_t    threadid;
        id_t    lwpid;
        td_thr_state_e state;
        uintptr_t startfunc;
        uintptr_t exitval;
        prgregset_t regs;
};

static struct threadinfo *thr_head, *thr_tail;

#define TRUE    1
#define FALSE   0

#define MAX_ARGS        8

/*
 * To support debugging java programs, we display java frames within a stack.
 * The logic to walk the java frames is contained in libjvm_db.so, which is
 * found in the same directory as libjvm.so, linked with the program.  If we are
 * debugging a 32-bit app with a 64-binary, then the debugging library is found
 * in the '64' subdirectory.  If we find libjvm_db.so, then we fill in these
 * stub routines.
 */
typedef struct jvm_agent jvm_agent_t;
typedef int java_stack_f(void *, prgregset_t, const char *, int, int, void *);

/*
 * The j_agent_create function takes a version parameter.  This ensures that the
 * interface can evolve appropriately.
 */
#define JVM_DB_VERSION  1
static void *libjvm;
typedef jvm_agent_t *(*j_agent_create_f)(struct ps_prochandle *, int);
typedef void (*j_agent_destroy_f)(jvm_agent_t *);
typedef int (*j_frame_iter_f)(jvm_agent_t *, prgregset_t, java_stack_f *,
    void *);

static j_agent_create_f j_agent_create;
static j_agent_destroy_f j_agent_destroy;
static j_frame_iter_f j_frame_iter;

static jvm_agent_t *load_libjvm(struct ps_prochandle *P);
static void reset_libjvm(jvm_agent_t *);

/*
 * Similar to what's done for debugging java programs, here are prototypes for
 * the library that allows us to debug Python programs.
 */
#define PYDB_VERSION    1
static void *libpython;

typedef struct pydb_agent pydb_agent_t;

typedef pydb_agent_t *(*pydb_agent_create_f)(struct ps_prochandle *P, int vers);
typedef void (*pydb_agent_destroy_f)(pydb_agent_t *py);
typedef int (*pydb_pc_frameinfo_f)(pydb_agent_t *py, uintptr_t pc,
    uintptr_t frame_addr, char *fbuf, size_t bufsz);

static pydb_agent_create_f pydb_agent_create;
static pydb_agent_destroy_f pydb_agent_destroy;
static pydb_pc_frameinfo_f pydb_pc_frameinfo;

static pydb_agent_t *load_libpython(struct ps_prochandle *P);
static void reset_libpython(pydb_agent_t *);
/*
 * Since we must maintain both a proc handle and a jvm handle, this structure
 * is the basic type that gets passed around.
 */
typedef struct pstack_handle {
        struct ps_prochandle *proc;
        jvm_agent_t *jvm;
        int ignore_frame;
        const char *lwps;
        int count;
        pydb_agent_t *pydb;
} pstack_handle_t;

static  int     thr_stack(const td_thrhandle_t *, void *);
static  void    free_threadinfo(void);
static  struct threadinfo *find_thread(id_t);
static  int     all_call_stacks(pstack_handle_t *, int);
static  void    tlhead(id_t, id_t, const char *);
static  int     print_frame(void *, prgregset_t, uint_t, const long *);
static  void    print_zombie(struct ps_prochandle *, struct threadinfo *);
static  void    print_syscall(const lwpstatus_t *, prgregset_t);
static  void    call_stack(pstack_handle_t *, const lwpstatus_t *);

/*
 * The number of active and zombie threads.
 */
static  int     nthreads;

int
main(int argc, char **argv)
{
        int retc = 0;
        int opt;
        int errflg = FALSE;
        core_content_t content = CC_CONTENT_DATA | CC_CONTENT_ANON |
            CC_CONTENT_STACK;
        struct rlimit rlim;

        if ((command = strrchr(argv[0], '/')) != NULL)
                command++;
        else
                command = argv[0];

        /* options */
        while ((opt = getopt(argc, argv, "F")) != EOF) {
                switch (opt) {
                case 'F':
                        /*
                         * If the user specifies the force option, we'll
                         * consent to printing out other threads' stacks
                         * even if the main stack is absent.
                         */
                        content &= ~CC_CONTENT_STACK;
                        Fflag = PGRAB_FORCE;
                        break;
                default:
                        errflg = TRUE;
                        break;
                }
        }

        argc -= optind;
        argv += optind;

        if (errflg || argc <= 0) {
                (void) fprintf(stderr,
                    "usage:\t%s [-F] { pid | core }[/lwps] ...\n", command);
                (void) fprintf(stderr, "  (show process call stack)\n");
                (void) fprintf(stderr,
                    "  -F: force grabbing of the target process\n");
                exit(2);
        }

        /*
         * Make sure we'll have enough file descriptors to handle a target
         * that has many many mappings.
         */
        if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) {
                rlim.rlim_cur = rlim.rlim_max;
                (void) setrlimit(RLIMIT_NOFILE, &rlim);
                (void) enable_extended_FILE_stdio(-1, -1);
        }

        (void) proc_initstdio();

        while (--argc >= 0) {
                int gcode;
                psinfo_t psinfo;
                const psinfo_t *tpsinfo;
                struct ps_prochandle *Pr = NULL;
                td_thragent_t *Tap;
                int threaded;
                pstack_handle_t handle;
                const char *lwps, *arg;

                (void) proc_flushstdio();

                arg = *argv++;

                if ((Pr = proc_arg_xgrab(arg, NULL, PR_ARG_ANY,
                    Fflag, &gcode, &lwps)) == NULL) {
                        (void) fprintf(stderr, "%s: cannot examine %s: %s\n",
                            command, arg, Pgrab_error(gcode));
                        retc++;
                        continue;
                }

                if ((tpsinfo = Ppsinfo(Pr)) == NULL) {
                        (void) fprintf(stderr, "%s: cannot examine %s: "
                            "lost control of process\n", command, arg);
                        Prelease(Pr, 0);
                        retc++;
                        continue;
                }
                (void) memcpy(&psinfo, tpsinfo, sizeof (psinfo_t));
                proc_unctrl_psinfo(&psinfo);

                if (Pstate(Pr) == PS_DEAD) {
                        if ((Pcontent(Pr) & content) != content) {
                                (void) fprintf(stderr, "%s: core '%s' has "
                                    "insufficient content\n", command, arg);
                                retc++;
                                continue;
                        }
                        (void) printf("core '%s' of %d:\t%.70s\n",
                            arg, (int)psinfo.pr_pid, psinfo.pr_psargs);
                } else {
                        (void) printf("%d:\t%.70s\n",
                            (int)psinfo.pr_pid, psinfo.pr_psargs);
                }

                is64 = (psinfo.pr_dmodel == PR_MODEL_LP64);

                if (Pgetauxval(Pr, AT_BASE) != -1L && Prd_agent(Pr) == NULL) {
                        (void) fprintf(stderr, "%s: warning: librtld_db failed "
                            "to initialize; symbols from shared libraries will "
                            "not be available\n", command);
                }

                /*
                 * First we need to get a thread agent handle.
                 */
                if (td_init() != TD_OK ||
                    td_ta_new(Pr, &Tap) != TD_OK)       /* no libc */
                        threaded = FALSE;
                else {
                        /*
                         * Iterate over all threads, calling:
                         *   thr_stack(td_thrhandle_t *Thp, NULL);
                         * for each one to generate the list of threads.
                         */
                        nthreads = 0;
                        (void) td_ta_thr_iter(Tap, thr_stack, NULL,
                            TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
                            TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);

                        (void) td_ta_delete(Tap);
                        threaded = TRUE;
                }

                handle.proc = Pr;
                handle.jvm = load_libjvm(Pr);
                handle.pydb = load_libpython(Pr);
                handle.lwps = lwps;
                handle.count = 0;

                if (all_call_stacks(&handle, threaded) != 0)
                        retc++;
                if (threaded)
                        free_threadinfo();

                reset_libjvm(handle.jvm);
                reset_libpython(handle.pydb);
                Prelease(Pr, 0);

                if (handle.count == 0)
                        (void) fprintf(stderr, "%s: no matching LWPs found\n",
                            command);
        }

        (void) proc_finistdio();

        return (retc);
}

/*
 * Thread iteration call-back function.
 * Called once for each user-level thread.
 * Used to build the list of all threads.
 */
/* ARGSUSED1 */
static int
thr_stack(const td_thrhandle_t *Thp, void *cd)
{
        td_thrinfo_t thrinfo;
        struct threadinfo *tip;
        td_err_e error;

        if (td_thr_get_info(Thp, &thrinfo) != TD_OK)
                return (0);

        tip = malloc(sizeof (struct threadinfo));
        tip->next = NULL;
        tip->threadid = thrinfo.ti_tid;
        tip->lwpid = thrinfo.ti_lid;
        tip->state = thrinfo.ti_state;
        tip->startfunc = thrinfo.ti_startfunc;
        tip->exitval = (uintptr_t)thrinfo.ti_exitval;
        nthreads++;

        if (thrinfo.ti_state == TD_THR_ZOMBIE ||
            ((error = td_thr_getgregs(Thp, tip->regs)) != TD_OK &&
            error != TD_PARTIALREG))
                (void) memset(tip->regs, 0, sizeof (prgregset_t));

        if (thr_tail)
                thr_tail->next = tip;
        else
                thr_head = tip;
        thr_tail = tip;

        return (0);
}

static void
free_threadinfo()
{
        struct threadinfo *tip = thr_head;
        struct threadinfo *next;

        while (tip) {
                next = tip->next;
                free(tip);
                tip = next;
        }

        thr_head = thr_tail = NULL;
}

/*
 * Find and eliminate the thread corresponding to the given lwpid.
 */
static struct threadinfo *
find_thread(id_t lwpid)
{
        struct threadinfo *tip;

        for (tip = thr_head; tip; tip = tip->next) {
                if (lwpid == tip->lwpid) {
                        tip->lwpid = 0;
                        return (tip);
                }
        }
        return (NULL);
}

static int
thread_call_stack(void *data, const lwpstatus_t *psp,
    const lwpsinfo_t *pip)
{
        char lwpname[THREAD_NAME_MAX] = "";
        pstack_handle_t *h = data;
        lwpstatus_t lwpstatus;
        struct threadinfo *tip;

        if (!proc_lwp_in_set(h->lwps, pip->pr_lwpid))
                return (0);
        h->count++;

        if ((tip = find_thread(pip->pr_lwpid)) == NULL)
                return (0);

        (void) Plwp_getname(h->proc, pip->pr_lwpid,
            lwpname, sizeof (lwpname));

        tlhead(tip->threadid, pip->pr_lwpid, lwpname);
        tip->threadid = 0;      /* finish eliminating tid */
        if (psp)
                call_stack(h, psp);
        else {
                if (tip->state == TD_THR_ZOMBIE)
                        print_zombie(h->proc, tip);
                else {
                        (void) memset(&lwpstatus, 0, sizeof (lwpstatus));
                        (void) memcpy(lwpstatus.pr_reg, tip->regs,
                            sizeof (prgregset_t));
                        call_stack(h, &lwpstatus);
                }
        }
        return (0);
}

static int
lwp_call_stack(void *data,
    const lwpstatus_t *psp, const lwpsinfo_t *pip)
{
        char lwpname[THREAD_NAME_MAX] = "";
        pstack_handle_t *h = data;

        if (!proc_lwp_in_set(h->lwps, pip->pr_lwpid))
                return (0);
        h->count++;

        (void) Plwp_getname(h->proc, pip->pr_lwpid,
            lwpname, sizeof (lwpname));

        tlhead(0, pip->pr_lwpid, lwpname);
        if (psp)
                call_stack(h, psp);
        else
                (void) printf("\t** zombie "
                    "(exited, not detached, not yet joined) **\n");
        return (0);
}

static int
all_call_stacks(pstack_handle_t *h, int dothreads)
{
        struct ps_prochandle *Pr = h->proc;
        pstatus_t status = *Pstatus(Pr);

        (void) memset(&sigh, 0, sizeof (GElf_Sym));
        (void) Plookup_by_name(Pr, "libc.so", "sigacthandler", &sigh);

        if ((status.pr_nlwp + status.pr_nzomb) <= 1 &&
            !(dothreads && nthreads > 1)) {
                if (proc_lwp_in_set(h->lwps, status.pr_lwp.pr_lwpid)) {
                        call_stack(h, &status.pr_lwp);
                        h->count++;
                }
        } else {
                lwpstatus_t lwpstatus;
                struct threadinfo *tip;
                id_t tid;

                if (dothreads)
                        (void) Plwp_iter_all(Pr, thread_call_stack, h);
                else
                        (void) Plwp_iter_all(Pr, lwp_call_stack, h);

                /* for each remaining thread w/o an lwp */
                (void) memset(&lwpstatus, 0, sizeof (lwpstatus));
                for (tip = thr_head; tip; tip = tip->next) {

                        if (!proc_lwp_in_set(h->lwps, tip->lwpid))
                                tip->threadid = 0;

                        if ((tid = tip->threadid) != 0) {
                                (void) memcpy(lwpstatus.pr_reg, tip->regs,
                                    sizeof (prgregset_t));
                                tlhead(tid, tip->lwpid, NULL);
                                if (tip->state == TD_THR_ZOMBIE)
                                        print_zombie(Pr, tip);
                                else
                                        call_stack(h, &lwpstatus);
                        }
                        tip->threadid = 0;
                        tip->lwpid = 0;
                }
        }
        return (0);
}

/* The width of the header */
#define HEAD_WIDTH      (62)
static void
tlhead(id_t threadid, id_t lwpid, const char *name)
{
        char buf[128] = { 0 };
        char num[16];
        ssize_t amt = 0;
        int i;

        if (threadid == 0 && lwpid == 0)
                return;

        if (lwpid > 0) {
                (void) snprintf(num, sizeof (num), "%d", (int)lwpid);
                (void) strlcat(buf, "thread# ", sizeof (buf));
                (void) strlcat(buf, num, sizeof (buf));
        }

        if (threadid > 0) {
                (void) snprintf(num, sizeof (num), "%d", (int)threadid);
                if (lwpid > 0)
                        (void) strlcat(buf, " / ", sizeof (buf));
                (void) strlcat(buf, "lwp# ", sizeof (buf));
                (void) strlcat(buf, num, sizeof (buf));
        }

        if (name != NULL && strlen(name) > 0) {
                (void) strlcat(buf, " [", sizeof (buf));
                (void) strlcat(buf, name, sizeof (buf));
                (void) strlcat(buf, "]", sizeof (buf));
        }

        amt = (HEAD_WIDTH - strlen(buf) - 2);
        if (amt < 4)
                amt = 4;

        for (i = 0; i < amt / 2; i++)
                (void) putc('-', stdout);
        (void) printf(" %s ", buf);
        for (i = 0; i < (amt / 2) + (amt % 2); i++)
                (void) putc('-', stdout);
        (void) putc('\n', stdout);
}

/*ARGSUSED*/
static int
print_java_frame(void *cld, prgregset_t gregs, const char *name, int bci,
    int line, void *handle)
{
        int length = (is64 ? 16 : 8);

        (void) printf(" %.*lx * %s", length, (long)gregs[R_PC], name);

        if (bci != -1) {
                (void) printf("+%d", bci);
                if (line)
                        (void) printf(" (line %d)", line);
        }
        (void) printf("\n");

        return (0);
}

static sigjmp_buf jumpbuf;

/*ARGSUSED*/
static void
fatal_signal(int signo)
{
        siglongjmp(jumpbuf, 1);
}

static int
print_frame(void *cd, prgregset_t gregs, uint_t argc, const long *argv)
{
        pstack_handle_t *h = cd;
        struct ps_prochandle *Pr = h->proc;
        uintptr_t pc = gregs[R_PC];
        char buff[255];
        GElf_Sym sym;
        uintptr_t start;
        int length = (is64? 16 : 8);
        int i;

        /*
         * If we are in a system call, we display the entry frame in a more
         * readable manner, using the name of the system call.  In this case, we
         * want to ignore this first frame, since we already displayed it
         * separately.
         */
        if (h->ignore_frame) {
                h->ignore_frame = 0;
                return (0);
        }

        (void) sprintf(buff, "%.*lx", length, (long)pc);
        (void) strcpy(buff + length, " ????????");
        if (Plookup_by_addr(Pr, pc,
            buff + 1 + length, sizeof (buff) - 1 - length, &sym) == 0) {
                start = sym.st_value;
        } else if (h->jvm != NULL) {
                int ret;
                void (*segv)(int), (*bus)(int), (*ill)(int);

                segv = signal(SIGSEGV, fatal_signal);
                bus = signal(SIGBUS, fatal_signal);
                ill = signal(SIGILL, fatal_signal);

                /* Insure against a bad libjvm_db */
                if (sigsetjmp(jumpbuf, 0) == 0)
                        ret = j_frame_iter(h->jvm, gregs, print_java_frame,
                            NULL);
                else
                        ret = -1;

                (void) signal(SIGSEGV, segv);
                (void) signal(SIGBUS, bus);
                (void) signal(SIGILL, ill);

                if (ret == 0)
                        return (ret);
        } else {
                start = pc;
        }

        (void) printf(" %-17s (", buff);
        for (i = 0; i < argc && i < MAX_ARGS; i++)
                (void) printf((i+1 == argc) ? "%lx" : "%lx, ", argv[i]);
        if (i != argc)
                (void) printf("...");
        (void) printf((start != pc) ? ") + %lx\n" : ")\n", (long)(pc - start));

        if (h->pydb != NULL && argc > 0) {
                char buf_py[1024];
                int rc;

                rc = pydb_pc_frameinfo(h->pydb, pc, argv[0], buf_py,
                    sizeof (buf_py));
                if (rc == 0) {
                        (void) printf("   %s", buf_py);
                }
        }

        /*
         * If the frame's pc is in the "sigh" (a.k.a. signal handler, signal
         * hack, or *sigh* ...) range, then we're about to cross a signal
         * frame.  The signal number is the first argument to this function.
         */
        if (pc - sigh.st_value < sigh.st_size) {
                if (sig2str((int)argv[0], buff) == -1)
                        (void) strcpy(buff, " Unknown");
                (void) printf(" --- called from signal handler with "
                    "signal %d (SIG%s) ---\n", (int)argv[0], buff);
        }

        return (0);
}

static void
print_zombie(struct ps_prochandle *Pr, struct threadinfo *tip)
{
        char buff[255];
        GElf_Sym sym;
        uintptr_t start;
        int length = (is64? 16 : 8);

        (void) sprintf(buff, "%.*lx", length, (long)tip->startfunc);
        (void) strcpy(buff + length, " ????????");
        if (Plookup_by_addr(Pr, tip->startfunc,
            buff + 1 + length, sizeof (buff) - 1 - length, &sym) == 0)
                start = sym.st_value;
        else
                start = tip->startfunc;
        (void) printf(" %s()", buff);
        if (start != tip->startfunc)    /* doesn't happen? */
                (void) printf("+%lx", (long)(tip->startfunc - start));
        (void) printf(", exit value = 0x%.*lx\n", length, (long)tip->exitval);
        (void) printf("\t** zombie "
            "(exited, not detached, not yet joined) **\n");
}

static void
print_syscall(const lwpstatus_t *psp, prgregset_t reg)
{
        char sname[32];
        int length = (is64? 16 : 8);
        uint_t i;

        (void) proc_sysname(psp->pr_syscall, sname, sizeof (sname));
        (void) printf(" %.*lx %-8s (", length, (long)reg[R_PC], sname);
        for (i = 0; i < psp->pr_nsysarg; i++)
                (void) printf((i+1 == psp->pr_nsysarg)? "%lx" : "%lx, ",
                    (long)psp->pr_sysarg[i]);
        (void) printf(")\n");
}

static void
call_stack(pstack_handle_t *h, const lwpstatus_t *psp)
{
        prgregset_t reg;

        (void) memcpy(reg, psp->pr_reg, sizeof (reg));

        if ((psp->pr_flags & (PR_ASLEEP|PR_VFORKP)) ||
            ((psp->pr_flags & PR_ISTOP) &&
            (psp->pr_why == PR_SYSENTRY ||
            psp->pr_why == PR_SYSEXIT))) {
                print_syscall(psp, reg);
                h->ignore_frame = 1;
        } else {
                h->ignore_frame = 0;
        }

        (void) Pstack_iter(h->proc, reg, print_frame, h);
}

/*ARGSUSED*/
static int
jvm_object_iter(void *cd, const prmap_t *pmp, const char *obj)
{
        char path[PATH_MAX];
        char *name;
        char *s1, *s2;
        struct ps_prochandle *Pr = cd;

        if ((name = strstr(obj, "/libjvm.so")) == NULL)
                name = strstr(obj, "/libjvm_g.so");

        if (name) {
                (void) strcpy(path, obj);
                if (Pstatus(Pr)->pr_dmodel != PR_MODEL_NATIVE) {
                        s1 = name;
                        s2 = path + (s1 - obj);
                        (void) strcpy(s2, "/64");
                        s2 += 3;
                        (void) strcpy(s2, s1);
                }

                s1 = strstr(obj, ".so");
                s2 = strstr(path, ".so");
                (void) strcpy(s2, "_db");
                s2 += 3;
                (void) strcpy(s2, s1);

                if ((libjvm = dlopen(path, RTLD_LAZY|RTLD_GLOBAL)) != NULL)
                        return (1);
        }

        return (0);
}

static jvm_agent_t *
load_libjvm(struct ps_prochandle *Pr)
{
        jvm_agent_t *ret;

        /*
         * Iterate through all the loaded objects in the target, looking
         * for libjvm.so.  If we find libjvm.so we'll try to load the
         * corresponding libjvm_db.so that lives in the same directory.
         *
         * At first glance it seems like we'd want to use
         * Pobject_iter_resolved() here since we'd want to make sure that
         * we have the full path to the libjvm.so.  But really, we don't
         * want that since we're going to be dlopen()ing a library and
         * executing code from that path, and therefore we don't want to
         * load any library code that could be from a zone since it could
         * have been replaced with a trojan.  Hence, we use Pobject_iter().
         * So if we're debugging java processes in a zone from the global
         * zone, and we want to get proper java stack stack frames, then
         * the same jvm that is running within the zone needs to be
         * installed in the global zone.
         */
        (void) Pobject_iter(Pr, jvm_object_iter, Pr);

        if (libjvm) {
                j_agent_create = (j_agent_create_f)
                    dlsym(libjvm, "Jagent_create");
                j_agent_destroy = (j_agent_destroy_f)
                    dlsym(libjvm, "Jagent_destroy");
                j_frame_iter = (j_frame_iter_f)
                    dlsym(libjvm, "Jframe_iter");

                if (j_agent_create == NULL || j_agent_destroy == NULL ||
                    j_frame_iter == NULL ||
                    (ret = j_agent_create(Pr, JVM_DB_VERSION)) == NULL) {
                        reset_libjvm(NULL);
                        return (NULL);
                }

                return (ret);
        }

        return (NULL);
}

static void
reset_libjvm(jvm_agent_t *agent)
{
        if (libjvm) {
                if (agent)
                        j_agent_destroy(agent);

                (void) dlclose(libjvm);
        }

        j_agent_create = NULL;
        j_agent_destroy = NULL;
        j_frame_iter = NULL;
        libjvm = NULL;
}

/*ARGSUSED*/
static int
python_object_iter(void *cd, const prmap_t *pmp, const char *obj)
{
        char path[PATH_MAX];
        char *name;
        char *s1, *s2;
        struct ps_prochandle *Pr = cd;

        name = strstr(obj, "/libpython");

        if (name) {
                (void) strcpy(path, obj);
                if (Pstatus(Pr)->pr_dmodel != PR_MODEL_NATIVE) {
                        s1 = name;
                        s2 = path + (s1 - obj);
                        (void) strcpy(s2, "/64");
                        s2 += 3;
                        (void) strcpy(s2, s1);
                }

                s1 = strstr(obj, ".so");
                s2 = strstr(path, ".so");
                (void) strcpy(s2, "_db");
                s2 += 3;
                (void) strcpy(s2, s1);

                if ((libpython = dlopen(path, RTLD_LAZY|RTLD_GLOBAL)) != NULL)
                        return (1);
        }

        return (0);
}

static pydb_agent_t *
load_libpython(struct ps_prochandle *Pr)
{
        pydb_agent_t *pdb;

        (void) Pobject_iter(Pr, python_object_iter, Pr);

        if (libpython) {
                pydb_agent_create = (pydb_agent_create_f)
                    dlsym(libpython, "pydb_agent_create");
                pydb_agent_destroy = (pydb_agent_destroy_f)
                    dlsym(libpython, "pydb_agent_destroy");
                pydb_pc_frameinfo = (pydb_pc_frameinfo_f)
                    dlsym(libpython, "pydb_pc_frameinfo");

                if (pydb_agent_create == NULL || pydb_agent_destroy == NULL ||
                    pydb_pc_frameinfo == NULL) {
                        (void) dlclose(libpython);
                        libpython = NULL;
                        return (NULL);
                }

                pdb = pydb_agent_create(Pr, PYDB_VERSION);
                if (pdb == NULL) {
                        (void) dlclose(libpython);
                        libpython = NULL;
                        return (NULL);
                }
                return (pdb);
        }

        return (NULL);
}

static void
reset_libpython(pydb_agent_t *pdb)
{
        if (libpython != NULL) {
                if (pdb != NULL) {
                        pydb_agent_destroy(pdb);
                }
                (void) dlclose(libpython);
        }

        libpython = NULL;
        pydb_agent_create = NULL;
        pydb_agent_destroy = NULL;
        pydb_pc_frameinfo = NULL;
}