xref: /onnv-gate/usr/src/cmd/mdb/common/modules/crypto/impl.c (revision 8384)

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

/*
 * mdb dcmds for selected structures from
 * usr/src/uts/common/sys/crypto/impl.h
 */
#include <stdio.h>
#include <sys/mdb_modapi.h>
#include <sys/modctl.h>
#include <sys/types.h>
#include <sys/crypto/api.h>
#include <sys/crypto/common.h>
#include <sys/crypto/impl.h>
#include "crypto_cmds.h"

int
kcf_sched_info(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	kcf_sched_info_t sched;
	kcf_sched_info_t *sinfo = &sched;

	if (!(flags & DCMD_ADDRSPEC)) {
		if ((argc == 1) && (argv->a_type == MDB_TYPE_IMMEDIATE))
			sinfo = (kcf_sched_info_t *)(uintptr_t)argv->a_un.a_val;
		else
			return (DCMD_USAGE);
	} else if (addr == NULL)	/* not allowed with DCMD_ADDRSPEC */
		return (DCMD_USAGE);
	else {
		if (mdb_vread(sinfo, sizeof (kcf_sched_info_t), addr) == -1) {
			mdb_warn("cannot read %p", addr);
			return (DCMD_ERR);
		}
	}
	mdb_printf("ks_ndispatches:\t%llu\n", sinfo->ks_ndispatches);
	mdb_printf("ks_nfails:\t%llu\n", sinfo->ks_nfails);
	mdb_printf("ks_nbusy_rval:\t%llu\n", sinfo->ks_nbusy_rval);
	mdb_printf("ks_ntaskq:\t%p\n", sinfo->ks_taskq);
	return (DCMD_OK);
}

static const char *prov_states[] = {
	"none",
	"KCF_PROV_ALLOCATED",
	"KCF_PROV_UNVERIFIED",
	"KCF_PROV_VERIFICATION_FAILED",
	"KCF_PROV_READY",
	"KCF_PROV_BUSY",
	"KCF_PROV_FAILED",
	"KCF_PROV_DISABLED",
	"KCF_PROV_REMOVED",
	"KCF_PROV_FREED"
};

static void
pr_kstat_named(kstat_named_t *ks)
{
	mdb_inc_indent(4);

	mdb_printf("name = %s\n", ks->name);
	mdb_printf("value = ");

	/*
	 * The only data type used for the provider kstats is uint64.
	 */
	switch (ks->data_type) {
	case KSTAT_DATA_UINT64:
#if defined(_LP64) || defined(_LONGLONG_TYPE)
		mdb_printf("%llu\n", ks->value.ui64);
#endif
		break;
	default:
		mdb_warn("Incorrect data type for kstat.\n");
	}

	mdb_dec_indent(4);
}

/*ARGSUSED*/
int
kcf_provider_desc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	kcf_provider_desc_t desc;
	kcf_provider_desc_t *ptr;
	char string[MAXNAMELEN + 1];
	int i, j;
	crypto_mech_info_t *mech_pointer;
	mdb_arg_t arg;

	if ((flags & DCMD_ADDRSPEC) != DCMD_ADDRSPEC)
		return (DCMD_USAGE);
	ptr = (kcf_provider_desc_t *)addr;

#ifdef DEBUG
	mdb_printf("DEBUG: reading kcf_provider_desc at %p\n", ptr);
#endif

	if (mdb_vread(&desc, sizeof (kcf_provider_desc_t), (uintptr_t)ptr)
	    == -1) {
		mdb_warn("cannot read at address %p", (uintptr_t)ptr);
		return (DCMD_ERR);
	}
	mdb_printf("%<b>kcf_provider_desc at %p%</b>\n", ptr);

	switch (desc.pd_prov_type) {
	case CRYPTO_HW_PROVIDER:
		mdb_printf("pd_prov_type:\t\tCRYPTO_HW_PROVIDER\n");
		break;
	case CRYPTO_SW_PROVIDER:
		mdb_printf("pd_prov_type:\t\tCRYPTO_SW_PROVIDER\n");
		break;
	case CRYPTO_LOGICAL_PROVIDER:
		mdb_printf("pd_prov_type:\t\tCRYPTO_LOGICAL_PROVIDER\n");
		break;
	default:
		mdb_printf("bad pd_prov_type:\t%d\n", desc.pd_prov_type);
	}

	mdb_printf("pd_prov_handle:\t\t%p\n", desc.pd_prov_handle);
	mdb_printf("pd_kcf_prov_handle:\t%u\n", desc.pd_kcf_prov_handle);
	mdb_printf("pd_prov_id:\t\t%u\n", desc.pd_prov_id);
	if (desc.pd_description == NULL)
		mdb_printf("pd_description:\t\tNULL\n");
	else if (mdb_readstr(string, MAXNAMELEN + 1,
	    (uintptr_t)desc.pd_description) == -1) {
		mdb_warn("cannot read %p", desc.pd_description);
	} else
		mdb_printf("pd_description:\t\t%s\n", string);

	mdb_printf("pd_ops_vector:\t\t%p\n", desc.pd_ops_vector);
	mdb_printf("pd_mech_list_count:\t%u\n", desc.pd_mech_list_count);
	/* mechanisms */
	mdb_inc_indent(4);
	for (i = 0; i < desc.pd_mech_list_count; i++) {
		mech_pointer = desc.pd_mechanisms + i;
		mdb_call_dcmd("crypto_mech_info",
		    (uintptr_t)mech_pointer, DCMD_ADDRSPEC, 0, NULL);
	}
	mdb_dec_indent(4);
	mdb_printf("pd_mech_indx:\n");
	mdb_inc_indent(8);
	for (i = 0; i < KCF_OPS_CLASSSIZE; i++) {
		for (j = 0; j < KCF_MAXMECHTAB; j++) {
			if (desc.pd_mech_indx[i][j] == KCF_INVALID_INDX)
				mdb_printf("N ");
			else
				mdb_printf("%u ", desc.pd_mech_indx[i][j]);
		}
		mdb_printf("\n");
	}
	mdb_dec_indent(8);
	mdb_printf("pd_ks_data.ps_ops_total:\n", desc.pd_ks_data.ps_ops_total);
	pr_kstat_named(&desc.pd_ks_data.ps_ops_total);
	mdb_printf("pd_ks_data.ps_ops_passed:\n",
	    desc.pd_ks_data.ps_ops_passed);
	pr_kstat_named(&desc.pd_ks_data.ps_ops_passed);
	mdb_printf("pd_ks_data.ps_ops_failed:\n",
	    desc.pd_ks_data.ps_ops_failed);
	pr_kstat_named(&desc.pd_ks_data.ps_ops_failed);
	mdb_printf("pd_ks_data.ps_ops_busy_rval:\n",
	    desc.pd_ks_data.ps_ops_busy_rval);
	pr_kstat_named(&desc.pd_ks_data.ps_ops_busy_rval);

	mdb_printf("pd_kstat:\t\t%p\n", desc.pd_kstat);
	mdb_printf("kcf_sched_info:\n");
	/* print pd_sched_info via existing function */
	mdb_inc_indent(8);
	arg.a_type = MDB_TYPE_IMMEDIATE;
	arg.a_un.a_val = (uintmax_t)(uintptr_t)&desc.pd_sched_info;
	mdb_call_dcmd("kcf_sched_info", (uintptr_t)NULL, 0, 1, &arg);
	mdb_dec_indent(8);

	mdb_printf("pd_refcnt:\t\t%u\n", desc.pd_refcnt);
	if (desc.pd_name == NULL)
		mdb_printf("pd_name:\t\t NULL\n");
	else if (mdb_readstr(string, MAXNAMELEN + 1, (uintptr_t)desc.pd_name)
	    == -1)
		mdb_warn("could not read pd_name from %X\n", desc.pd_name);
	else
		mdb_printf("pd_name:\t\t%s\n", string);

	mdb_printf("pd_instance:\t\t%u\n", desc.pd_instance);
	mdb_printf("pd_module_id:\t\t%d\n", desc.pd_module_id);
	mdb_printf("pd_mctlp:\t\t%p\n", desc.pd_mctlp);
	mdb_printf("pd_sid:\t\t\t%u\n", desc.pd_sid);
	mdb_printf("pd_lock:\t\t%p\n", desc.pd_lock);
	if (desc.pd_state < KCF_PROV_ALLOCATED ||
	    desc.pd_state > KCF_PROV_FREED)
		mdb_printf("pd_state is invalid:\t%d\n", desc.pd_state);
	else
		mdb_printf("pd_state:\t%s\n", prov_states[desc.pd_state]);

	mdb_printf("pd_resume_cv:\t\t%hd\n", desc.pd_resume_cv._opaque);
	mdb_printf("pd_remove_cv:\t\t%hd\n", desc.pd_remove_cv._opaque);
	mdb_printf("pd_flags:\t\t%s %s %s %s %s\n",
	    (desc.pd_flags & CRYPTO_HIDE_PROVIDER) ?
	    "CRYPTO_HIDE_PROVIDER" : " ",
	    (desc.pd_flags & CRYPTO_HASH_NO_UPDATE) ?
	    "CRYPTO_HASH_NO_UPDATE" : " ",
	    (desc.pd_flags & CRYPTO_SYNCHRONOUS) ?
	    "CRYPTO_SYNCHRONOUS" : " ",
	    (desc.pd_flags & KCF_LPROV_MEMBER) ?
	    "KCF_LPROV_MEMBER" : " ",
	    (desc.pd_flags & KCF_PROV_RESTRICTED) ?
	    "KCF_PROV_RESTRICTED" : " ");
	if (desc.pd_flags & CRYPTO_HASH_NO_UPDATE)
		mdb_printf("pd_hash_limit:\t\t%u\n", desc.pd_hash_limit);
	mdb_printf("pd_provider_list:\t%p\n", desc.pd_provider_list);
	return (DCMD_OK);
}

#define	GOT_NONE	(-2)

/*ARGSUSED*/
int
prov_tab(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	kcf_provider_desc_t **tab;
	kcf_provider_desc_t desc;
	kcf_provider_desc_t *ptr;
	uint_t prov_tab_max;
	int i;
	int gotzero = GOT_NONE;
	char string[MAXNAMELEN + 1];

	if ((flags & DCMD_ADDRSPEC) == DCMD_ADDRSPEC) {
		return (DCMD_USAGE);
	} else if (mdb_readsym(&ptr, sizeof (void *), "prov_tab")
	    == -1) {
		mdb_warn("cannot read prov_tab");
		return (DCMD_ERR);

	} else if (mdb_readvar(&prov_tab_max, "prov_tab_max") == -1) {
		mdb_warn("cannot read prov_tab_max");
		return (DCMD_ERR);
	}
	mdb_printf("%<b>prov_tab = %p%</b>\n", ptr);
	tab = mdb_zalloc(prov_tab_max * sizeof (kcf_provider_desc_t *),
	    UM_SLEEP| UM_GC);

#ifdef DEBUG
	mdb_printf("DEBUG: tab = %p, prov_tab_max = %d\n", tab, prov_tab_max);
#endif

	if (mdb_vread(tab, prov_tab_max * sizeof (kcf_provider_desc_t *),
	    (uintptr_t)ptr) == -1) {
		mdb_warn("cannot read prov_tab");
		return (DCMD_ERR);
	}
#ifdef DEBUG
	mdb_printf("DEBUG: got past mdb_vread of tab\n");
	mdb_printf("DEBUG: *tab = %p\n", *tab);
#endif
	for (i = 0;  i <  prov_tab_max; i++) {
		/* save space, only print range for long list of nulls */
		if (tab[i] == NULL) {
			if (gotzero == GOT_NONE) {
				mdb_printf("prov_tab[%d", i);
				gotzero = i;
			}
		} else {
			/* first non-null in awhile, print index of prev null */
			if (gotzero != GOT_NONE) {
				if (gotzero == (i - 1))
					mdb_printf("] = NULL\n", i - 1);
				else
					mdb_printf(" - %d] = NULL\n", i - 1);
				gotzero = GOT_NONE;
			}
			/* interesting value, print it */
			mdb_printf("prov_tab[%d] = %p ", i, tab[i]);

			if (mdb_vread(&desc, sizeof (kcf_provider_desc_t),
			    (uintptr_t)tab[i]) == -1) {
				mdb_warn("cannot read at address %p",
				    (uintptr_t)tab[i]);
				return (DCMD_ERR);
			}

			(void) mdb_readstr(string, MAXNAMELEN + 1,
			    (uintptr_t)desc.pd_name);
			mdb_printf("(%s\t%s)\n", string,
			    prov_states[desc.pd_state]);
		}
	}
	/* if we've printed the first of many nulls but left the brace open */
	if ((i > 0) && (tab[i-1] == NULL)) {
		if (gotzero == GOT_NONE)
			mdb_printf("] = NULL\n");
		else
			mdb_printf(" - %d] = NULL\n", i - 1);
	}

	return (DCMD_OK);
}

/*ARGSUSED*/
int
policy_tab(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	kcf_policy_desc_t **tab;
	kcf_policy_desc_t *ptr;
	uint_t policy_tab_max;
	int num, i;
	int gotzero = GOT_NONE;

	if ((flags & DCMD_ADDRSPEC) == DCMD_ADDRSPEC) {
		return (DCMD_USAGE);
	} else if (mdb_readsym(&ptr, sizeof (void *), "policy_tab")
	    == -1) {
		mdb_warn("cannot read policy_tab");
		return (DCMD_ERR);

	} else if (mdb_readvar(&policy_tab_max, "policy_tab_max") == -1) {
		mdb_warn("cannot read policy_tab_max");
		return (DCMD_ERR);
	}

	/* get the current number of descriptors in the table */
	if (mdb_readvar(&num, "policy_tab_num") == -1) {
		mdb_warn("cannot read policy_tab_num");
		return (DCMD_ERR);
	}
	mdb_printf("%<b>policy_tab = %p%</b> \tpolicy_tab_num = %d\n",
	    ptr, num);

	tab = mdb_zalloc(policy_tab_max * sizeof (kcf_policy_desc_t *),
	    UM_SLEEP| UM_GC);

	if (mdb_vread(tab, policy_tab_max * sizeof (kcf_policy_desc_t *),
	    (uintptr_t)ptr) == -1) {
		mdb_warn("cannot read policy_tab");
		return (DCMD_ERR);
	}
#ifdef DEBUG
	mdb_printf("DEBUG: got past mdb_vread of tab\n");
	mdb_printf("DEBUG: *tab = %p\n", *tab);
#endif
	for (i = 0;  i < policy_tab_max; i++) {
		/* save space, only print range for long list of nulls */
		if (tab[i] == NULL) {
			if (gotzero == GOT_NONE) {
				mdb_printf("policy_tab[%d", i);
				gotzero = i;
			}
		} else {
			/* first non-null in awhile, print index of prev null */
			if (gotzero != GOT_NONE) {
				if (gotzero == (i - 1))
					mdb_printf("] = NULL\n", i - 1);
				else
					mdb_printf(" - %d] = NULL\n", i - 1);
				gotzero = GOT_NONE;
			}
			/* interesting value, print it */
			mdb_printf("policy_tab[%d] = %p\n", i, tab[i]);
		}
	}
	/* if we've printed the first of many nulls but left the brace open */
	if ((i > 0) && (tab[i-1] == NULL)) {
		if (gotzero == GOT_NONE)
			mdb_printf("] = NULL\n");
		else
			mdb_printf(" - %d] = NULL\n", i - 1);
	}

	return (DCMD_OK);
}

static void
prt_mechs(int count, crypto_mech_name_t *mechs)
{
	int i;
	char name[CRYPTO_MAX_MECH_NAME + 1];
	char name2[CRYPTO_MAX_MECH_NAME + 3];

	for (i = 0; i < count; i++) {
		if (mdb_readstr(name, CRYPTO_MAX_MECH_NAME,
		    (uintptr_t)((char *)mechs)) == -1)
			continue;
		/* put in quotes */
		(void) mdb_snprintf(name2, sizeof (name2), "\"%s\"", name);
		/* yes, length is 32, but then it will wrap */
		/* this shorter size formats nicely for most cases */
		mdb_printf("mechs[%d]=%-28s", i, name2);
		mdb_printf("%s", i%2 ? "\n" : "  "); /* 2-columns */
		mechs++;
	}
}

/* ARGSUSED2 */
static int
prt_soft_conf_entry(kcf_soft_conf_entry_t *addr, kcf_soft_conf_entry_t *entry,
    void *cbdata)
{
	char name[MAXNAMELEN + 1];

	mdb_printf("\n%<b>kcf_soft_conf_entry_t at %p:%</b>\n", addr);
	mdb_printf("ce_next: %p", entry->ce_next);

	if (entry->ce_name == NULL)
		mdb_printf("\tce_name: NULL\n");
	else if (mdb_readstr(name, MAXNAMELEN, (uintptr_t)entry->ce_name)
	    == -1)
		mdb_printf("could not read ce_name from %p\n",
		    entry->ce_name);
	else
		mdb_printf("\tce_name: %s\n", name);

	mdb_printf("ce_count: %d\n", entry->ce_count);
	prt_mechs(entry->ce_count, entry->ce_mechs);
	return (WALK_NEXT);
}

int
soft_conf_walk_init(mdb_walk_state_t *wsp)
{
	uintptr_t *soft;

	if (mdb_readsym(&soft, sizeof (kcf_soft_conf_entry_t *),
	    "soft_config_list") == -1) {
		mdb_warn("failed to find 'soft_config_list'");
		return (WALK_ERR);
	}
	wsp->walk_addr = (uintptr_t)soft;
	wsp->walk_data = mdb_alloc(sizeof (kcf_soft_conf_entry_t), UM_SLEEP);
	wsp->walk_callback = (mdb_walk_cb_t)prt_soft_conf_entry;
	return (WALK_NEXT);
}

/*
 * At each step, read a kcf_soft_conf_entry_t into our private storage, then
 * invoke the callback function.  We terminate when we reach a NULL ce_next
 * pointer.
 */
int
soft_conf_walk_step(mdb_walk_state_t *wsp)
{
	int status;

	if (wsp->walk_addr == NULL)	/* then we're done */
		return (WALK_DONE);
#ifdef DEBUG
	else
		mdb_printf("DEBUG: wsp->walk_addr == %p\n", wsp->walk_addr);
#endif

	if (mdb_vread(wsp->walk_data, sizeof (kcf_soft_conf_entry_t),
	    wsp->walk_addr) == -1) {
		mdb_warn("failed to read kcf_soft_conf_entry at %p",
		    wsp->walk_addr);
		return (WALK_DONE);
	}

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

	wsp->walk_addr =
	    (uintptr_t)(((kcf_soft_conf_entry_t *)wsp->walk_data)->ce_next);
	return (status);
}

/*
 * The walker's fini function is invoked at the end of each walk.  Since we
 * dynamically allocated a kcf_soft_conf_entry_t in soft_conf_walk_init,
 * we must free it now.
 */
void
soft_conf_walk_fini(mdb_walk_state_t *wsp)
{
#ifdef	DEBUG
	mdb_printf("...end of kcf_soft_conf_entry walk\n");
#endif
	mdb_free(wsp->walk_data, sizeof (kcf_soft_conf_entry_t));
}
/* ARGSUSED2 */
int
kcf_soft_conf_entry(uintptr_t addr, uint_t flags, int argc,
    const mdb_arg_t *argv)
{
	kcf_soft_conf_entry_t entry;
	kcf_soft_conf_entry_t *ptr;

	if ((flags & DCMD_ADDRSPEC) == DCMD_ADDRSPEC) {
		if (addr == NULL) 	/* not allowed with DCMD_ADDRSPEC */
			return (DCMD_USAGE);
		else
			ptr = (kcf_soft_conf_entry_t *)addr;
	} else if (mdb_readsym(&ptr, sizeof (void *), "soft_config_list")
	    == -1) {
		mdb_warn("cannot read soft_config_list");
		return (DCMD_ERR);
	} else
		mdb_printf("soft_config_list = %p\n", ptr);

	if (ptr == NULL)
		return (DCMD_OK);

	if (mdb_vread(&entry, sizeof (kcf_soft_conf_entry_t), (uintptr_t)ptr)
	    == -1) {
		mdb_warn("cannot read at address %p", (uintptr_t)ptr);
		return (DCMD_ERR);
	}

	/* this could change in the future to have more than one ret val */
	if (prt_soft_conf_entry(ptr, &entry, NULL) != WALK_ERR)
		return (DCMD_OK);
	return (DCMD_ERR);
}

/* ARGSUSED1 */
int
kcf_policy_desc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	kcf_policy_desc_t  desc;
	char name[MAXNAMELEN + 1];


	if ((flags & DCMD_ADDRSPEC) != DCMD_ADDRSPEC)
		return (DCMD_USAGE);

	if (mdb_vread(&desc, sizeof (kcf_policy_desc_t), (uintptr_t)addr)
	    == -1) {
		mdb_warn("Could not read kcf_policy_desc_t at %p\n", addr);
		return (DCMD_ERR);
	}
	mdb_printf("pd_prov_type:  %s",
	    desc.pd_prov_type == CRYPTO_HW_PROVIDER ? "CRYPTO_HW_PROVIDER" :
	    "CRYPTO_SW_PROVIDER");

	if (desc.pd_name == NULL)
		mdb_printf("\tpd_name: NULL\n");
	else if (mdb_readstr(name, MAXNAMELEN, (uintptr_t)desc.pd_name)
	    == -1)
		mdb_printf("could not read pd_name from %p\n",
		    desc.pd_name);
	else
		mdb_printf("\tpd_name: %s\n", name);

	mdb_printf("pd_instance: %d ", desc.pd_instance);
	mdb_printf("\t\tpd_refcnt: %d\n", desc.pd_refcnt);
	mdb_printf("pd_mutex: %p", desc.pd_mutex);
	mdb_printf("\t\tpd_disabled_count: %d", desc.pd_disabled_count);
	mdb_printf("\npd_disabled_mechs:\n");
	mdb_inc_indent(4);
	prt_mechs(desc.pd_disabled_count, desc.pd_disabled_mechs);
	mdb_dec_indent(4);
	return (DCMD_OK);
}