modules/svc.configd/configd.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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <mdb/mdb_modapi.h>
#include <mdb/mdb_ctf.h>

#include <configd.h>

mdb_ctf_id_t request_enum;
mdb_ctf_id_t response_enum;
mdb_ctf_id_t ptr_type_enum;
mdb_ctf_id_t thread_state_enum;

hrtime_t max_time_seen;

static void
enum_lookup(char *out, size_t size, mdb_ctf_id_t id, int val,
    const char *prefix, const char *prefix2)
{
    const char *cp;
    size_t len = strlen(prefix);
    size_t len2 = strlen(prefix2);

    if ((cp = mdb_ctf_enum_name(id, val)) != NULL) {
        if (strncmp(cp, prefix, len) == 0)
            cp += len;
        if (strncmp(cp, prefix2, len2) == 0)
            cp += len2;
        (void) strlcpy(out, cp, size);
    } else {
        mdb_snprintf(out, size, "? (%d)", val);
    }
}

static void
make_lower(char *out, size_t sz)
{
    while (*out != 0 && sz > 0) {
        if (*out >= 'A' && *out <= 'Z')
            *out += 'a' - 'A';
        out++;
        sz--;
    }
}

/*ARGSUSED*/
static int
configd_status(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    int num_servers;
    int num_started;

    if (argc != 0)
        return (DCMD_USAGE);

    if (mdb_readvar(&num_servers, "num_servers") == -1) {
        mdb_warn("unable to read num_servers");
        return (DCMD_ERR);
    }
    if (mdb_readvar(&num_started, "num_started") == -1) {
        mdb_warn("unable to read num_started");
        return (DCMD_ERR);
    }
    mdb_printf(
        "\nserver threads:\t%d running, %d starting\n\n", num_servers,
        num_started - num_servers);

    if (mdb_walk_dcmd("configd_threads", "configd_thread", argc,
        argv) == -1) {
        mdb_warn("can't walk 'configd_threads'");
        return (DCMD_ERR);
    }
    return (DCMD_OK);
}

/*ARGSUSED*/
static int
configd_thread(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    thread_info_t t;
    char state[20];
    char oldstate[20];

    if (!(flags & DCMD_ADDRSPEC)) {
        if (mdb_walk_dcmd("configd_threads", "configd_thread", argc,
            argv) == -1) {
            mdb_warn("can't walk 'configd_threads'");
            return (DCMD_ERR);
        }
        return (DCMD_OK);
    }

    if (argc != 0)
        return (DCMD_USAGE);

    if (DCMD_HDRSPEC(flags)) {
        mdb_printf("%<u>%-?s %5s %-12s %-12s %-?s %-?s %-?s%</u>\n",
            "ADDR", "TID", "STATE", "PREV_STATE", "CLIENT", "CLIENTRQ",
            "MAINREQ");
    }

    if (mdb_vread(&t, sizeof (t), addr) == -1) {
        mdb_warn("failed to read thread_info_t at %p", addr);
        return (DCMD_ERR);
    }

    enum_lookup(state, sizeof (state), thread_state_enum,
        t.ti_state, "TI_", "");
    make_lower(state, sizeof (state));

    enum_lookup(oldstate, sizeof (oldstate), thread_state_enum,
        t.ti_prev_state, "TI_", "");
    make_lower(oldstate, sizeof (oldstate));

    mdb_printf("%0?p %5d %-12s %-12s %?p %?p %?p\n",
        (void *)addr, t.ti_thread, state, oldstate,
        t.ti_active_client, t.ti_client_request, t.ti_main_door_request);

    return (DCMD_OK);
}

static int
walk_thread_info_init(mdb_walk_state_t *wsp)
{
    if (mdb_readvar(&wsp->walk_addr, "thread_list") == -1) {
        mdb_warn("unable to read thread_list");
        return (WALK_ERR);
    }

    if (mdb_layered_walk("uu_list_node", wsp) == -1) {
        mdb_warn("couldn't walk 'uu_list_node'");
        return (WALK_ERR);
    }

    return (WALK_NEXT);
}

static int
walk_thread_info_step(mdb_walk_state_t *wsp)
{
    uintptr_t addr = wsp->walk_addr;
    thread_info_t ti;

    if (mdb_vread(&ti, sizeof (ti), addr) == -1) {
        mdb_warn("unable to read thread_info_t at %p", addr);
        return (WALK_ERR);
    }

    return (wsp->walk_callback(addr, &ti, wsp->walk_cbdata));
}

static int
request_log(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    request_log_entry_t cur;
    hrtime_t dur;
    hrtime_t dursec;
    hrtime_t durnsec;
    char durstr[20];
    char stampstr[20];
    char requstr[30];
    char respstr[30];
    char typestr[30];
    uintptr_t node = 0;
    uintptr_t client = 0;
    uint64_t clientid = 0;

    int idx;
    int opt_v = FALSE;          /* verbose */

    if (!(flags & DCMD_ADDRSPEC)) {
        if (mdb_walk_dcmd("configd_log", "configd_log", argc,
            argv) == -1) {
            mdb_warn("can't walk 'configd_log'");
            return (DCMD_ERR);
        }
        return (DCMD_OK);
    }

    if (mdb_getopts(argc, argv,
        'c', MDB_OPT_UINTPTR, &client,
        'i', MDB_OPT_UINT64, &clientid,
        'n', MDB_OPT_UINTPTR, &node,
        'v', MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
        return (DCMD_USAGE);

    if (DCMD_HDRSPEC(flags)) {
        mdb_printf("%<u>%-?s %-4s %-14s %9s %-22s %-17s\n%</u>",
            "ADDR", "THRD", "START", "DURATION", "REQUEST",
            "RESPONSE");
    }

    if (mdb_vread(&cur, sizeof (cur), addr) == -1) {
        mdb_warn("couldn't read log entry at %p", addr);
        return (DCMD_ERR);
    }

    /*
     * apply filters, if any.
     */
    if (clientid != 0 && clientid != cur.rl_clientid)
        return (DCMD_OK);

    if (client != 0 && client != (uintptr_t)cur.rl_client)
        return (DCMD_OK);

    if (node != 0) {
        for (idx = 0; idx < MIN(MAX_PTRS, cur.rl_num_ptrs); idx++) {
            if ((uintptr_t)cur.rl_ptrs[idx].rlp_data == node) {
                node = 0;       /* found it */
                break;
            }
        }
        if (node != 0)
            return (DCMD_OK);
    }

    enum_lookup(requstr, sizeof (requstr), request_enum, cur.rl_request,
        "REP_PROTOCOL_", "");

    if (cur.rl_end != 0) {
        enum_lookup(respstr, sizeof (respstr), response_enum,
            cur.rl_response, "REP_PROTOCOL_", "FAIL_");

        dur = cur.rl_end - cur.rl_start;
        dursec = dur / NANOSEC;
        durnsec = dur % NANOSEC;

        if (dursec <= 9)
            mdb_snprintf(durstr, sizeof (durstr),
                "%lld.%06lld",
                dursec, durnsec / (NANOSEC / MICROSEC));
        else if (dursec <= 9999)
            mdb_snprintf(durstr, sizeof (durstr),
                "%lld.%03lld",
                dursec, NSEC2MSEC(durnsec));
        else
            mdb_snprintf(durstr, sizeof (durstr),
                "%lld", dursec);
    } else {
        (void) strcpy(durstr, "-");
        (void) strcpy(respstr, "-");
    }

    if (max_time_seen != 0 && max_time_seen >= cur.rl_start) {
        dur = max_time_seen - cur.rl_start;
        dursec = dur / NANOSEC;
        durnsec = dur % NANOSEC;

        if (dursec <= 99ULL)
            mdb_snprintf(stampstr, sizeof (stampstr),
                "-%lld.%09lld", dursec, durnsec);
        else if (dursec <= 99999ULL)
            mdb_snprintf(stampstr, sizeof (stampstr),
                "-%lld.%06lld",
                dursec, durnsec / (NANOSEC / MICROSEC));
        else if (dursec <= 99999999ULL)
            mdb_snprintf(stampstr, sizeof (stampstr),
                "-%lld.%03lld",
                dursec, NSEC2MSEC(durnsec));
        else
            mdb_snprintf(stampstr, sizeof (stampstr),
                "-%lld", dursec);
    } else {
        (void) strcpy(stampstr, "-");
    }

    mdb_printf("%0?x %4d T%13s %9s %-22s %-17s\n",
        addr, cur.rl_tid, stampstr, durstr, requstr, respstr);

    if (opt_v) {
        mdb_printf("\tclient: %?p (%d)\tptrs: %d\tstamp: %llx\n",
            cur.rl_client, cur.rl_clientid, cur.rl_num_ptrs,
            cur.rl_start);
        for (idx = 0; idx < MIN(MAX_PTRS, cur.rl_num_ptrs); idx++) {
            enum_lookup(typestr, sizeof (typestr), ptr_type_enum,
                cur.rl_ptrs[idx].rlp_type, "RC_PTR_TYPE_", "");
            mdb_printf("\t\t%-7s %5d %?p %?p\n", typestr,
                cur.rl_ptrs[idx].rlp_id, cur.rl_ptrs[idx].rlp_ptr,
                cur.rl_ptrs[idx].rlp_data);
        }
        mdb_printf("\n");
    }
    return (DCMD_OK);
}

struct request_log_walk {
    size_t      rlw_max;
    size_t      rlw_count;
    size_t      rlw_cur;
    struct request_entry {
        hrtime_t  timestamp;
        uintptr_t addr;
    }       *rlw_list;
};

/*
 * we want newer items at the top
 */
static int
request_entry_compare(const void *l, const void *r)
{
    const struct request_entry *lp = l;
    const struct request_entry *rp = r;

    if (rp->timestamp == lp->timestamp)
        return (0);

    /*
     * 0 timestamps go first.
     */
    if (rp->timestamp == 0)
        return (1);
    if (lp->timestamp == 0)
        return (-1);

    if (lp->timestamp < rp->timestamp)
        return (1);
    return (-1);
}

/*ARGSUSED*/
static int
request_log_count_thread(uintptr_t addr, thread_info_t *tip, uint_t *arg)
{
    (*arg)++;

    return (WALK_NEXT);
}

static int
request_log_add_thread(uintptr_t addr, thread_info_t *tip,
    struct request_entry **arg)
{
    if (max_time_seen < tip->ti_log.rl_start)
        max_time_seen = tip->ti_log.rl_start;

    if (max_time_seen < tip->ti_log.rl_end)
        max_time_seen = tip->ti_log.rl_end;

    if (tip->ti_log.rl_start != 0) {
        if (tip->ti_log.rl_end)
            (*arg)->timestamp = tip->ti_log.rl_start;
        else
            (*arg)->timestamp = 0;      /* sort to the top */

        (*arg)->addr = addr + offsetof(thread_info_t, ti_log);
        ++*arg;
    }
    return (WALK_NEXT);
}

static int
request_log_walk_init(mdb_walk_state_t *wsp)
{
    struct request_log_walk *rlw;
    struct request_entry *list, *listp;

    uint_t log_size;
    uint_t size;
    uint_t idx;
    uint_t pos;
    request_log_entry_t *base;
    request_log_entry_t cur;

    if (mdb_readvar(&base, "request_log") == -1) {
        mdb_warn("couldn't read 'request_log'");
        return (WALK_ERR);
    }
    if (mdb_readvar(&log_size, "request_log_size") == -1) {
        mdb_warn("couldn't read 'request_log_size'");
        return (WALK_ERR);
    }
    size = log_size;

    if (mdb_walk("configd_threads", (mdb_walk_cb_t)request_log_count_thread,
        &size) == -1) {
        mdb_warn("couldn't walk 'configd_threads'");
        return (WALK_ERR);
    }

    list = mdb_zalloc(sizeof (*list) * size, UM_SLEEP);
    listp = list;

    if (mdb_walk("configd_threads", (mdb_walk_cb_t)request_log_add_thread,
        &listp) == -1) {
        mdb_warn("couldn't walk 'configd_threads'");
        mdb_free(list, sizeof (*list) * size);
        return (WALK_ERR);
    }

    pos = listp - list;
    for (idx = 0; idx < log_size; idx++) {
        uintptr_t addr = (uintptr_t)&base[idx];
        if (mdb_vread(&cur, sizeof (cur), addr) == -1) {
            mdb_warn("couldn't read log entry at %p", addr);
            mdb_free(list, sizeof (*list) * size);
            return (WALK_ERR);
        }

        if (max_time_seen < cur.rl_start)
            max_time_seen = cur.rl_start;

        if (max_time_seen < cur.rl_end)
            max_time_seen = cur.rl_end;

        if (cur.rl_start != 0) {
            list[pos].timestamp = cur.rl_start;
            list[pos].addr = addr;
            pos++;
        }
    }
    qsort(list, pos, sizeof (*list), &request_entry_compare);

    rlw = mdb_zalloc(sizeof (*rlw), UM_SLEEP);
    rlw->rlw_max = size;
    rlw->rlw_count = pos;
    rlw->rlw_cur = 0;
    rlw->rlw_list = list;

    wsp->walk_data = rlw;

    return (WALK_NEXT);
}

static int
request_log_walk_step(mdb_walk_state_t *wsp)
{
    struct request_log_walk *rlw = wsp->walk_data;
    uintptr_t addr;
    request_log_entry_t cur;

    if (rlw->rlw_cur >= rlw->rlw_count)
        return (WALK_DONE);

    addr = rlw->rlw_list[rlw->rlw_cur++].addr;

    if (mdb_vread(&cur, sizeof (cur), addr) == -1) {
        mdb_warn("couldn't read log entry at %p", addr);
        return (WALK_ERR);
    }
    return (wsp->walk_callback(addr, &cur, wsp->walk_cbdata));
}

static void
request_log_walk_fini(mdb_walk_state_t *wsp)
{
    struct request_log_walk *rlw = wsp->walk_data;

    mdb_free(rlw->rlw_list, sizeof (*rlw->rlw_list) * rlw->rlw_max);
    mdb_free(rlw, sizeof (*rlw));
}

static const mdb_dcmd_t dcmds[] = {
    { "configd_status", NULL, "svc.configd status summary",
        configd_status },
    { "configd_thread", "?", "Print a thread_info_t tabularly",
        configd_thread },
    { "configd_log", "?[-v] [-c clientptr] [-i clientid]",
        "Print the request log, or a single entry", request_log },
    { NULL }
};

static const mdb_walker_t walkers[] = {
    { "configd_threads", "walks the thread_info_ts for all "
        "threads", walk_thread_info_init, walk_thread_info_step },
    { "configd_log", "walks the request_log_entry_ts",
        request_log_walk_init, request_log_walk_step,
        request_log_walk_fini},
    { NULL }
};

static const mdb_modinfo_t modinfo = {
    MDB_API_VERSION, dcmds, walkers
};

const mdb_modinfo_t *
_mdb_init(void)
{
    if (mdb_ctf_lookup_by_name("enum rep_protocol_requestid",
        &request_enum) == -1) {
        mdb_warn("enum rep_protocol_requestid not found");
    }
    if (mdb_ctf_lookup_by_name("enum rep_protocol_responseid",
        &response_enum) == -1) {
        mdb_warn("enum rep_protocol_responseid not found");
    }
    if (mdb_ctf_lookup_by_name("enum rc_ptr_type",
        &ptr_type_enum) == -1) {
        mdb_warn("enum rc_ptr_type not found");
    }
    if (mdb_ctf_lookup_by_name("enum thread_state",
        &thread_state_enum) == -1) {
        mdb_warn("enum thread_state not found");
    }
    return (&modinfo);
}