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

#include <sys/dditypes.h>
#include <sys/mdb_modapi.h>
#include <sys/modctl.h>
#include <sys/sunddi.h>
#include <sys/lpif.h>
#include <sys/stmf.h>
#include <sys/portif.h>
#include <stmf_impl.h>
#include <lun_map.h>
#include <stmf_state.h>

#include <sys/fct.h>
#include <fct_impl.h>

#include "cmd_options.h"

static int
stmf_ilport_walk_i(mdb_walk_state_t *wsp)
{
    if (wsp->walk_addr == NULL) {
        struct stmf_state state;

        if (mdb_readsym(&state, sizeof (struct stmf_state),
            "stmf_state") == -1) {
            mdb_warn("failed to read stmf_state");
            return (WALK_ERR);
        }
        wsp->walk_addr = (uintptr_t)state.stmf_ilportlist;
    }

    wsp->walk_data = mdb_alloc(sizeof (stmf_i_local_port_t), UM_SLEEP);
    return (WALK_NEXT);
}

static int
stmf_ilport_walk_s(mdb_walk_state_t *wsp)
{
    int status = WALK_NEXT;

    if (wsp->walk_addr == NULL)
        return (WALK_DONE);

    if (mdb_vread(wsp->walk_data, sizeof (struct stmf_i_local_port),
        wsp->walk_addr) == -1) {
        mdb_warn("failed to read stmf_i_local_port_t at %p",
            wsp->walk_addr);
        return (WALK_ERR);
    }

    if (wsp->walk_callback)
        status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
            wsp->walk_cbdata);

    wsp->walk_addr = (uintptr_t)
        (((struct stmf_i_local_port *)wsp->walk_data)->ilport_next);

    return (status);
}

static void
stmf_ilport_walk_f(mdb_walk_state_t *wsp)
{
    mdb_free(wsp->walk_data, sizeof (struct stmf_i_local_port));
}

static int
dump_ilport(struct stmf_i_local_port *ilportp, int verbose)
{
    if (ilportp == NULL)
        return (DCMD_OK);

    mdb_printf("%p\n", ilportp);

    if (verbose) {
        /* here assume the alias is maximumly 1024 bytes */
        char alias[255];
        struct stmf_local_port lport;
        struct stmf_i_local_port ilport;

        if (mdb_vread(&ilport, sizeof (ilport), (uintptr_t)ilportp)
            == -1) {
            mdb_warn("failed to read stmf_i_local_port at %p",
                ilportp);
            return (DCMD_ERR);
        }

        memset(alias, 0, sizeof (alias));
        if (mdb_vread(&lport, sizeof (lport),
            (uintptr_t)ilport.ilport_lport) == -1) {
            mdb_warn("failed to read stmf_local_port at %p",
                ilport.ilport_lport);
            return (DCMD_ERR);
        }
        if (lport.lport_alias && mdb_vread(alias, sizeof (alias),
            (uintptr_t)lport.lport_alias) == -1) {
            mdb_warn("failed to read memory at %p",
                lport.lport_alias);
            return (DCMD_ERR);
        }

        mdb_printf("  lport: %p\n", ilport.ilport_lport);
        if (lport.lport_alias)
            mdb_printf("  port alias: %s\n", alias);
        mdb_printf("  port provider: %p\n", lport.lport_pp);
    }

    return (DCMD_OK);
}

/*ARGSUSED*/
static int
stmf_ilports(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    int i;
    int verbose = 0;
    mdb_walk_state_t ws = {NULL, };

    for (i = 0; i < argc; i++) {
        char *ptr = (char *)argv[i].a_un.a_str;

        if (ptr[0] == '-')
            ptr++;
        while (*ptr) {
            if (*ptr == 'v')
                verbose = 1;
            ptr++;
        }
    }

    if (stmf_ilport_walk_i(&ws) == WALK_ERR)
        return (DCMD_ERR);

    dump_ilport((stmf_i_local_port_t *)ws.walk_addr, verbose);

    while (stmf_ilport_walk_s(&ws) == WALK_NEXT)
        dump_ilport((stmf_i_local_port_t *)ws.walk_addr, verbose);

    stmf_ilport_walk_f(&ws);
    return (DCMD_OK);
}

struct stmf_i_local_port *
next_stmf_port(mdb_walk_state_t *wsp)
{
    if (wsp->walk_addr == NULL) {
        if (stmf_ilport_walk_i(wsp) == WALK_ERR) {
            stmf_ilport_walk_f(wsp);
            return (NULL);
        }
        if (wsp->walk_addr == NULL)
            stmf_ilport_walk_f(wsp);
        return ((struct stmf_i_local_port *)wsp->walk_addr);
    }

    if (stmf_ilport_walk_s(wsp) == WALK_ERR) {
        stmf_ilport_walk_f(wsp);
        return (NULL);
    }
    if (wsp->walk_addr == NULL)
        stmf_ilport_walk_f(wsp);
    return ((struct stmf_i_local_port *)wsp->walk_addr);
}


/*ARGSUSED*/
static int
stmf_iss(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    struct stmf_i_local_port iport;
    struct stmf_i_scsi_session *issp;
    struct stmf_i_scsi_session iss;
    int i;
    int verbose = 0;

    for (i = 0; i < argc; i++) {
        char *ptr = (char *)argv[i].a_un.a_str;

        if (ptr[0] == '-')
            ptr++;
        while (*ptr) {
            if (*ptr == 'v')
                verbose = 1;
            ptr++;
        }
    }

    if (addr == NULL) {
        mdb_warn("address of stmf_i_local_port should be specified\n");
        return (DCMD_ERR);
    }

    /*
     * Input should be stmf_i_local_port_t.
     */
    if (mdb_vread(&iport, sizeof (struct stmf_i_local_port), addr)
        != sizeof (struct stmf_i_local_port)) {
        mdb_warn("Unable to read in stmf_i_local_port at %p\n", addr);
        return (DCMD_ERR);
    }

    issp = iport.ilport_ss_list;

    while (issp) {
        if (mdb_vread(&iss, sizeof (iss), (uintptr_t)issp) == -1) {
            mdb_warn("failed to read stmf_i_scsi_session_t at %p",
                issp);
            return (DCMD_ERR);
        }

        mdb_printf("%p\n", issp);
        if (verbose) {
            mdb_printf("  scsi session: %p\n", iss.iss_ss);
        }

        issp = iss.iss_next;
    }

    return (DCMD_OK);
}

/*ARGSUSED*/
static int
stmf_ilus(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    struct stmf_state state;
    struct stmf_i_lu ilu;
    struct stmf_i_lu *ilup;
    int i;
    int verbose = 0;

    for (i = 0; i < argc; i++) {
        char *ptr = (char *)argv[i].a_un.a_str;

        if (ptr[0] == '-')
            ptr++;
        while (*ptr) {
            if (*ptr == 'v')
                verbose = 1;
            ptr++;
        }
    }

    if (mdb_readsym(&state, sizeof (struct stmf_state), "stmf_state")
        == -1) {
        mdb_warn("failed to read stmf_state");
        return (DCMD_ERR);
    }

    ilup = state.stmf_ilulist;
    while (ilup) {
        if (mdb_vread(&ilu, sizeof (struct stmf_i_lu), (uintptr_t)ilup)
            == -1) {
            mdb_warn("failed to read stmf_i_lu_t at %p", ilup);
            return (DCMD_ERR);
        }

        mdb_printf("%p\n", ilup);
        if (verbose) {
            mdb_printf("  lu: %p\n", ilu.ilu_lu);

            /* XXX lu_alias? what is its size? */
        }

        ilup = ilu.ilu_next;
    }

    return (DCMD_OK);
}

/*ARGSUSED*/
static int
stmf_i_lu_providers(uintptr_t addr, uint_t flags, int argc,
    const mdb_arg_t *argv)
{
    struct stmf_state state;
    struct stmf_i_lu_provider ilp;
    struct stmf_i_lu_provider *ilpp;
    int i;
    int verbose = 0;

    for (i = 0; i < argc; i++) {
        char *ptr = (char *)argv[i].a_un.a_str;

        if (ptr[0] == '-')
            ptr++;
        while (*ptr) {
            if (*ptr == 'v')
                verbose = 1;
            ptr++;
        }
    }

    if (mdb_readsym(&state, sizeof (struct stmf_state), "stmf_state")
        == -1) {
        mdb_warn("failed to read stmf_state");
        return (DCMD_ERR);
    }

    ilpp = state.stmf_ilplist;
    while (ilpp) {
        if (mdb_vread(&ilp, sizeof (stmf_i_lu_provider_t),
            (uintptr_t)ilpp) == -1) {
            mdb_warn("failed to read stmf_i_lu_provider_t at %p",
                ilpp);
            return (DCMD_ERR);
        }

        mdb_printf("%p\n", ilpp);
        if (verbose) {
            mdb_printf("  lu provider: %p\n", ilp.ilp_lp);
        }

        ilpp = ilp.ilp_next;
    }

    return (DCMD_OK);
}

/*ARGSUSED*/
static int
stmf_i_port_providers(uintptr_t addr, uint_t flags, int argc,
    const mdb_arg_t *argv)
{
    struct stmf_state state;
    struct stmf_i_port_provider ipp;
    struct stmf_i_port_provider *ippp;
    int i;
    int verbose = 0;

    for (i = 0; i < argc; i++) {
        char *ptr = (char *)argv[i].a_un.a_str;

        if (ptr[0] == '-')
            ptr++;
        while (*ptr) {
            if (*ptr == 'v')
                verbose = 1;
            ptr++;
        }
    }

    if (mdb_readsym(&state, sizeof (struct stmf_state), "stmf_state")
        == -1) {
        mdb_warn("failed to read stmf_state");
        return (DCMD_ERR);
    }

    ippp = state.stmf_ipplist;
    while (ippp) {
        if (mdb_vread(&ipp, sizeof (stmf_i_port_provider_t),
            (uintptr_t)ippp) == -1) {
            mdb_warn("failed to read stmf_i_port_provider_t at %p",
                ippp);
            return (DCMD_ERR);
        }

        mdb_printf("%p\n", ippp);
        if (verbose) {
            mdb_printf("  port provider: %p\n", ipp.ipp_pp);
        }

        ippp = ipp.ipp_next;
    }

    return (DCMD_OK);
}

int string2wwn(const char *s, uint8_t wwn[8]);

static uint16_t port_max_logins;
static int  rp_index;

/*
 * Cervert stmf_i_local_port to fct_i_local_port
 */
/*ARGSUSED*/
static struct fct_i_local_port *
__ilport2iport(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    struct stmf_i_local_port iport;
    struct stmf_local_port   lport;
    struct fct_local_port    fport;

    if (!(flags & DCMD_ADDRSPEC)) {
        mdb_warn("stmf_i_local_port address should be specified");
        return (NULL);
    }

    /*
     * Input should be stmf_i_local_port_t.
     */
    if (mdb_vread(&iport, sizeof (struct stmf_i_local_port), addr)
        != sizeof (struct stmf_i_local_port)) {
        mdb_warn("Unable to read in stmf_i_local_port\n");
        return (NULL);
    }

    if (mdb_vread(&lport, sizeof (stmf_local_port_t),
        (uintptr_t)iport.ilport_lport) != sizeof (stmf_local_port_t)) {
        mdb_warn("Unable to read in stmf_local_port\n");
        return (NULL);
    }

    if (mdb_vread(&fport, sizeof (fct_local_port_t),
        (uintptr_t)lport.lport_port_private)
        != sizeof (fct_local_port_t)) {
        mdb_warn("Unable to read in fct_local_port\n");
        return (NULL);
    }

    return (fport.port_fct_private);
}

static int
ilport2iport(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    struct fct_i_local_port *iportp;
    int i;
    int verbose = 0;

    for (i = 0; i < argc; i++) {
        char *ptr = (char *)argv[i].a_un.a_str;

        if (ptr[0] == '-')
            ptr++;
        while (*ptr) {
            if (*ptr == 'v')
                verbose = 1;
            ptr++;
        }
    }


    iportp = __ilport2iport(addr, flags, argc, argv);
    if (iportp) {
        mdb_printf("%p\n", iportp);
        if (verbose) {
            struct fct_i_local_port iport;
            /* is the alias always 16 bytes in size ? */
            char alias[16];

            memset(alias, 0, sizeof (alias));
            if (mdb_vread(&iport, sizeof (fct_i_local_port_t),
                (uintptr_t)iportp)
                != sizeof (fct_i_local_port_t)) {
                mdb_warn("Unable to read in fct_i_local_port"
                    "at %p\n", iportp);
                return (DCMD_ERR);
            }
            if (iport.iport_alias &&
                mdb_vread(alias, sizeof (alias),
                (uintptr_t)iport.iport_alias)
                != sizeof (alias)) {
                mdb_warn("Unable to read in memory at %p",
                    iport.iport_alias);
                return (DCMD_ERR);
            }
            mdb_printf("  port: %p\n", iport.iport_port);
            if (iport.iport_alias)
                mdb_printf("  alias: %s\n", alias);
        }
    }
    return (DCMD_OK);
}

/*
 * by wwn, we can only find one local port
 */
static struct stmf_i_local_port *
find_lport_by_wwn(uint8_t wwn[8])
{
    struct stmf_i_local_port *siport;
    struct fct_i_local_port *fiport;
    struct fct_i_local_port iport;
    struct fct_local_port fport;
    mdb_walk_state_t ws = {NULL, };

    while ((siport = next_stmf_port(&ws)) != NULL) {
        fiport = __ilport2iport((uintptr_t)siport, DCMD_ADDRSPEC,
            0, NULL);
        if (fiport == NULL)
            return (NULL);

        if (mdb_vread(&iport, sizeof (fct_i_local_port_t),
            (uintptr_t)fiport)
            != sizeof (fct_i_local_port_t)) {
            mdb_warn("Unable to read in fct_i_local_port\n");
            return (NULL);
        }
        if (mdb_vread(&fport, sizeof (fct_local_port_t),
            (uintptr_t)iport.iport_port)
            != sizeof (fct_local_port_t)) {
            mdb_warn("Unable to read in fct_local_port\n");
            return (NULL);
        }

#if 0
        mdb_printf("pwwn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
            fport.port_pwwn[0], fport.port_pwwn[1],
            fport.port_pwwn[2], fport.port_pwwn[3],
            fport.port_pwwn[4], fport.port_pwwn[5],
            fport.port_pwwn[6], fport.port_pwwn[7]);
#endif
        if (memcmp(fport.port_pwwn, wwn, 8) == 0) {
            return (siport);
        }
    }

    return (NULL);
}

/*ARGSUSED*/
static int
stmf_find_ilport(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    struct find_options *options;
    struct stmf_i_local_port *siport;

    options = parse_options(argc, argv);
    /* need to free options manually ? */
    if (options == NULL || ! options->lpname_defined) {
        mdb_printf("lpname=<wwn.12345678 or 12345678> "
            "should be specified\n");
        return (DCMD_OK);
    }

    if ((siport = find_lport_by_wwn(options->lpname)) != NULL)
        mdb_printf("%p\n", siport);

    return (DCMD_OK);
}

static int
fct_irp_walk_i(mdb_walk_state_t *wsp)
{
    struct fct_local_port port;
    struct fct_i_local_port iport;

    if (wsp->walk_addr == NULL) {
        mdb_warn("Can not perform global walk");
        return (WALK_ERR);
    }

    /*
     * Input should be fct_i_local_port_t.
     */
    if (mdb_vread(&iport, sizeof (struct fct_i_local_port), wsp->walk_addr)
        != sizeof (struct fct_i_local_port)) {
        mdb_warn("Unable to read in fct_i_local_port\n");
        return (WALK_ERR);
    }

    if (mdb_vread(&port, sizeof (struct fct_local_port),
        (uintptr_t)iport.iport_port)
        != sizeof (struct fct_local_port)) {
        mdb_warn("Unable to read in fct_local_port\n");
        return (WALK_ERR);
    }

    port_max_logins = port.port_max_logins;
    rp_index = 0;
    wsp->walk_addr = (uintptr_t)iport.iport_rp_slots;

    return (WALK_NEXT);
}

static int
fct_irp_walk_s(mdb_walk_state_t *wsp)
{
    int status = WALK_NEXT;
    fct_i_remote_port_t *rp;

    if (wsp->walk_addr == NULL)
        return (WALK_DONE);

    if (rp_index++ >= port_max_logins)
        return (WALK_DONE);

    if (mdb_vread(&rp, sizeof (fct_i_remote_port_t *),
        wsp->walk_addr) == -1) {
        mdb_warn("failed to read address of fct_i_remote_port_t at %p",
            wsp->walk_addr);
        return (WALK_DONE);
    }

    if (rp != NULL && wsp->walk_callback != NULL)
        status = wsp->walk_callback((uintptr_t)rp, rp,
            wsp->walk_cbdata);

    wsp->walk_addr = (uintptr_t)
        &(((fct_i_remote_port_t **)wsp->walk_addr)[1]);

    return (status);
}

static void
fct_irp_walk_f(mdb_walk_state_t *wsp)
{
    wsp->walk_addr = NULL;
}

/*
 * to set remote_port
 */
/*ARGSUSED*/
static int
walk_fct_irp_cb(uintptr_t p, const void * arg, void *cbdata)
{
    *((uintptr_t *)cbdata) = p;
    return (WALK_NEXT);
}

static int
fct_irps(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    static uint64_t cbdata = 0;
    mdb_walk_state_t ws = {walk_fct_irp_cb, &cbdata, addr};
    fct_i_remote_port_t *irpp;
    int i;
    int verbose = 0;

    for (i = 0; i < argc; i++) {
        char *ptr = (char *)argv[i].a_un.a_str;

        if (ptr[0] == '-')
            ptr++;
        while (*ptr) {
            if (*ptr == 'v')
                verbose = 1;
            ptr++;
        }
    }

    if (!(flags & DCMD_ADDRSPEC)) {
        mdb_warn("fct_i_local_port_t address should be specified");
        return (DCMD_ERR);
    }

    fct_irp_walk_i(&ws);
    while (fct_irp_walk_s(&ws) == WALK_NEXT) {
        irpp = *((fct_i_remote_port_t **)ws.walk_cbdata);

        if (irpp) {
            *((fct_i_remote_port_t **)ws.walk_cbdata) = NULL;

            mdb_printf("%p\n", irpp);
            if (verbose) {
                fct_i_remote_port_t irp;

                if (mdb_vread(&irp, sizeof (irp),
                    (uintptr_t)irpp) != sizeof (irp)) {
                    mdb_warn("Unable to read in "
                        "fct_i_remote_port at %p\n", irpp);
                    return (DCMD_ERR);
                }
                mdb_printf("  remote port: %p\n", irp.irp_rp);
                mdb_printf("  port id: %x\n", irp.irp_portid);
            }
        }
    }
    fct_irp_walk_f(&ws);

    return (DCMD_OK);
}

static uintptr_t cur_iport_for_irp_loop = NULL;

static fct_i_remote_port_t *
next_rport(struct fct_i_local_port *iport)
{
    static uint64_t cbdata = 0;
    static mdb_walk_state_t ws = {walk_fct_irp_cb, &cbdata};
    int ret;
    fct_i_remote_port_t *irp;

    if (ws.walk_addr == NULL || cur_iport_for_irp_loop !=
        (uintptr_t)iport) {
        *((fct_i_remote_port_t **)ws.walk_cbdata) = NULL;
        cur_iport_for_irp_loop = (uintptr_t)iport;
        ws.walk_addr = (uintptr_t)iport;
        if (fct_irp_walk_i(&ws) == WALK_ERR) {
            fct_irp_walk_f(&ws);
            return (NULL);
        }
        if (ws.walk_addr == NULL) {
            fct_irp_walk_f(&ws);
            return (NULL);
        }
    }

    while ((ret = fct_irp_walk_s(&ws)) == WALK_NEXT) {
        if (*((fct_i_remote_port_t **)ws.walk_cbdata) != 0) {
            irp = *((fct_i_remote_port_t **)ws.walk_cbdata);
            *((fct_i_remote_port_t **)ws.walk_cbdata) = NULL;
            return (irp);
        }
    }
    fct_irp_walk_f(&ws);

    /*
     * If it is WALK_DONE, there may be one remote port there
     */
    if (ret == WALK_DONE) {
        irp = *((fct_i_remote_port_t **)ws.walk_cbdata);
        *((fct_i_remote_port_t **)ws.walk_cbdata) = NULL;
        return (irp);
    }
    return (NULL);
}

static struct stmf_i_local_port *
irp_to_ilport(struct fct_i_remote_port *irpp)
{
    struct fct_i_remote_port irp;
    struct fct_remote_port rp;
    struct fct_local_port port;
    struct stmf_local_port lport;

    if (mdb_vread(&irp, sizeof (struct fct_i_remote_port),
        (uintptr_t)irpp)
        != sizeof (struct fct_i_remote_port)) {
        mdb_warn("Unable to read in fct_i_remote_port\n");
        return (NULL);
    }
    if (mdb_vread(&rp, sizeof (struct fct_remote_port),
        (uintptr_t)irp.irp_rp)
        != sizeof (struct fct_remote_port)) {
        mdb_warn("Unable to read in fct_remote_port\n");
        return (NULL);
    }

    if (mdb_vread(&port, sizeof (struct fct_local_port),
        (uintptr_t)rp.rp_port)
        != sizeof (struct fct_local_port)) {
        mdb_warn("Unable to read in fct_local_port\n");
        return (NULL);
    }
    if (mdb_vread(&lport, sizeof (struct stmf_local_port),
        (uintptr_t)port.port_lport)
        != sizeof (struct stmf_local_port)) {
        mdb_warn("Unable to read in stmf_local_port\n");
        return (NULL);
    }
    return (lport.lport_stmf_private);
}

/*
 * by wwn, we may find more than one remote port, so we need to know its
 * corresponding local port
 */
static struct fct_i_remote_port *
find_irp_by_wwn(struct stmf_i_local_port *siport, uint8_t wwn[8])
{
    struct fct_i_local_port *fiport;
    fct_i_remote_port_t *irpp;
    struct fct_i_remote_port irp;
    struct fct_remote_port rp;
    fct_i_remote_port_t *ret = NULL;

    fiport = __ilport2iport((uintptr_t)siport, DCMD_ADDRSPEC, 0, NULL);
    if (fiport == NULL)
        return (NULL);

    while ((irpp = next_rport(fiport)) != NULL) {
        if (mdb_vread(&irp, sizeof (struct fct_i_remote_port),
            (uintptr_t)irpp)
            != sizeof (struct fct_i_remote_port)) {
            mdb_warn("Unable to read in fct_i_remote_port\n");
            break;
        }
        if (mdb_vread(&rp, sizeof (struct fct_remote_port),
            (uintptr_t)irp.irp_rp)
            != sizeof (struct fct_remote_port)) {
            mdb_warn("Unable to read in fct_remote_port\n");
            break;
        }

        if (memcmp(rp.rp_pwwn, wwn, 8) == 0) {
            ret = irpp;
            break;
        }
    }
    cur_iport_for_irp_loop = NULL;
    return (ret);
}

/*ARGSUSED*/
static int
stmf_find_fct_irp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    struct stmf_i_local_port *siport;
    struct find_options *options;
    fct_i_remote_port_t *irpp;
    mdb_walk_state_t ws = {NULL, };

    options = parse_options(argc, argv);
    /* need to free options manually ? */
    if (options == NULL || (options->rpname_defined == 0 &&
        options->rp_defined == 0)) {
        mdb_printf("rpname=<wwn.12345678> or rp=<3000586778734>"
            " should be specified\n");
        return (DCMD_OK);
    }
    if (options->rpname_defined && options->rp_defined) {
        mdb_printf("rpname=<wwn.12345678> or rp=<3000586778734>"
            " should be specified, but not both\n");
        return (DCMD_OK);
    }

    if (options->rp_defined) {
        siport = irp_to_ilport(options->rp);
        if (siport != NULL)
            mdb_printf("stmf_i_local_port=%p,"
                " fct_i_remote_port=%p\n",
                siport, options->rp);
        return (DCMD_OK);
    }

    /* if options->rpname_defined */
    while ((siport = next_stmf_port(&ws)) != NULL) {
        if ((irpp = find_irp_by_wwn(siport, options->rpname)) != NULL)
            mdb_printf("stmf_i_local_port=%p, "
                "fct_i_remote_port=%p\n",
                siport, irpp);
    }

    return (DCMD_OK);
}

typedef void (*cmd_filter_t) (struct fct_i_cmd *,
    struct find_options *, void *);

/*ARGSUSED*/
static void
print_tasks(struct fct_i_cmd *icmdp, struct find_options *options, void *arg)
{
    struct fct_i_cmd icmd;
    struct fct_cmd cmd;

    if (mdb_vread(&icmd, sizeof (struct fct_i_cmd),
        (uintptr_t)icmdp) != sizeof (struct fct_i_cmd)) {
        mdb_warn("Unable to read in fct_i_cmd\n");
        return;
    }
    if (mdb_vread(&cmd, sizeof (struct fct_cmd),
        (uintptr_t)icmd.icmd_cmd) != sizeof (struct fct_cmd)) {
        mdb_warn("Unable to read in fct_cmd\n");
        return;
    }

    if (cmd.cmd_type == FCT_CMD_FCP_XCHG) {
        struct scsi_task task;
        int colon_printed = 0;

        if (mdb_vread(&task, sizeof (struct scsi_task),
            (uintptr_t)cmd.cmd_specific)
            != sizeof (struct scsi_task)) {
            mdb_warn("Unable to read in scsi_task\n");
            return;
        }

        mdb_printf("%p", cmd.cmd_specific);
        if (options->show_task_flags) {
            mdb_printf(":");
            colon_printed = 1;
            mdb_printf(" task_flags=%x", task.task_flags);
        }

        if (options->show_lport) {
            if (colon_printed == 0) {
                mdb_printf(":");
                colon_printed = 1;
            }
            mdb_printf(" lport=%p", task.task_lport);
        }
        mdb_printf("\n");
    }
}

static void
print_tasks_on_rp(struct fct_i_cmd *icmdp, struct find_options *options,
    void *arg)
{
    struct fct_i_cmd icmd;
    struct fct_cmd cmd;
    fct_i_remote_port_t irp;

    if (mdb_vread(&icmd, sizeof (struct fct_i_cmd),
        (uintptr_t)icmdp) != sizeof (struct fct_i_cmd)) {
        mdb_warn("Unable to read in fct_i_cmd\n");
        return;
    }
    if (mdb_vread(&cmd, sizeof (struct fct_cmd),
        (uintptr_t)icmd.icmd_cmd) != sizeof (struct fct_cmd)) {
        mdb_warn("Unable to read in fct_cmd\n");
        return;
    }

    /* arg is a pointer to fct_i_remote_port */
    if (mdb_vread(&irp, sizeof (struct fct_i_remote_port),
        (uintptr_t)arg) != sizeof (struct fct_i_remote_port)) {
        mdb_warn("Unable to read in fct_i_remote_port\n");
        return;
    }

    if (cmd.cmd_type == FCT_CMD_FCP_XCHG && cmd.cmd_rp == irp.irp_rp) {
        struct scsi_task task;
        int colon_printed = 0;

        if (mdb_vread(&task, sizeof (struct scsi_task),
            (uintptr_t)cmd.cmd_specific)
            != sizeof (struct scsi_task)) {
            mdb_warn("Unable to read in scsi_task\n");
            return;
        }

        mdb_printf("%p", cmd.cmd_specific);
        if (options->show_task_flags) {
            mdb_printf(":");
            colon_printed = 1;
            mdb_printf(" task_flags=%x", task.task_flags);
        }

        if (options->show_lport) {
            if (colon_printed == 0) {
                mdb_printf(":");
                colon_printed = 1;
            }
            mdb_printf(" lport=%p", task.task_lport);
        }
        mdb_printf("\n");
    }
}

/*ARGSUSED*/
static void
print_all_cmds(struct fct_i_cmd *icmd, struct find_options *options, void *arg)
{
    mdb_printf("%p\n", icmd);
}

/*
 * find outstanding cmds (fct_i_cmd) on local port
 */
static int
outstanding_cmds_on_lport(struct stmf_i_local_port *siport, cmd_filter_t filter,
    struct find_options *options, void *arg)
{
    struct fct_i_local_port *iportp;
    struct fct_i_local_port iport;
    struct fct_local_port port;
    struct fct_cmd_slot *slotp;
    struct fct_cmd_slot slot;
    int i;

    iportp = __ilport2iport((uintptr_t)siport, DCMD_ADDRSPEC, 0, NULL);
    if (iportp == NULL)
        return (DCMD_ERR);

    if (mdb_vread(&iport, sizeof (struct fct_i_local_port),
        (uintptr_t)iportp) != sizeof (struct fct_i_local_port)) {
        mdb_warn("Unable to read in fct_i_local_port\n");
        return (DCMD_ERR);
    }
    if (mdb_vread(&port, sizeof (struct fct_local_port),
        (uintptr_t)iport.iport_port) != sizeof (struct fct_local_port)) {
        mdb_warn("Unable to read in fct_local_port\n");
        return (DCMD_ERR);
    }

    slotp = iport.iport_cmd_slots;
    for (i = 0; i < port.port_max_xchges; i++) {
        if (mdb_vread(&slot, sizeof (struct fct_cmd_slot),
            (uintptr_t)slotp) != sizeof (struct fct_cmd_slot)) {
            mdb_warn("Unable to read in fct_cmd_slot\n");
            return (DCMD_ERR);
        }
        if (slot.slot_cmd != NULL) {
            if (filter == NULL)
                mdb_printf("%p\n", slot.slot_cmd);
            else
                filter(slot.slot_cmd, options, arg);
        }
        slotp ++;
    }

    return (DCMD_OK);
}

/*ARGSUSED*/
static int
stmf_find_tasks(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    struct find_options *options;
    struct stmf_i_local_port *siport;

    options = parse_options(argc, argv);
    if (options == NULL ||
        (options->lpname_defined == 0 && options->rpname_defined == 0)) {
        mdb_printf("lpname=<wwn.12345678> or rpname=<wwn.12345678>"
            " should be specified\n");
        return (DCMD_OK);
    }

    if (options->lpname_defined) {
        siport = find_lport_by_wwn(options->lpname);
        if (siport == NULL)
            return (DCMD_ERR);

        outstanding_cmds_on_lport(siport, print_tasks, options, NULL);
        return (DCMD_OK);
    }

    if (options->rpname_defined) {
        mdb_walk_state_t ws = {NULL, };
        fct_i_remote_port_t *irpp;

        while ((siport = next_stmf_port(&ws)) != NULL) {
            if ((irpp = find_irp_by_wwn(siport, options->rpname))
                != NULL) {
                outstanding_cmds_on_lport(siport,
                    print_tasks_on_rp, options, irpp);
            }
        }
    }

    return (DCMD_OK);
}

/*ARGSUSED*/
static int
fct_find_cmds(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    struct find_options *options;
    struct stmf_i_local_port *siport;

    options = parse_options(argc, argv);
    if (options == NULL || options->lpname_defined == 0) {
        mdb_printf("lpname=<wwn.12345678> should be specified\n");
        return (DCMD_OK);
    }

    siport = find_lport_by_wwn(options->lpname);
    if (siport == NULL)
        return (DCMD_ERR);

    outstanding_cmds_on_lport(siport, print_all_cmds, options, NULL);
    return (DCMD_OK);
}

static int
fct_icmds(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    struct fct_i_local_port iport;
    struct fct_i_cmd icmd;
    struct fct_i_cmd *icmdp;
    int i;
    int verbose = 0;

    for (i = 0; i < argc; i++) {
        char *ptr = (char *)argv[i].a_un.a_str;

        if (ptr[0] == '-')
            ptr++;
        while (*ptr) {
            if (*ptr == 'v')
                verbose = 1;
            ptr++;
        }
    }

    if (!(flags & DCMD_ADDRSPEC)) {
        mdb_warn("fct_i_local_port_t address should be specified");
        return (DCMD_ERR);
    }

    if (mdb_vread(&iport, sizeof (struct fct_i_local_port), addr)
        != sizeof (struct fct_i_local_port)) {
        mdb_warn("Unable to read in fct_i_local_port at %p\n", addr);
        return (DCMD_ERR);
    }

    icmdp = iport.iport_cached_cmdlist;
    while (icmdp) {
        if (mdb_vread(&icmd, sizeof (struct fct_i_cmd),
            (uintptr_t)icmdp) == -1) {
            mdb_warn("failed to read fct_i_cmd at %p", icmdp);
            return (DCMD_ERR);
        }

        mdb_printf("%p\n", icmdp);
        if (verbose) {
            mdb_printf("  fct cmd: %p\n", icmd.icmd_cmd);
        }

        icmdp = icmd.icmd_next;
    }

    return (DCMD_OK);
}

/*
 * Walker to list the addresses of all the active STMF scsi tasks (scsi_task_t),
 * given a stmf_worker address
 *
 * To list all the active STMF scsi tasks, use
 * "::walk stmf_worker |::walk stmf_scsi_task"
 * To list the active tasks of a particular worker, use
 * <stmf_worker addr>::walk stmf_scsi_task
 */
static int
stmf_scsi_task_walk_init(mdb_walk_state_t *wsp)
{
    stmf_worker_t   worker;

    /*
     * Input should be a stmf_worker, so read it to get the
     * worker_task_head to get the start of the task list
     */
    if (wsp->walk_addr == NULL) {
        mdb_warn("<worker addr>::walk stmf_scsi_task\n");
        return (WALK_ERR);
    }

    if (mdb_vread(&worker, sizeof (stmf_worker_t), wsp->walk_addr) !=
        sizeof (stmf_worker_t)) {
        mdb_warn("failed to read in the task address\n");
        return (WALK_ERR);
    }

    wsp->walk_addr = (uintptr_t)(worker.worker_task_head);
    wsp->walk_data = mdb_alloc(sizeof (scsi_task_t), UM_SLEEP);

    return (WALK_NEXT);
}

static int
stmf_scsi_task_walk_step(mdb_walk_state_t *wsp)
{
    stmf_i_scsi_task_t  itask;
    int         status;

    if (wsp->walk_addr == NULL) {
        return (WALK_DONE);
    }

    /* Save the stmf_i_scsi_task for use later to get the next entry */
    if (mdb_vread(&itask, sizeof (stmf_i_scsi_task_t),
        wsp->walk_addr) != sizeof (stmf_i_scsi_task_t)) {
        mdb_warn("failed to read stmf_i_scsi_task at %p",
            wsp->walk_addr);
        return (WALK_DONE);
    }

    wsp->walk_addr = (uintptr_t)itask.itask_task;

    if (mdb_vread(wsp->walk_data, sizeof (scsi_task_t),
        wsp->walk_addr) != sizeof (scsi_task_t)) {
        mdb_warn("failed to read scsi_task_t at %p", wsp->walk_addr);
        return (DCMD_ERR);
    }

    status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
        wsp->walk_cbdata);

    wsp->walk_addr = (uintptr_t)(itask.itask_worker_next);

    return (status);
}

static void
stmf_scsi_task_walk_fini(mdb_walk_state_t *wsp)
{
    mdb_free(wsp->walk_data, sizeof (scsi_task_t));
}

/*ARGSUSED*/
static int
stmf_scsi_task(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    stmf_worker_t       worker;
    stmf_i_scsi_task_t  itask;
    scsi_task_t     *task_addr, task;

    /*
     * A stmf_worker address is given to the left of ::stmf_scsi_task
     * i.e. display the scsi_task for the given worker
     */
    if (!(flags & DCMD_ADDRSPEC)) {
        if (mdb_walk_dcmd("stmf_worker", "stmf_scsi_task", argc,
            argv) == -1) {
            mdb_warn("Failed to walk the stmf_scsi_task entries");
            return (DCMD_ERR);
        }
        return (DCMD_OK);
    }

    if (DCMD_HDRSPEC(flags) && (!(flags & DCMD_PIPE_OUT))) {
        mdb_printf("%<u>%-19s %-10s %-19s%</u>\n",
            "scsi_task_t", "Flags", "LPort");
    }

    if (mdb_vread(&worker, sizeof (stmf_worker_t),
        addr) != sizeof (stmf_worker_t)) {
        mdb_warn("failed to read in the worker address");
        return (DCMD_ERR);
    }

    /* Read the scsi_task */
    if (worker.worker_task_head == NULL) {
        return (DCMD_OK);
    }

    if (mdb_vread(&itask, sizeof (stmf_i_scsi_task_t),
        (uintptr_t)worker.worker_task_head) == -1) {
        mdb_warn("failed to read stmf_i_scsi_task_t at %p",
            worker.worker_task_head);
        return (DCMD_ERR);
    }

    task_addr = itask.itask_task;

    if (mdb_vread(&task, sizeof (scsi_task_t),
        (uintptr_t)task_addr) != sizeof (scsi_task_t)) {
        mdb_warn("failed to read scsi_task_t at %p", task_addr);
        return (DCMD_ERR);
    }

    if ((flags & DCMD_PIPE_OUT)) {
        mdb_printf("%p\n", task_addr);
    } else {
        /* pretty print */
        mdb_printf("%-19p %-10x %-19p\n",
            task_addr, task.task_flags, task.task_lport);
    }

    return (DCMD_OK);
}

/*
 * Walker to list the addresses of all the stmf_worker in the queue
 */
typedef struct stmf_worker_walk_data {
    int     worker_current;
    int     worker_count;
} stmf_worker_walk_data_t;

/* stmf_workers_state definition from stmf.c (static) */
enum {
    STMF_WORKERS_DISABLED = 0,
    STMF_WORKERS_ENABLING,
    STMF_WORKERS_ENABLED
} stmf_workers_state;

/*
 * Initialize the stmf_worker_t walker by either using the given starting
 * address, or reading the value of the kernel's global stmf_workers pointer.
 */
/*ARGSUSED*/
static int
stmf_worker_walk_init(mdb_walk_state_t *wsp)
{
    int         worker_state;
    int         nworkers;
    stmf_worker_t       *worker;
    stmf_worker_walk_data_t *walk_data;

    if (mdb_readvar(&worker_state, "stmf_workers_state") == -1) {
        mdb_warn("failed to read stmf_workers_state");
        return (WALK_ERR);
    }
    if (worker_state != STMF_WORKERS_ENABLED) {
        mdb_warn("stmf_workers_state not initialized");
        return (WALK_ERR);
    }

    /*
     * Look up the stmf_nworkers_accepting_cmds to
     * determine number of entries in the worker queue
     */
    if (mdb_readvar(&nworkers, "stmf_nworkers_accepting_cmds") == -1) {
        mdb_warn("failed to read stmf_nworkers_accepting_cmds");
        return (WALK_ERR);
    }

    if (mdb_readvar(&worker, "stmf_workers") == -1) {
        mdb_warn("failed to read stmf_workers");
        return (WALK_ERR);
    }

    walk_data = mdb_alloc(sizeof (stmf_worker_walk_data_t), UM_SLEEP);
    walk_data->worker_current   = 0;
    walk_data->worker_count     = nworkers;

    wsp->walk_addr = (uintptr_t)worker;
    wsp->walk_data = walk_data;

    return (WALK_NEXT);
}

static int
stmf_worker_walk_step(mdb_walk_state_t *wsp)
{
    stmf_worker_walk_data_t *walk_data = wsp->walk_data;
    int         status;

    if (wsp->walk_addr == NULL) {
        return (WALK_DONE);
    }

    if (walk_data->worker_current >= walk_data->worker_count) {
        return (WALK_DONE);
    }

    status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
        wsp->walk_cbdata);

    walk_data->worker_current++;
    wsp->walk_addr += sizeof (stmf_worker_t);

    return (status);
}

static void
stmf_worker_walk_fini(mdb_walk_state_t *wsp)
{
    mdb_free(wsp->walk_data, sizeof (stmf_worker_walk_data_t));
}

int
stmf_worker(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    stmf_worker_t       worker;

    if (!(flags & DCMD_ADDRSPEC)) {
        if (mdb_walk_dcmd("stmf_worker", "stmf_worker", argc,
            argv) == -1) {
            mdb_warn("Failed to walk the stmf_worker entries");
            return (DCMD_ERR);
        }
        return (DCMD_OK);
    }

    if (mdb_vread(&worker, sizeof (stmf_worker_t),
        addr) != sizeof (stmf_worker_t)) {
        mdb_warn("failed to read stmf_worker at %p", addr);
        return (DCMD_ERR);
    }

    if (flags & DCMD_PIPE_OUT) {
        mdb_printf("%-19p\n", addr);
    } else {
        /* pretty print */
        if (DCMD_HDRSPEC(flags)) {
            mdb_printf("%<u>%-19s %-10s %-10s %-10s%</u>\n",
                "stmf_worker_t", "State", "Ref_Count", "Tasks");
        }

        mdb_printf("%-19p %-10s %-10d %-5d%\n", addr,
            (worker.worker_flags == STMF_WORKER_STARTED) ? "STARTED" :
            (worker.worker_flags & STMF_WORKER_ACTIVE) ?
            "ACTIVE" : "TERMINATED",
            worker.worker_ref_count,
            worker.worker_queue_depth);
    }

    return (DCMD_OK);
}

struct find_options *
parse_options(int argc, const mdb_arg_t *argv)
{
    int i;
    struct find_options *options;
    int len;
    char *ptr;
    int ret;

    if (argc == 0)
        return (NULL);
    options = mdb_zalloc(sizeof (struct find_options), UM_SLEEP);
    for (i = 0; i < argc; i++) {
        switch (argv[i].a_type) {
        case MDB_TYPE_STRING:
            break;
        case MDB_TYPE_IMMEDIATE:
        case MDB_TYPE_CHAR:
            mdb_printf("unknown type\n");
        }
        if ((ptr = strchr(argv[i].a_un.a_str, '=')) == NULL) {
            mdb_printf("invalid argument: %s\n",
                argv[i].a_un.a_str);
            goto out;
        }
        len = ptr - argv[i].a_un.a_str;
        ptr++;  /* point to value now */

        if (len == strlen("lpname") &&
            strncmp(argv[i].a_un.a_str, "lpname", len) == 0) {
            if (strstr(ptr, "wwn.") == ptr)
                ptr += 4;
            ret = string2wwn(ptr, options->lpname);
            if (ret == -1)
                goto out;
#if 0
    mdb_printf("wwn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
        wwn[0], wwn[1], wwn[2], wwn[3], wwn[4], wwn[5], wwn[6], wwn[7]);
#endif
            options->lpname_defined = 1;

        } else if (len == strlen("rp") &&
            strncmp(argv[i].a_un.a_str, "rp", len) == 0) {
            options->rp_defined = 1;
            options->rp =
                (void *)(unsigned long)mdb_strtoull(ptr);

        } else if (len == strlen("rpname") &&
            strncmp(argv[i].a_un.a_str, "rpname", len) == 0) {
            if (strstr(ptr, "wwn.") == ptr)
                ptr += 4;
            ret = string2wwn(ptr, options->rpname);
            if (ret == -1)
                goto out;
            options->rpname_defined = 1;

        } else if (len == strlen("show") &&
            strncmp(argv[i].a_un.a_str, "show", len) == 0) {
            char *s;
            int l;

            for (;;) {
                s = strchr(ptr, ',');
                if (s)
                    l = s - ptr;
                else
                    l = strlen(ptr);
                if (l == strlen("task_flags") &&
                    strncmp(ptr, "task_flags", l) == 0)
                    options->show_task_flags = 1;
                else if (l == strlen("lport") &&
                    strncmp(ptr, "lport", l) == 0)
                    options->show_lport = 1;
                else {
                    mdb_printf("unknown shower: %s\n",
                        ptr);
                    goto out;
                }
                if (s == NULL)
                    break;
                ptr = s + 1;
            }
        } else {
            mdb_printf("unknown argument: %s\n",
                argv[i].a_un.a_str);
            goto out;
        }
    }

    return (options);
out:
    mdb_free(options, sizeof (struct find_options));
    return (NULL);
}

int
string2wwn(const char *s, uint8_t wwn[8])
{
    int i;
    char tmp[17];
    char *p;

    if (strlen(s) > 16) {
        mdb_printf("invalid wwn %s\n", s);
        return (-1);
    }

    strcpy(tmp, s);
    p = tmp + strlen(tmp) - 2;
    memset(wwn, 0, 8);
    /* figure out wwn from the tail to beginning */
    for (i = 7; i >= 0 && p >= tmp; i--, p -= 2) {
        wwn[i] = mdb_strtoull(p);
        *p = 0;
    }
    return (0);
}

void
fct_find_cmds_help(void)
{
    mdb_printf(
        "Find all cached fct_i_cmd_t for a local port. If a local port \n"
        "name is specified, find all pending cmds for it and print the \n"
        "address. Example:\n"
        "    fct_find_cmds lpname=<wwn.12345678 or 12345678>\n");
}
void
stmf_find_ilport_help(void)
{
    mdb_printf(
        "Find the fct_i_local_port if local port name is "
        "specified. Example:\n"
        "    stmf_find_ilport lpname=<wwn.12345678 or 12345678>\n");
}
void
stmf_find_fct_irp_help(void)
{
    mdb_printf(
        "If a remote port name or stmf_i_remote_port_t address is\n"
        "specified, loop through all local ports, to which this remote \n"
        "port has logged in, print address for stmf_i_local_port_t and \n"
        "stmf_i_remote_port. Example:\n"
        "    stmf_find_fct_irp rpname=<wwn.12345678 or 12345678>\n"
        "    stmf_find_fct_irp rp=<3000586778734>\n");
}

void
stmf_find_tasks_help(void)
{
    mdb_printf(
        "Find all pending scsi_task_t for a given local port and/or\n"
        "remote port. Various different fields for each task are printed\n"
        "depending on what is requested. Example:\n"
        "    stmf_find_tasks rpname=<wwn.12345678 or 12345678>\n"
        "    stmf_find_tasks lpname=<wwn.12345678 or 12345678> "
        "show=task_flags,lport\n");
}

void
stmf_scsi_task_help(void)
{
    mdb_printf(
        "List all active scsi_task_t on a given stmf_worker_t. Example\n"
        "    addr::stmf_scsi_task\n");
}

static const mdb_dcmd_t dcmds[] = {
    { "stmf_ilports", "[-v]",
        "Print a list of stmf_i_local_port", stmf_ilports },
    { "ilport2iport", "?[-v]",
        "Convert stmf_i_local_port to corresponding fct_i_local_port",
        ilport2iport },
    { "stmf_iss", "?[-v]",
        "List all active sessions for a given local port",
        stmf_iss },
    { "stmf_ilus", "[-v]", "Print a list of stmf_i_lu", stmf_ilus },
    { "stmf_i_lu_providers", "[-v]",
        "Print a list of stmf_i_lu_provider", stmf_i_lu_providers },
    { "stmf_i_port_providers", "[-v]",
        "Print a list of stmf_i_port_provider", stmf_i_port_providers },
    { "fct_irps", "?[-v]",
        "Print all fct_i_remote_port for a given fct_i_local_port",
        fct_irps },
    { "fct_icmds", "?[-v]",
        "Print all cached fct_i_cmd_t on fct_i_local_port",
        fct_icmds },
    { "fct_find_cmds", "lpname",
        "Find all fct_i_cmd_t for a given local port",
        fct_find_cmds, fct_find_cmds_help},
    { "stmf_find_ilport", "lpname",
        "Find local port information based on its wwn",
        stmf_find_ilport, stmf_find_ilport_help},
    { "stmf_find_fct_irp", "rpname|rp",
        "Print fct remote port information based on its wwn",
        stmf_find_fct_irp, stmf_find_fct_irp_help},
    { "stmf_find_tasks", "lpname|rpname [show]",
        "Find all pending task for a local port or remote port",
        stmf_find_tasks, stmf_find_tasks_help},
    { "stmf_worker", "?", "List all the stmf_worker entries", stmf_worker},
    { "stmf_scsi_task", ":",
        "List all the active STMF SCSI tasks per worker", stmf_scsi_task,
        stmf_scsi_task_help},
    { NULL }
};

static const mdb_walker_t walkers[] = {
    { "stmf_worker", "Walk STMF worker queue", stmf_worker_walk_init,
        stmf_worker_walk_step, stmf_worker_walk_fini},
    { "stmf_scsi_task", "Walk active STMF SCSI tasks per worker",
        stmf_scsi_task_walk_init,
        stmf_scsi_task_walk_step, stmf_scsi_task_walk_fini },
    { NULL }
};

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

const mdb_modinfo_t *
_mdb_init(void)
{
    return (&modinfo);
}