demo/common/ps.c

	ps.c revision 20c1c3551cb3b3117591ae38463d16aada597c48
/*
 * 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 (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/uio.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/signal.h>
#include <sys/fault.h>
#include <sys/syscall.h>
#include <procfs.h>
#include <sys/auxv.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <libelf.h>
#include <sys/param.h>
#include <sys/machelf.h>
#include <stdarg.h>

#include <proc_service.h>

#include "rdb.h"
#include "disasm.h"

#if !defined(_LP64)
static void
gelf_sym_to_elf32(GElf_Sym *src, Elf32_Sym *dst)
{
    dst->st_name    = src->st_name;
    dst->st_value   = src->st_value;
    dst->st_size    = src->st_size;
    dst->st_info    = ELF32_ST_INFO(GELF_ST_BIND(src->st_info),
        GELF_ST_TYPE(src->st_info));
    dst->st_other   = src->st_other;
    dst->st_shndx   = src->st_shndx;
}
#endif

#define PROCSIZE    20

static void
get_ldbase(struct ps_prochandle *procp)
{
    int     pauxvfd;
    char        pname[PROCSIZE];
    struct stat stbuf;
    void        *auxvptr, *auxvtail;
    auxv_t      *auxvp;
    uint_t      entsize;

    (void) snprintf(pname, PROCSIZE, "/proc/%d/auxv",
        EC_SWORD(procp->pp_pid));
    if ((pauxvfd = open(pname, O_RDONLY)) == -1)
        perr("open auxv");

    if (fstat(pauxvfd, &stbuf) == -1)
        perr("stat auxv");

    auxvptr = malloc(stbuf.st_size);
    if (read(pauxvfd, auxvptr, stbuf.st_size) == -1)
        perr("gldb: reading auxv");

    (void) close(pauxvfd);

    procp->pp_auxvp = auxvptr;
    auxvtail = (void *)((uintptr_t)auxvptr + stbuf.st_size);

#if defined(_LP64)
    if (procp->pp_dmodel == PR_MODEL_ILP32)
        entsize = sizeof (auxv32_t);
    else
#endif
        entsize = sizeof (auxv_t);

    while (auxvptr < auxvtail) {
        auxvp = auxvptr;
        if (auxvp->a_type == AT_BASE) {
#if defined(_LP64)
            if (procp->pp_dmodel == PR_MODEL_ILP32)
                procp->pp_ldsobase =
                    ((uintptr_t)((auxv32_t *)auxvp)->
                    a_un.a_val);
            else
#endif
                procp->pp_ldsobase =  auxvp->a_un.a_val;
        } else if (auxvp->a_type == AT_PHDR) {
#if defined(_LP64)
            if (procp->pp_dmodel == PR_MODEL_ILP32)
                procp->pp_execphdr =
                    ((uintptr_t)((auxv32_t *)auxvp)->
                    a_un.a_val);
            else
#endif
                procp->pp_execphdr =  auxvp->a_un.a_val;
        }
        auxvptr = (void *)((uintptr_t)auxvptr + entsize);
    }
}

retc_t
ps_init(int pctlfd, int pstatusfd, pid_t pid, struct ps_prochandle *procp)
{
    rd_notify_t rd_notify;
    char        procname[PROCSIZE];
    long        oper, pflags;
    struct iovec    piov[2];

    procp->pp_pid = pid;
    procp->pp_ctlfd = pctlfd;
    procp->pp_statusfd = pstatusfd;

    (void) snprintf(procname, PROCSIZE, "/proc/%d/map",
        EC_SWORD(procp->pp_pid));
    if ((procp->pp_mapfd = open(procname, O_RDONLY)) == -1)
        perr("psi: open of /proc/dpid/map failed");

    (void) snprintf(procname, PROCSIZE, "/proc/%d/as",
        EC_SWORD(procp->pp_pid));
    if ((procp->pp_asfd = open(procname, O_RDWR)) == -1)
        perr("psi: open of /proc/dpid/as failed");

    if (ps_pdmodel(procp, &procp->pp_dmodel) != PS_OK)
        perr("psi: data model");

#if !defined(_LP64)
    if (procp->pp_dmodel == PR_MODEL_LP64)
        perr("psi:  run 64-bit rdb to debug a 64-bit process");
#endif
    get_ldbase(procp);

    (void) load_map(procp, (caddr_t)procp->pp_ldsobase,
        &(procp->pp_ldsomap));
    procp->pp_ldsomap.mi_addr += procp->pp_ldsobase;
    procp->pp_ldsomap.mi_end += procp->pp_ldsobase;
    procp->pp_ldsomap.mi_name = "<procfs: interp>";

    (void) load_map(procp, (caddr_t)procp->pp_execphdr,
        &(procp->pp_execmap));
    procp->pp_execmap.mi_name = "<procfs: exec>";

    procp->pp_breakpoints = NULL;
    procp->pp_flags = FLG_PP_PACT | FLG_PP_PLTSKIP;
    procp->pp_lmaplist.ml_head = NULL;
    procp->pp_lmaplist.ml_tail = NULL;
    if ((procp->pp_rap = rd_new(procp)) == NULL) {
        (void) fprintf(stderr, "rdb: rtld_db: rd_new() call failed\n");
        exit(1);
    }
    (void) rd_event_enable(procp->pp_rap, 1);

    /*
     * For those architectures that increment the PC on
     * a breakpoint fault we enable the PR_BPTADJ adjustments.
     */
    oper = PCSET;
    pflags = PR_BPTADJ;
    piov[0].iov_base = (caddr_t)(&oper);
    piov[0].iov_len = sizeof (oper);
    piov[1].iov_base = (caddr_t)(&pflags);
    piov[1].iov_len = sizeof (pflags);
    if (writev(procp->pp_ctlfd, piov, 2) == -1)
        perr("psinit: PCSET(PR_BTPADJ)");

    /*
     * Set breakpoints for special handshakes between librtld_db.so
     * and the debugger.  These include:
     *  PREINIT     - before .init processing.
     *  POSTINIT    - after .init processing
     *  DLACTIVITY  - link_maps status has changed
     */
    if (rd_event_addr(procp->pp_rap, RD_PREINIT, &rd_notify) == RD_OK) {
        if (set_breakpoint(procp, rd_notify.u.bptaddr,
            FLG_BP_RDPREINIT) != RET_OK)
            (void) fprintf(stderr,
                "psi: failed to set BP for preinit at: 0x%lx\n",
                rd_notify.u.bptaddr);
    } else
        (void) fprintf(stderr, "psi: no event registered for "
            "preinit\n");

    if (rd_event_addr(procp->pp_rap, RD_POSTINIT, &rd_notify) == RD_OK) {
        if (set_breakpoint(procp, rd_notify.u.bptaddr,
            FLG_BP_RDPOSTINIT) != RET_OK)
            (void) fprintf(stderr,
                "psi: failed to set BP for postinit at: 0x%lx\n",
                rd_notify.u.bptaddr);
    } else
        (void) fprintf(stderr, "psi: no event registered for "
            "postinit\n");

    if (rd_event_addr(procp->pp_rap, RD_DLACTIVITY, &rd_notify) == RD_OK) {
        if (set_breakpoint(procp, rd_notify.u.bptaddr,
            FLG_BP_RDDLACT) != RET_OK)
            (void) fprintf(stderr,
                "psi: failed to set BP for dlact at: 0x%lx\n",
                rd_notify.u.bptaddr);
    } else
        (void) fprintf(stderr, "psi: no event registered for dlact\n");

    return (RET_OK);
}

retc_t
ps_close(struct ps_prochandle *ph)
{
    (void) delete_all_breakpoints(ph);

    if (ph->pp_auxvp)
        free(ph->pp_auxvp);
    free_linkmaps(ph);
    return (RET_OK);
}

ps_err_e
ps_pauxv(struct ps_prochandle *ph, const auxv_t **auxvp)
{
    *auxvp = ph->pp_auxvp;
    return (PS_OK);
}

ps_err_e
ps_pdmodel(struct ps_prochandle *ph, int *dm)
{
    pstatus_t   pstatus;

    if (pread(ph->pp_statusfd, &pstatus, sizeof (pstatus), 0) == -1)
        return (PS_ERR);

    *dm = (int)pstatus.pr_dmodel;
    return (PS_OK);
}

ps_err_e
ps_pread(struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
{
    if (pread(ph->pp_asfd, buf, size, (off_t)addr) != size)
        return (PS_ERR);

    return (PS_OK);
}

ps_err_e
ps_pwrite(struct ps_prochandle *ph, psaddr_t addr, const void *buf, size_t size)
{
    if (pwrite(ph->pp_asfd, buf, size, (off_t)addr) != size)
        return (PS_ERR);

    return (PS_OK);
}

ps_err_e
ps_pglobal_sym(struct ps_prochandle *ph, const char *object_name,
    const char *sym_name, ps_sym_t *symp)
{
    map_info_t  *mip;
    GElf_Sym    gsym;

    if ((mip = str_to_map(ph, object_name)) == NULL)
        return (PS_ERR);

    if (str_map_sym(sym_name, mip, &gsym, NULL) == RET_FAILED)
        return (PS_ERR);

#if defined(_LP64)
    *symp = gsym;
#else
    gelf_sym_to_elf32(&gsym, (Elf32_Sym *)symp);
#endif

    return (PS_OK);
}

ps_err_e
ps_pglobal_lookup(struct ps_prochandle *ph, const char *object_name,
    const char *sym_name, ulong_t *sym_addr)
{
    GElf_Sym    sym;
    map_info_t  *mip;

    if ((mip = str_to_map(ph, object_name)) == NULL)
        return (PS_ERR);

    if (str_map_sym(sym_name, mip, &sym, NULL) == RET_FAILED)
        return (PS_ERR);

    *sym_addr = sym.st_value;

    return (PS_OK);
}

ps_err_e
ps_lgetregs(struct ps_prochandle *ph, lwpid_t lid, prgregset_t gregset)
{
    char        procname[MAXPATHLEN];
    int     lwpfd;
    lwpstatus_t lwpstatus;

    (void) snprintf(procname, MAXPATHLEN - 1,
        "/proc/%d/lwp/%d/lwpstatus", EC_SWORD(ph->pp_pid), EC_SWORD(lid));

    if ((lwpfd = open(procname, O_RDONLY)) == -1)
        return (PS_ERR);

    if (read(lwpfd, &lwpstatus, sizeof (lwpstatus)) == -1)
        return (PS_ERR);

    gregset = lwpstatus.pr_reg;

    (void) close(lwpfd);
    return (PS_OK);
}

void
ps_plog(const char *fmt, ...)
{
    va_list     args;
    static FILE *log_fp = NULL;

    if (log_fp == NULL) {
        char        log_fname[256];
        (void) sprintf(log_fname, "/tmp/tdlog.%d", EC_SWORD(getpid()));
        if ((log_fp = fopen(log_fname, "w")) == NULL) {
            /*
             * Unable to open log file - default to stderr.
             */
            (void) fprintf(stderr, "unable to open %s, logging "
                "redirected to stderr", log_fname);
            log_fp = stderr;
        }
    }

    va_start(args, fmt);
    (void) vfprintf(log_fp, fmt, args);
    va_end(args);
    (void) fputc('\n', log_fp);
    (void) fflush(log_fp);
}

/* ARGSUSED0 */
ps_err_e
ps_pbrandname(struct ps_prochandle *P, char *buf, size_t len)
{
    return (PS_ERR);
}