xref: /illumos-gate/usr/src/uts/common/crypto/core/kcf_callprov.c (revision 9b009fc1)

/*
 * 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) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * This file contains routines which call into a provider's
 * entry points and do other related work.
 */

#include <sys/types.h>
#include <sys/systm.h>
#include <sys/taskq_impl.h>
#include <sys/cmn_err.h>

#include <sys/crypto/common.h>
#include <sys/crypto/impl.h>
#include <sys/crypto/sched_impl.h>

#include <sys/sdt.h>

/*
 * Return B_TRUE if the specified entry point is NULL. We rely on the
 * caller to provide, with offset_1 and offset_2, information to calculate
 * the location of the entry point. The ops argument is a temporary local
 * variable defined as caddr_t *.
 */
#define	KCF_PROV_NULL_ENTRY_POINT(pd, o1, o2, ops)			\
	(ops = (caddr_t *)(void *)((caddr_t)(pd)->pd_ops_vector + (o1)), \
	(*ops == NULL || *(caddr_t *)(void *)((caddr_t)(*ops) + (o2)) == NULL))


static int kcf_emulate_dual(kcf_provider_desc_t *, crypto_ctx_t *,
    kcf_req_params_t *);

void
kcf_free_triedlist(kcf_prov_tried_t *list)
{
	kcf_prov_tried_t *l;

	while ((l = list) != NULL) {
		list = list->pt_next;
		KCF_PROV_REFRELE(l->pt_pd);
		kmem_free(l, sizeof (kcf_prov_tried_t));
	}
}

/*
 * The typical caller of this routine does a kcf_get_mech_provider()
 * which holds the provider and then calls this routine. So, for the
 * common case (no KCF_HOLD_PROV flag) we skip doing a KCF_PROV_REFHOLD.
 */
kcf_prov_tried_t *
kcf_insert_triedlist(kcf_prov_tried_t **list, kcf_provider_desc_t *pd,
    int flags)
{
	kcf_prov_tried_t *l;

	l = kmem_alloc(sizeof (kcf_prov_tried_t),
	    flags & (KM_SLEEP | KM_NOSLEEP));
	if (l == NULL)
		return (NULL);

	if (flags & KCF_HOLD_PROV)
		KCF_PROV_REFHOLD(pd);
	l->pt_pd = pd;
	l->pt_next = *list;
	*list = l;

	return (l);
}

static boolean_t
is_in_triedlist(kcf_provider_desc_t *pd, kcf_prov_tried_t *triedl)
{
	while (triedl != NULL) {
		if (triedl->pt_pd == pd)
			return (B_TRUE);
		triedl = triedl->pt_next;
	};

	return (B_FALSE);
}

/*
 * Check if the key/attribute length is within the limits of given provider
 * and mechanism. Return 0 if the key length is off the limits, 1 otherwise.
 * In the latter case, this either means the key length is within the limits
 * or we are not able to perform check for a key type.
 */
static int
kcf_check_prov_mech_keylen(kcf_provider_desc_t *provider,
	crypto_mech_type_t mech_type,
	crypto_key_t *key)
{
	crypto_mech_info_t *mech_info = NULL;
	size_t keylen = 0;
	ssize_t attr_len;
	uchar_t *attr;

	mech_info = &(KCF_TO_PROV_MECHINFO(provider, mech_type));
	switch (key->ck_format) {
		case CRYPTO_KEY_RAW:
			/* ck_length is always in bits */
			if (mech_info->cm_mech_flags &
			    CRYPTO_KEYSIZE_UNIT_IN_BYTES)
				keylen = CRYPTO_BITS2BYTES(key->ck_length);
			else
				keylen = key->ck_length;
			break;

		case CRYPTO_KEY_ATTR_LIST:
			/* Check modulus for RSA operations. */
			if ((crypto_get_key_attr(key, SUN_CKA_MODULUS,
			    &attr, &attr_len)) == CRYPTO_SUCCESS) {
				/* modulus length is returned in bytes */
				if (mech_info->cm_mech_flags &
				    CRYPTO_KEYSIZE_UNIT_IN_BITS)
					keylen = CRYPTO_BYTES2BITS(attr_len);
				else
					keylen = attr_len;
			/* Check prime for DH/DSA operations. */
			} else if ((crypto_get_key_attr(key, SUN_CKA_PRIME,
			    &attr, &attr_len)) == CRYPTO_SUCCESS) {
				/* prime length is returned in bytes */
				if (mech_info->cm_mech_flags &
				    CRYPTO_KEYSIZE_UNIT_IN_BITS)
					keylen = CRYPTO_BYTES2BITS(attr_len);
				else
					keylen = attr_len;
			}

			/*
			 * If the attribute is not found we cannot do
			 * the check so return with success and let
			 * the actual provider do the check.
			 */
			if (keylen == 0)
				return (1);
			break;

		default:
			/*
			 * We are not able to check CRYPTO_KEY_REFERENCE
			 * or other key types here.
			 */
			return (1);
	}

	DTRACE_PROBE4(keylen__check,
	    crypto_mech_type_t, mech_type,
	    size_t, keylen,
	    ssize_t, mech_info->cm_min_key_length,
	    ssize_t, mech_info->cm_max_key_length);
	/* Do the actual check. */
	if ((keylen > mech_info->cm_max_key_length) ||
	    (keylen < mech_info->cm_min_key_length)) {
		return (0);
	}

	return (1);
}

/*
 * Search a mech entry's hardware provider list for the specified
 * provider. Return true if found.
 */
static boolean_t
is_valid_provider_for_mech(kcf_provider_desc_t *pd, kcf_mech_entry_t *me,
    crypto_func_group_t fg)
{
	kcf_prov_mech_desc_t *prov_chain;

	prov_chain = me->me_hw_prov_chain;
	if (prov_chain != NULL) {
		ASSERT(me->me_num_hwprov > 0);
		for (; prov_chain != NULL; prov_chain = prov_chain->pm_next) {
			if (prov_chain->pm_prov_desc == pd &&
			    IS_FG_SUPPORTED(prov_chain, fg)) {
				return (B_TRUE);
			}
		}
	}
	return (B_FALSE);
}

/*
 * This routine, given a logical provider, returns the least loaded
 * provider belonging to the logical provider. The provider must be
 * able to do the specified mechanism, i.e. check that the mechanism
 * hasn't been disabled. In addition, just in case providers are not
 * entirely equivalent, the provider's entry point is checked for
 * non-nullness. This is accomplished by having the caller pass, as
 * arguments, the offset of the function group (offset_1), and the
 * offset of the function within the function group (offset_2).
 *
 * If a non-NULL key structure is supplied, the provider will be checked
 * to see if the key length falls into the limits of given mechanism
 * for that provider. This is done for both key structures and mechanisms.
 *
 * Returns NULL if no provider can be found.
 */
int
kcf_get_hardware_provider(crypto_mech_type_t mech_type_1, crypto_key_t *key1,
    crypto_mech_type_t mech_type_2, crypto_key_t *key2,
    kcf_provider_desc_t *old, kcf_provider_desc_t **new, crypto_func_group_t fg)
{
	kcf_provider_desc_t *provider, *real_pd = old;
	kcf_provider_desc_t *gpd = NULL;	/* good provider */
	kcf_provider_desc_t *bpd = NULL;	/* busy provider */
	kcf_provider_list_t *p;
	kcf_ops_class_t class;
	kcf_mech_entry_t *me;
	kcf_mech_entry_tab_t *me_tab;
	int index, len, gqlen = INT_MAX, rv = CRYPTO_SUCCESS;
	kcf_lock_withpad_t *mp;

	/* get the mech entry for the specified mechanism */
	class = KCF_MECH2CLASS(mech_type_1);
	if ((class < KCF_FIRST_OPSCLASS) || (class > KCF_LAST_OPSCLASS)) {
		return (CRYPTO_MECHANISM_INVALID);
	}

	me_tab = &kcf_mech_tabs_tab[class];
	index = KCF_MECH2INDEX(mech_type_1);
	if ((index < 0) || (index >= me_tab->met_size)) {
		return (CRYPTO_MECHANISM_INVALID);
	}

	me = &((me_tab->met_tab)[index]);
	mp = &me_mutexes[CPU_SEQID];
	mutex_enter(&mp->kl_lock);

	/*
	 * We assume the provider descriptor will not go away because
	 * it is being held somewhere, i.e. its reference count has been
	 * incremented. In the case of the crypto module, the provider
	 * descriptor is held by the session structure.
	 */
	if (old->pd_prov_type == CRYPTO_LOGICAL_PROVIDER) {
		if (old->pd_provider_list == NULL) {
			real_pd = NULL;
			rv = CRYPTO_DEVICE_ERROR;
			goto out;
		}
		/*
		 * Find the least loaded real provider. KCF_PROV_LOAD gives
		 * the load (number of pending requests) of the provider.
		 */
		mutex_enter(&old->pd_lock);
		p = old->pd_provider_list;
		while (p != NULL) {
			provider = p->pl_provider;

			ASSERT(provider->pd_prov_type !=
			    CRYPTO_LOGICAL_PROVIDER);

			if (!is_valid_provider_for_mech(provider, me, fg)) {
				p = p->pl_next;
				continue;
			}

			if ((key1 != NULL) &&
			    !kcf_check_prov_mech_keylen(provider, mech_type_1,
			    key1)) {
				p = p->pl_next;
				rv = CRYPTO_KEY_SIZE_RANGE;
				continue;
			}

			/* provider does second mech */
			if (mech_type_2 != CRYPTO_MECH_INVALID) {
				int i;

				i = KCF_TO_PROV_MECH_INDX(provider,
				    mech_type_2);
				if (i == KCF_INVALID_INDX) {
					p = p->pl_next;
					continue;
				}

				if ((key2 != NULL) &&
				    !kcf_check_prov_mech_keylen(provider,
				    mech_type_2, key2)) {
					p = p->pl_next;
					rv = CRYPTO_KEY_SIZE_RANGE;
					continue;
				}
			}

			if (provider->pd_state != KCF_PROV_READY) {
				/* choose BUSY if no READY providers */
				if (provider->pd_state == KCF_PROV_BUSY)
					bpd = provider;
				p = p->pl_next;
				continue;
			}

			/* Do load calculation only if needed */
			if ((p = p->pl_next) == NULL && gpd == NULL) {
				gpd = provider;
			} else {
				len = KCF_PROV_LOAD(provider);
				if (len < gqlen) {
					gqlen = len;
					gpd = provider;
				}
			}
		}

		if (gpd != NULL) {
			real_pd = gpd;
			rv = CRYPTO_SUCCESS;
			KCF_PROV_REFHOLD(real_pd);
		} else if (bpd != NULL) {
			real_pd = bpd;
			rv = CRYPTO_SUCCESS;
			KCF_PROV_REFHOLD(real_pd);
		} else {
			/* can't find provider */
			real_pd = NULL;
			if (rv == CRYPTO_SUCCESS)
				rv = CRYPTO_MECHANISM_INVALID;
		}
		mutex_exit(&old->pd_lock);

	} else {
		if (!KCF_IS_PROV_USABLE(old)) {
			real_pd = NULL;
			rv = CRYPTO_DEVICE_ERROR;
			goto out;
		}

		if (!is_valid_provider_for_mech(old, me, fg)) {
			real_pd = NULL;
			rv = CRYPTO_MECHANISM_INVALID;
			goto out;
		}

		if ((key1 != NULL) &&
		    !kcf_check_prov_mech_keylen(old, mech_type_1, key1)) {
			real_pd = NULL;
			rv = CRYPTO_KEY_SIZE_RANGE;
			goto out;
		}

		KCF_PROV_REFHOLD(real_pd);
	}
out:
	mutex_exit(&mp->kl_lock);
	*new = real_pd;
	return (rv);
}

/*
 * This routine, given a logical provider, returns the least loaded
 * provider belonging to the logical provider. Just in case providers
 * are not entirely equivalent, the provider's entry point is checked
 * for non-nullness. This is accomplished by having the caller pass, as
 * arguments, the offset of the function group (offset_1), and the
 * offset of the function within the function group (offset_2).
 * Returns NULL if no provider can be found.
 */
int
kcf_get_hardware_provider_nomech(offset_t offset_1, offset_t offset_2,
    kcf_provider_desc_t *old, kcf_provider_desc_t **new)
{
	kcf_provider_desc_t *provider, *real_pd = old;
	kcf_provider_desc_t *gpd = NULL;	/* good provider */
	kcf_provider_desc_t *bpd = NULL;	/* busy provider */
	kcf_provider_list_t *p;
	caddr_t *ops;
	int len, gqlen = INT_MAX, rv = CRYPTO_SUCCESS;

	/*
	 * We assume the provider descriptor will not go away because
	 * it is being held somewhere, i.e. its reference count has been
	 * incremented. In the case of the crypto module, the provider
	 * descriptor is held by the session structure.
	 */
	if (old->pd_prov_type == CRYPTO_LOGICAL_PROVIDER) {
		if (old->pd_provider_list == NULL) {
			real_pd = NULL;
			rv = CRYPTO_DEVICE_ERROR;
			goto out;
		}
		/*
		 * Find the least loaded real provider. KCF_PROV_LOAD gives
		 * the load (number of pending requests) of the provider.
		 */
		mutex_enter(&old->pd_lock);
		p = old->pd_provider_list;
		while (p != NULL) {
			provider = p->pl_provider;

			ASSERT(provider->pd_prov_type !=
			    CRYPTO_LOGICAL_PROVIDER);

			if (KCF_PROV_NULL_ENTRY_POINT(provider, offset_1,
			    offset_2, ops)) {
				p = p->pl_next;
				continue;
			}

			if (provider->pd_state != KCF_PROV_READY) {
				/* choose BUSY if no READY providers */
				if (provider->pd_state == KCF_PROV_BUSY)
					bpd = provider;
				p = p->pl_next;
				continue;
			}

			/* Do load calculation only if needed */
			if ((p = p->pl_next) == NULL && gpd == NULL) {
				gpd = provider;
			} else {
				len = KCF_PROV_LOAD(provider);
				if (len < gqlen) {
					gqlen = len;
					gpd = provider;
				}
			}
		}
		mutex_exit(&old->pd_lock);

		if (gpd != NULL) {
			real_pd = gpd;
			KCF_PROV_REFHOLD(real_pd);
		} else if (bpd != NULL) {
			real_pd = bpd;
			KCF_PROV_REFHOLD(real_pd);
		} else {
			/* can't find provider */
			real_pd = NULL;
			rv = CRYPTO_DEVICE_ERROR;
		}

	} else {
		if (!KCF_IS_PROV_USABLE(old)) {
			real_pd = NULL;
			rv = CRYPTO_DEVICE_ERROR;
			goto out;
		}

		if (KCF_PROV_NULL_ENTRY_POINT(old, offset_1, offset_2, ops)) {
			real_pd = NULL;
			rv = CRYPTO_NOT_SUPPORTED;
			goto out;
		}
		KCF_PROV_REFHOLD(real_pd);
	}
out:
	*new = real_pd;
	return (rv);
}

/*
 * Return the next member of a logical provider, given the previous
 * member. The function returns true if the next member is found and
 * bumps its refcnt before returning.
 */
boolean_t
kcf_get_next_logical_provider_member(kcf_provider_desc_t *logical_provider,
    kcf_provider_desc_t *prev, kcf_provider_desc_t **pd)
{
	kcf_provider_list_t *p;
	kcf_provider_desc_t *next;

	ASSERT(MUTEX_HELD(&logical_provider->pd_lock));
	p = logical_provider->pd_provider_list;
	while (p != NULL) {
		/* start the search */
		if (prev == NULL) {
			next = p->pl_provider;
			goto found;
		} else {
			/* find where we were before */
			if (p->pl_provider == prev) {
				if (p->pl_next != NULL) {
					next = p->pl_next->pl_provider;
					goto found;
				}
			}
		}
		p = p->pl_next;
	}
	return (B_FALSE);

found:
	KCF_PROV_REFHOLD(next);
	*pd = next;
	return (B_TRUE);
}

/*
 * Return the best provider for the specified mechanism. The provider
 * is held and it is the caller's responsibility to release it when done.
 * The fg input argument is used as a search criterion to pick a provider.
 * A provider has to support this function group to be picked. If a non-NULL
 * key structure is supplied, the provider will be checked to see if the key
 * length falls into the limits of given mechanism for that provider.
 *
 * Find the least loaded provider in the list of providers. We do a linear
 * search to find one. This is fine as we assume there are only a few
 * number of providers in this list. If this assumption ever changes,
 * we should revisit this.
 *
 */
kcf_provider_desc_t *
kcf_get_mech_provider(crypto_mech_type_t mech_type, crypto_key_t *key,
    kcf_mech_entry_t **mepp, int *error, kcf_prov_tried_t *triedl,
    crypto_func_group_t fg, size_t data_size)
{
	kcf_provider_desc_t *pd = NULL, *gpd = NULL;
	kcf_prov_mech_desc_t *prov_chain, *mdesc;
	int len, gqlen = INT_MAX;
	kcf_ops_class_t class;
	int index;
	kcf_mech_entry_t *me;
	kcf_mech_entry_tab_t *me_tab;
	kcf_lock_withpad_t *mp;
	int error_val = CRYPTO_MECH_NOT_SUPPORTED; /* default error value */

	class = KCF_MECH2CLASS(mech_type);
	if ((class < KCF_FIRST_OPSCLASS) || (class > KCF_LAST_OPSCLASS)) {
		*error = CRYPTO_MECHANISM_INVALID;
		return (NULL);
	}

	me_tab = &kcf_mech_tabs_tab[class];
	index = KCF_MECH2INDEX(mech_type);
	if ((index < 0) || (index >= me_tab->met_size)) {
		*error = CRYPTO_MECHANISM_INVALID;
		return (NULL);
	}

	me = &((me_tab->met_tab)[index]);
	if (mepp != NULL)
		*mepp = me;

	mp = &me_mutexes[CPU_SEQID];
	mutex_enter(&mp->kl_lock);

	prov_chain = me->me_hw_prov_chain;

	/*
	 * We check for the threshold for using a hardware provider for
	 * this amount of data. If there is no software provider available
	 * for the mechanism, then the threshold is ignored.
	 */
	if ((prov_chain != NULL) &&
	    ((data_size == 0) || (me->me_threshold == 0) ||
	    (data_size >= me->me_threshold) ||
	    ((mdesc = me->me_sw_prov) == NULL) ||
	    (!IS_FG_SUPPORTED(mdesc, fg)) ||
	    (!KCF_IS_PROV_USABLE(mdesc->pm_prov_desc)))) {
		ASSERT(me->me_num_hwprov > 0);
		/* there is at least one provider */

		/*
		 * Find the least loaded real provider. KCF_PROV_LOAD gives
		 * the load (number of pending requests) of the provider.
		 */
		while (prov_chain != NULL) {
			pd = prov_chain->pm_prov_desc;

			if (!IS_FG_SUPPORTED(prov_chain, fg) ||
			    !KCF_IS_PROV_USABLE(pd) ||
			    IS_PROVIDER_TRIED(pd, triedl)) {
				prov_chain = prov_chain->pm_next;
				continue;
			}

			if ((key != NULL) && !kcf_check_prov_mech_keylen(pd,
			    mech_type, key)) {
				prov_chain = prov_chain->pm_next;
				error_val = CRYPTO_KEY_SIZE_RANGE;
				continue;
			}

			/* Do load calculation only if needed */
			if ((prov_chain = prov_chain->pm_next) == NULL &&
			    gpd == NULL) {
				gpd = pd;
			} else {
				len = KCF_PROV_LOAD(pd);
				if (len < gqlen) {
					gqlen = len;
					gpd = pd;
				}
			}
		}

		pd = gpd;
	}

	/* No HW provider for this mech, is there a SW provider? */
	if (pd == NULL && (mdesc = me->me_sw_prov) != NULL) {
		pd = mdesc->pm_prov_desc;
		if (!IS_FG_SUPPORTED(mdesc, fg) ||
		    !KCF_IS_PROV_USABLE(pd) ||
		    IS_PROVIDER_TRIED(pd, triedl))
			pd = NULL;
	}

	/* No provider found */
	if (pd == NULL) {
		/*
		 * We do not want to report CRYPTO_MECH_NOT_SUPPORTED, when
		 * we are in the "fallback to the next provider" case. Rather
		 * we preserve the error, so that the client gets the right
		 * error code.
		 */
		if (triedl == NULL)
			*error = error_val;
	} else {
		KCF_PROV_REFHOLD(pd);
	}

	mutex_exit(&mp->kl_lock);
	return (pd);
}

/*
 * Very similar to kcf_get_mech_provider(). Finds the best provider capable of
 * a dual operation with both me1 and me2.
 *
 * If a non-NULL key structure is supplied, the provider will be checked
 * to see if the key length falls into the limits of given mechanism
 * for that provider. This is done for both key structures and mechanisms.
 *
 * When no dual-ops capable providers are available, return the best provider
 * for me1 only, and sets *prov_mt2 to CRYPTO_INVALID_MECHID;
 * We assume/expect that a slower HW capable of the dual is still
 * faster than the 2 fastest providers capable of the individual ops
 * separately.
 */
kcf_provider_desc_t *
kcf_get_dual_provider(crypto_mechanism_t *mech1, crypto_key_t *key1,
    crypto_mechanism_t *mech2, crypto_key_t *key2,
    kcf_mech_entry_t **mepp, crypto_mech_type_t *prov_mt1,
    crypto_mech_type_t *prov_mt2, int *error, kcf_prov_tried_t *triedl,
    crypto_func_group_t fg1, crypto_func_group_t fg2,
    size_t data_size)
{
	kcf_provider_desc_t *pd = NULL, *pdm1 = NULL, *pdm1m2 = NULL;
	kcf_prov_mech_desc_t *prov_chain, *mdesc;
	int len, gqlen = INT_MAX, dgqlen = INT_MAX;
	crypto_mech_info_list_t *mil;
	crypto_mech_type_t m2id =  mech2->cm_type;
	kcf_mech_entry_t *me;
	kcf_lock_withpad_t *mp;
	int error_val = CRYPTO_MECH_NOT_SUPPORTED; /* default error value */

	/* when mech is a valid mechanism, me will be its mech_entry */
	if (kcf_get_mech_entry(mech1->cm_type, &me) != KCF_SUCCESS) {
		*error = CRYPTO_MECHANISM_INVALID;
		return (NULL);
	}

	*prov_mt2 = CRYPTO_MECH_INVALID;

	if (mepp != NULL)
		*mepp = me;

	mp = &me_mutexes[CPU_SEQID];
	mutex_enter(&mp->kl_lock);

	prov_chain = me->me_hw_prov_chain;
	/*
	 * We check the threshold for using a hardware provider for
	 * this amount of data. If there is no software provider available
	 * for the first mechanism, then the threshold is ignored.
	 */
	if ((prov_chain != NULL) &&
	    ((data_size == 0) || (me->me_threshold == 0) ||
	    (data_size >= me->me_threshold) ||
	    ((mdesc = me->me_sw_prov) == NULL) ||
	    (!IS_FG_SUPPORTED(mdesc, fg1)) ||
	    (!KCF_IS_PROV_USABLE(mdesc->pm_prov_desc)))) {
		/* there is at least one provider */
		ASSERT(me->me_num_hwprov > 0);

		/*
		 * Find the least loaded provider capable of the combo
		 * me1 + me2, and save a pointer to the least loaded
		 * provider capable of me1 only.
		 */
		while (prov_chain != NULL) {
			pd = prov_chain->pm_prov_desc;

			if (!IS_FG_SUPPORTED(prov_chain, fg1) ||
			    !KCF_IS_PROV_USABLE(pd) ||
			    IS_PROVIDER_TRIED(pd, triedl)) {
				prov_chain = prov_chain->pm_next;
				continue;
			}

			if ((key1 != NULL) && !kcf_check_prov_mech_keylen(pd,
			    mech1->cm_type, key1)) {
				prov_chain = prov_chain->pm_next;
				error_val = CRYPTO_KEY_SIZE_RANGE;
				continue;
			}

#define	PMD_MECH_NUM(pmdp)	(pmdp)->pm_mech_info.cm_mech_number

			/* Do load calculation only if needed */
			if (prov_chain->pm_next == NULL && pdm1 == NULL) {
				*prov_mt1 = PMD_MECH_NUM(prov_chain);
				pdm1 = pd;
			} else {
				len = KCF_PROV_LOAD(pd);

				/* Save the best provider capable of m1 */
				if (len < gqlen) {
					*prov_mt1 = PMD_MECH_NUM(prov_chain);
					gqlen = len;
					pdm1 = pd;
				}
			}

			/* See if pd can do me2 too */
			for (mil = prov_chain->pm_mi_list;
			    mil != NULL; mil = mil->ml_next) {
				if ((mil->ml_mech_info.cm_func_group_mask &
				    fg2) == 0)
					continue;

				if ((key2 != NULL) &&
				    !kcf_check_prov_mech_keylen(pd,
				    mech2->cm_type, key2)) {
					error_val = CRYPTO_KEY_SIZE_RANGE;
					continue;
				}

#define	MIL_MECH_NUM(mil)	(mil)->ml_mech_info.cm_mech_number

				if (mil->ml_kcf_mechid == m2id) { /* Bingo! */

					/* Do load calculation only if needed */
					if (prov_chain->pm_next == NULL &&
					    pdm1m2 == NULL) {
						pdm1m2 = pd;
						*prov_mt2 = MIL_MECH_NUM(mil);
					} else {
						if (len < dgqlen) {
							dgqlen = len;
							pdm1m2 = pd;
							*prov_mt2 =
							    MIL_MECH_NUM(mil);
						}
					}
					break;
				}
			}

			prov_chain = prov_chain->pm_next;
		}

		pd =  (pdm1m2 != NULL) ? pdm1m2 : pdm1;
	}

	/* no HW provider for this mech, is there a SW provider? */
	if (pd == NULL && (mdesc = me->me_sw_prov) != NULL) {
		pd = mdesc->pm_prov_desc;
		if (!IS_FG_SUPPORTED(mdesc, fg1) ||
		    !KCF_IS_PROV_USABLE(pd) ||
		    IS_PROVIDER_TRIED(pd, triedl))
			pd = NULL;
		else {
			/* See if pd can do me2 too */
			for (mil = me->me_sw_prov->pm_mi_list;
			    mil != NULL; mil = mil->ml_next) {
				if ((mil->ml_mech_info.cm_func_group_mask &
				    fg2) == 0)
					continue;

				if (mil->ml_kcf_mechid == m2id) {
					/* Bingo! */
					*prov_mt2 =
					    mil->ml_mech_info.cm_mech_number;
					break;
				}
			}
			*prov_mt1 = me->me_sw_prov->pm_mech_info.cm_mech_number;
		}
	}

	/* No provider found */
	if (pd == NULL) {
		/*
		 * We do not want to report CRYPTO_MECH_NOT_SUPPORTED, when
		 * we are in the "fallback to the next provider" case. Rather
		 * we preserve the error, so that the client gets the right
		 * error code.
		 */
		if (triedl == NULL)
			*error = error_val;
	} else
		KCF_PROV_REFHOLD(pd);

	mutex_exit(&mp->kl_lock);
	return (pd);
}

/*
 * Do the actual work of calling the provider routines.
 *
 * pd - Provider structure
 * ctx - Context for this operation
 * params - Parameters for this operation
 * rhndl - Request handle to use for notification
 *
 * The return values are the same as that of the respective SPI.
 */
int
common_submit_request(kcf_provider_desc_t *pd, crypto_ctx_t *ctx,
    kcf_req_params_t *params, crypto_req_handle_t rhndl)
{
	int err = CRYPTO_ARGUMENTS_BAD;
	kcf_op_type_t optype;

	optype = params->rp_optype;

	switch (params->rp_opgrp) {
	case KCF_OG_DIGEST: {
		kcf_digest_ops_params_t *dops = &params->rp_u.digest_params;

		switch (optype) {
		case KCF_OP_INIT:
			/*
			 * We should do this only here and not in KCF_WRAP_*
			 * macros. This is because we may want to try other
			 * providers, in case we recover from a failure.
			 */
			KCF_SET_PROVIDER_MECHNUM(dops->do_framework_mechtype,
			    pd, &dops->do_mech);

			err = KCF_PROV_DIGEST_INIT(pd, ctx, &dops->do_mech,
			    rhndl);
			break;

		case KCF_OP_SINGLE:
			err = KCF_PROV_DIGEST(pd, ctx, dops->do_data,
			    dops->do_digest, rhndl);
			break;

		case KCF_OP_UPDATE:
			err = KCF_PROV_DIGEST_UPDATE(pd, ctx,
			    dops->do_data, rhndl);
			break;

		case KCF_OP_FINAL:
			err = KCF_PROV_DIGEST_FINAL(pd, ctx,
			    dops->do_digest, rhndl);
			break;

		case KCF_OP_ATOMIC:
			ASSERT(ctx == NULL);
			KCF_SET_PROVIDER_MECHNUM(dops->do_framework_mechtype,
			    pd, &dops->do_mech);
			err = KCF_PROV_DIGEST_ATOMIC(pd, dops->do_sid,
			    &dops->do_mech, dops->do_data, dops->do_digest,
			    rhndl);
			break;

		case KCF_OP_DIGEST_KEY:
			err = KCF_PROV_DIGEST_KEY(pd, ctx, dops->do_digest_key,
			    rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_MAC: {
		kcf_mac_ops_params_t *mops = &params->rp_u.mac_params;

		switch (optype) {
		case KCF_OP_INIT:
			KCF_SET_PROVIDER_MECHNUM(mops->mo_framework_mechtype,
			    pd, &mops->mo_mech);

			err = KCF_PROV_MAC_INIT(pd, ctx, &mops->mo_mech,
			    mops->mo_key, mops->mo_templ, rhndl);
			break;

		case KCF_OP_SINGLE:
			err = KCF_PROV_MAC(pd, ctx, mops->mo_data,
			    mops->mo_mac, rhndl);
			break;

		case KCF_OP_UPDATE:
			err = KCF_PROV_MAC_UPDATE(pd, ctx, mops->mo_data,
			    rhndl);
			break;

		case KCF_OP_FINAL:
			err = KCF_PROV_MAC_FINAL(pd, ctx, mops->mo_mac, rhndl);
			break;

		case KCF_OP_ATOMIC:
			ASSERT(ctx == NULL);
			KCF_SET_PROVIDER_MECHNUM(mops->mo_framework_mechtype,
			    pd, &mops->mo_mech);

			err = KCF_PROV_MAC_ATOMIC(pd, mops->mo_sid,
			    &mops->mo_mech, mops->mo_key, mops->mo_data,
			    mops->mo_mac, mops->mo_templ, rhndl);
			break;

		case KCF_OP_MAC_VERIFY_ATOMIC:
			ASSERT(ctx == NULL);
			KCF_SET_PROVIDER_MECHNUM(mops->mo_framework_mechtype,
			    pd, &mops->mo_mech);

			err = KCF_PROV_MAC_VERIFY_ATOMIC(pd, mops->mo_sid,
			    &mops->mo_mech, mops->mo_key, mops->mo_data,
			    mops->mo_mac, mops->mo_templ, rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_ENCRYPT: {
		kcf_encrypt_ops_params_t *eops = &params->rp_u.encrypt_params;

		switch (optype) {
		case KCF_OP_INIT:
			KCF_SET_PROVIDER_MECHNUM(eops->eo_framework_mechtype,
			    pd, &eops->eo_mech);

			err = KCF_PROV_ENCRYPT_INIT(pd, ctx, &eops->eo_mech,
			    eops->eo_key, eops->eo_templ, rhndl);
			break;

		case KCF_OP_SINGLE:
			err = KCF_PROV_ENCRYPT(pd, ctx, eops->eo_plaintext,
			    eops->eo_ciphertext, rhndl);
			break;

		case KCF_OP_UPDATE:
			err = KCF_PROV_ENCRYPT_UPDATE(pd, ctx,
			    eops->eo_plaintext, eops->eo_ciphertext, rhndl);
			break;

		case KCF_OP_FINAL:
			err = KCF_PROV_ENCRYPT_FINAL(pd, ctx,
			    eops->eo_ciphertext, rhndl);
			break;

		case KCF_OP_ATOMIC:
			ASSERT(ctx == NULL);
			KCF_SET_PROVIDER_MECHNUM(eops->eo_framework_mechtype,
			    pd, &eops->eo_mech);

			err = KCF_PROV_ENCRYPT_ATOMIC(pd, eops->eo_sid,
			    &eops->eo_mech, eops->eo_key, eops->eo_plaintext,
			    eops->eo_ciphertext, eops->eo_templ, rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_DECRYPT: {
		kcf_decrypt_ops_params_t *dcrops = &params->rp_u.decrypt_params;

		switch (optype) {
		case KCF_OP_INIT:
			KCF_SET_PROVIDER_MECHNUM(dcrops->dop_framework_mechtype,
			    pd, &dcrops->dop_mech);

			err = KCF_PROV_DECRYPT_INIT(pd, ctx, &dcrops->dop_mech,
			    dcrops->dop_key, dcrops->dop_templ, rhndl);
			break;

		case KCF_OP_SINGLE:
			err = KCF_PROV_DECRYPT(pd, ctx, dcrops->dop_ciphertext,
			    dcrops->dop_plaintext, rhndl);
			break;

		case KCF_OP_UPDATE:
			err = KCF_PROV_DECRYPT_UPDATE(pd, ctx,
			    dcrops->dop_ciphertext, dcrops->dop_plaintext,
			    rhndl);
			break;

		case KCF_OP_FINAL:
			err = KCF_PROV_DECRYPT_FINAL(pd, ctx,
			    dcrops->dop_plaintext, rhndl);
			break;

		case KCF_OP_ATOMIC:
			ASSERT(ctx == NULL);
			KCF_SET_PROVIDER_MECHNUM(dcrops->dop_framework_mechtype,
			    pd, &dcrops->dop_mech);

			err = KCF_PROV_DECRYPT_ATOMIC(pd, dcrops->dop_sid,
			    &dcrops->dop_mech, dcrops->dop_key,
			    dcrops->dop_ciphertext, dcrops->dop_plaintext,
			    dcrops->dop_templ, rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_SIGN: {
		kcf_sign_ops_params_t *sops = &params->rp_u.sign_params;

		switch (optype) {
		case KCF_OP_INIT:
			KCF_SET_PROVIDER_MECHNUM(sops->so_framework_mechtype,
			    pd, &sops->so_mech);

			err = KCF_PROV_SIGN_INIT(pd, ctx, &sops->so_mech,
			    sops->so_key, sops->so_templ, rhndl);
			break;

		case KCF_OP_SIGN_RECOVER_INIT:
			KCF_SET_PROVIDER_MECHNUM(sops->so_framework_mechtype,
			    pd, &sops->so_mech);

			err = KCF_PROV_SIGN_RECOVER_INIT(pd, ctx,
			    &sops->so_mech, sops->so_key, sops->so_templ,
			    rhndl);
			break;

		case KCF_OP_SINGLE:
			err = KCF_PROV_SIGN(pd, ctx, sops->so_data,
			    sops->so_signature, rhndl);
			break;

		case KCF_OP_SIGN_RECOVER:
			err = KCF_PROV_SIGN_RECOVER(pd, ctx,
			    sops->so_data, sops->so_signature, rhndl);
			break;

		case KCF_OP_UPDATE:
			err = KCF_PROV_SIGN_UPDATE(pd, ctx, sops->so_data,
			    rhndl);
			break;

		case KCF_OP_FINAL:
			err = KCF_PROV_SIGN_FINAL(pd, ctx, sops->so_signature,
			    rhndl);
			break;

		case KCF_OP_ATOMIC:
			ASSERT(ctx == NULL);
			KCF_SET_PROVIDER_MECHNUM(sops->so_framework_mechtype,
			    pd, &sops->so_mech);

			err = KCF_PROV_SIGN_ATOMIC(pd, sops->so_sid,
			    &sops->so_mech, sops->so_key, sops->so_data,
			    sops->so_templ, sops->so_signature, rhndl);
			break;

		case KCF_OP_SIGN_RECOVER_ATOMIC:
			ASSERT(ctx == NULL);
			KCF_SET_PROVIDER_MECHNUM(sops->so_framework_mechtype,
			    pd, &sops->so_mech);

			err = KCF_PROV_SIGN_RECOVER_ATOMIC(pd, sops->so_sid,
			    &sops->so_mech, sops->so_key, sops->so_data,
			    sops->so_templ, sops->so_signature, rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_VERIFY: {
		kcf_verify_ops_params_t *vops = &params->rp_u.verify_params;

		switch (optype) {
		case KCF_OP_INIT:
			KCF_SET_PROVIDER_MECHNUM(vops->vo_framework_mechtype,
			    pd, &vops->vo_mech);

			err = KCF_PROV_VERIFY_INIT(pd, ctx, &vops->vo_mech,
			    vops->vo_key, vops->vo_templ, rhndl);
			break;

		case KCF_OP_VERIFY_RECOVER_INIT:
			KCF_SET_PROVIDER_MECHNUM(vops->vo_framework_mechtype,
			    pd, &vops->vo_mech);

			err = KCF_PROV_VERIFY_RECOVER_INIT(pd, ctx,
			    &vops->vo_mech, vops->vo_key, vops->vo_templ,
			    rhndl);
			break;

		case KCF_OP_SINGLE:
			err = KCF_PROV_VERIFY(pd, ctx, vops->vo_data,
			    vops->vo_signature, rhndl);
			break;

		case KCF_OP_VERIFY_RECOVER:
			err = KCF_PROV_VERIFY_RECOVER(pd, ctx,
			    vops->vo_signature, vops->vo_data, rhndl);
			break;

		case KCF_OP_UPDATE:
			err = KCF_PROV_VERIFY_UPDATE(pd, ctx, vops->vo_data,
			    rhndl);
			break;

		case KCF_OP_FINAL:
			err = KCF_PROV_VERIFY_FINAL(pd, ctx, vops->vo_signature,
			    rhndl);
			break;

		case KCF_OP_ATOMIC:
			ASSERT(ctx == NULL);
			KCF_SET_PROVIDER_MECHNUM(vops->vo_framework_mechtype,
			    pd, &vops->vo_mech);

			err = KCF_PROV_VERIFY_ATOMIC(pd, vops->vo_sid,
			    &vops->vo_mech, vops->vo_key, vops->vo_data,
			    vops->vo_templ, vops->vo_signature, rhndl);
			break;

		case KCF_OP_VERIFY_RECOVER_ATOMIC:
			ASSERT(ctx == NULL);
			KCF_SET_PROVIDER_MECHNUM(vops->vo_framework_mechtype,
			    pd, &vops->vo_mech);

			err = KCF_PROV_VERIFY_RECOVER_ATOMIC(pd, vops->vo_sid,
			    &vops->vo_mech, vops->vo_key, vops->vo_signature,
			    vops->vo_templ, vops->vo_data, rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_ENCRYPT_MAC: {
		kcf_encrypt_mac_ops_params_t *eops =
		    &params->rp_u.encrypt_mac_params;
		kcf_context_t *kcf_secondctx;

		switch (optype) {
		case KCF_OP_INIT:
			kcf_secondctx = ((kcf_context_t *)
			    (ctx->cc_framework_private))->kc_secondctx;

			if (kcf_secondctx != NULL) {
				err = kcf_emulate_dual(pd, ctx, params);
				break;
			}
			KCF_SET_PROVIDER_MECHNUM(
			    eops->em_framework_encr_mechtype,
			    pd, &eops->em_encr_mech);

			KCF_SET_PROVIDER_MECHNUM(
			    eops->em_framework_mac_mechtype,
			    pd, &eops->em_mac_mech);

			err = KCF_PROV_ENCRYPT_MAC_INIT(pd, ctx,
			    &eops->em_encr_mech, eops->em_encr_key,
			    &eops->em_mac_mech, eops->em_mac_key,
			    eops->em_encr_templ, eops->em_mac_templ,
			    rhndl);

			break;

		case KCF_OP_SINGLE:
			err = KCF_PROV_ENCRYPT_MAC(pd, ctx,
			    eops->em_plaintext, eops->em_ciphertext,
			    eops->em_mac, rhndl);
			break;

		case KCF_OP_UPDATE:
			kcf_secondctx = ((kcf_context_t *)
			    (ctx->cc_framework_private))->kc_secondctx;
			if (kcf_secondctx != NULL) {
				err = kcf_emulate_dual(pd, ctx, params);
				break;
			}
			err = KCF_PROV_ENCRYPT_MAC_UPDATE(pd, ctx,
			    eops->em_plaintext, eops->em_ciphertext, rhndl);
			break;

		case KCF_OP_FINAL:
			kcf_secondctx = ((kcf_context_t *)
			    (ctx->cc_framework_private))->kc_secondctx;
			if (kcf_secondctx != NULL) {
				err = kcf_emulate_dual(pd, ctx, params);
				break;
			}
			err = KCF_PROV_ENCRYPT_MAC_FINAL(pd, ctx,
			    eops->em_ciphertext, eops->em_mac, rhndl);
			break;

		case KCF_OP_ATOMIC:
			ASSERT(ctx == NULL);

			KCF_SET_PROVIDER_MECHNUM(
			    eops->em_framework_encr_mechtype,
			    pd, &eops->em_encr_mech);

			KCF_SET_PROVIDER_MECHNUM(
			    eops->em_framework_mac_mechtype,
			    pd, &eops->em_mac_mech);

			err = KCF_PROV_ENCRYPT_MAC_ATOMIC(pd, eops->em_sid,
			    &eops->em_encr_mech, eops->em_encr_key,
			    &eops->em_mac_mech, eops->em_mac_key,
			    eops->em_plaintext, eops->em_ciphertext,
			    eops->em_mac,
			    eops->em_encr_templ, eops->em_mac_templ,
			    rhndl);

			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_MAC_DECRYPT: {
		kcf_mac_decrypt_ops_params_t *dops =
		    &params->rp_u.mac_decrypt_params;
		kcf_context_t *kcf_secondctx;

		switch (optype) {
		case KCF_OP_INIT:
			kcf_secondctx = ((kcf_context_t *)
			    (ctx->cc_framework_private))->kc_secondctx;

			if (kcf_secondctx != NULL) {
				err = kcf_emulate_dual(pd, ctx, params);
				break;
			}
			KCF_SET_PROVIDER_MECHNUM(
			    dops->md_framework_mac_mechtype,
			    pd, &dops->md_mac_mech);

			KCF_SET_PROVIDER_MECHNUM(
			    dops->md_framework_decr_mechtype,
			    pd, &dops->md_decr_mech);

			err = KCF_PROV_MAC_DECRYPT_INIT(pd, ctx,
			    &dops->md_mac_mech, dops->md_mac_key,
			    &dops->md_decr_mech, dops->md_decr_key,
			    dops->md_mac_templ, dops->md_decr_templ,
			    rhndl);

			break;

		case KCF_OP_SINGLE:
			err = KCF_PROV_MAC_DECRYPT(pd, ctx,
			    dops->md_ciphertext, dops->md_mac,
			    dops->md_plaintext, rhndl);
			break;

		case KCF_OP_UPDATE:
			kcf_secondctx = ((kcf_context_t *)
			    (ctx->cc_framework_private))->kc_secondctx;
			if (kcf_secondctx != NULL) {
				err = kcf_emulate_dual(pd, ctx, params);
				break;
			}
			err = KCF_PROV_MAC_DECRYPT_UPDATE(pd, ctx,
			    dops->md_ciphertext, dops->md_plaintext, rhndl);
			break;

		case KCF_OP_FINAL:
			kcf_secondctx = ((kcf_context_t *)
			    (ctx->cc_framework_private))->kc_secondctx;
			if (kcf_secondctx != NULL) {
				err = kcf_emulate_dual(pd, ctx, params);
				break;
			}
			err = KCF_PROV_MAC_DECRYPT_FINAL(pd, ctx,
			    dops->md_mac, dops->md_plaintext, rhndl);
			break;

		case KCF_OP_ATOMIC:
			ASSERT(ctx == NULL);

			KCF_SET_PROVIDER_MECHNUM(
			    dops->md_framework_mac_mechtype,
			    pd, &dops->md_mac_mech);

			KCF_SET_PROVIDER_MECHNUM(
			    dops->md_framework_decr_mechtype,
			    pd, &dops->md_decr_mech);

			err = KCF_PROV_MAC_DECRYPT_ATOMIC(pd, dops->md_sid,
			    &dops->md_mac_mech, dops->md_mac_key,
			    &dops->md_decr_mech, dops->md_decr_key,
			    dops->md_ciphertext, dops->md_mac,
			    dops->md_plaintext,
			    dops->md_mac_templ, dops->md_decr_templ,
			    rhndl);

			break;

		case KCF_OP_MAC_VERIFY_DECRYPT_ATOMIC:
			ASSERT(ctx == NULL);

			KCF_SET_PROVIDER_MECHNUM(
			    dops->md_framework_mac_mechtype,
			    pd, &dops->md_mac_mech);

			KCF_SET_PROVIDER_MECHNUM(
			    dops->md_framework_decr_mechtype,
			    pd, &dops->md_decr_mech);

			err = KCF_PROV_MAC_VERIFY_DECRYPT_ATOMIC(pd,
			    dops->md_sid, &dops->md_mac_mech, dops->md_mac_key,
			    &dops->md_decr_mech, dops->md_decr_key,
			    dops->md_ciphertext, dops->md_mac,
			    dops->md_plaintext,
			    dops->md_mac_templ, dops->md_decr_templ,
			    rhndl);

			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_KEY: {
		kcf_key_ops_params_t *kops = &params->rp_u.key_params;

		ASSERT(ctx == NULL);
		KCF_SET_PROVIDER_MECHNUM(kops->ko_framework_mechtype, pd,
		    &kops->ko_mech);

		switch (optype) {
		case KCF_OP_KEY_GENERATE:
			err = KCF_PROV_KEY_GENERATE(pd, kops->ko_sid,
			    &kops->ko_mech,
			    kops->ko_key_template, kops->ko_key_attribute_count,
			    kops->ko_key_object_id_ptr, rhndl);
			break;

		case KCF_OP_KEY_GENERATE_PAIR:
			err = KCF_PROV_KEY_GENERATE_PAIR(pd, kops->ko_sid,
			    &kops->ko_mech,
			    kops->ko_key_template, kops->ko_key_attribute_count,
			    kops->ko_private_key_template,
			    kops->ko_private_key_attribute_count,
			    kops->ko_key_object_id_ptr,
			    kops->ko_private_key_object_id_ptr, rhndl);
			break;

		case KCF_OP_KEY_WRAP:
			err = KCF_PROV_KEY_WRAP(pd, kops->ko_sid,
			    &kops->ko_mech,
			    kops->ko_key, kops->ko_key_object_id_ptr,
			    kops->ko_wrapped_key, kops->ko_wrapped_key_len_ptr,
			    rhndl);
			break;

		case KCF_OP_KEY_UNWRAP:
			err = KCF_PROV_KEY_UNWRAP(pd, kops->ko_sid,
			    &kops->ko_mech,
			    kops->ko_key, kops->ko_wrapped_key,
			    kops->ko_wrapped_key_len_ptr,
			    kops->ko_key_template, kops->ko_key_attribute_count,
			    kops->ko_key_object_id_ptr, rhndl);
			break;

		case KCF_OP_KEY_DERIVE:
			err = KCF_PROV_KEY_DERIVE(pd, kops->ko_sid,
			    &kops->ko_mech,
			    kops->ko_key, kops->ko_key_template,
			    kops->ko_key_attribute_count,
			    kops->ko_key_object_id_ptr, rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_RANDOM: {
		kcf_random_number_ops_params_t *rops =
		    &params->rp_u.random_number_params;

		ASSERT(ctx == NULL);

		switch (optype) {
		case KCF_OP_RANDOM_SEED:
			err = KCF_PROV_SEED_RANDOM(pd, rops->rn_sid,
			    rops->rn_buf, rops->rn_buflen, rops->rn_entropy_est,
			    rops->rn_flags, rhndl);
			break;

		case KCF_OP_RANDOM_GENERATE:
			err = KCF_PROV_GENERATE_RANDOM(pd, rops->rn_sid,
			    rops->rn_buf, rops->rn_buflen, rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_SESSION: {
		kcf_session_ops_params_t *sops = &params->rp_u.session_params;

		ASSERT(ctx == NULL);
		switch (optype) {
		case KCF_OP_SESSION_OPEN:
			/*
			 * so_pd may be a logical provider, in which case
			 * we need to check whether it has been removed.
			 */
			if (KCF_IS_PROV_REMOVED(sops->so_pd)) {
				err = CRYPTO_DEVICE_ERROR;
				break;
			}
			err = KCF_PROV_SESSION_OPEN(pd, sops->so_sid_ptr,
			    rhndl, sops->so_pd);
			break;

		case KCF_OP_SESSION_CLOSE:
			/*
			 * so_pd may be a logical provider, in which case
			 * we need to check whether it has been removed.
			 */
			if (KCF_IS_PROV_REMOVED(sops->so_pd)) {
				err = CRYPTO_DEVICE_ERROR;
				break;
			}
			err = KCF_PROV_SESSION_CLOSE(pd, sops->so_sid,
			    rhndl, sops->so_pd);
			break;

		case KCF_OP_SESSION_LOGIN:
			err = KCF_PROV_SESSION_LOGIN(pd, sops->so_sid,
			    sops->so_user_type, sops->so_pin,
			    sops->so_pin_len, rhndl);
			break;

		case KCF_OP_SESSION_LOGOUT:
			err = KCF_PROV_SESSION_LOGOUT(pd, sops->so_sid, rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_OBJECT: {
		kcf_object_ops_params_t *jops = &params->rp_u.object_params;

		ASSERT(ctx == NULL);
		switch (optype) {
		case KCF_OP_OBJECT_CREATE:
			err = KCF_PROV_OBJECT_CREATE(pd, jops->oo_sid,
			    jops->oo_template, jops->oo_attribute_count,
			    jops->oo_object_id_ptr, rhndl);
			break;

		case KCF_OP_OBJECT_COPY:
			err = KCF_PROV_OBJECT_COPY(pd, jops->oo_sid,
			    jops->oo_object_id,
			    jops->oo_template, jops->oo_attribute_count,
			    jops->oo_object_id_ptr, rhndl);
			break;

		case KCF_OP_OBJECT_DESTROY:
			err = KCF_PROV_OBJECT_DESTROY(pd, jops->oo_sid,
			    jops->oo_object_id, rhndl);
			break;

		case KCF_OP_OBJECT_GET_SIZE:
			err = KCF_PROV_OBJECT_GET_SIZE(pd, jops->oo_sid,
			    jops->oo_object_id, jops->oo_object_size, rhndl);
			break;

		case KCF_OP_OBJECT_GET_ATTRIBUTE_VALUE:
			err = KCF_PROV_OBJECT_GET_ATTRIBUTE_VALUE(pd,
			    jops->oo_sid, jops->oo_object_id,
			    jops->oo_template, jops->oo_attribute_count, rhndl);
			break;

		case KCF_OP_OBJECT_SET_ATTRIBUTE_VALUE:
			err = KCF_PROV_OBJECT_SET_ATTRIBUTE_VALUE(pd,
			    jops->oo_sid, jops->oo_object_id,
			    jops->oo_template, jops->oo_attribute_count, rhndl);
			break;

		case KCF_OP_OBJECT_FIND_INIT:
			err = KCF_PROV_OBJECT_FIND_INIT(pd, jops->oo_sid,
			    jops->oo_template, jops->oo_attribute_count,
			    jops->oo_find_init_pp_ptr, rhndl);
			break;

		case KCF_OP_OBJECT_FIND:
			err = KCF_PROV_OBJECT_FIND(pd, jops->oo_find_pp,
			    jops->oo_object_id_ptr, jops->oo_max_object_count,
			    jops->oo_object_count_ptr, rhndl);
			break;

		case KCF_OP_OBJECT_FIND_FINAL:
			err = KCF_PROV_OBJECT_FIND_FINAL(pd, jops->oo_find_pp,
			    rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_PROVMGMT: {
		kcf_provmgmt_ops_params_t *pops = &params->rp_u.provmgmt_params;

		ASSERT(ctx == NULL);
		switch (optype) {
		case KCF_OP_MGMT_EXTINFO:
			/*
			 * po_pd may be a logical provider, in which case
			 * we need to check whether it has been removed.
			 */
			if (KCF_IS_PROV_REMOVED(pops->po_pd)) {
				err = CRYPTO_DEVICE_ERROR;
				break;
			}
			err = KCF_PROV_EXT_INFO(pd, pops->po_ext_info, rhndl,
			    pops->po_pd);
			break;

		case KCF_OP_MGMT_INITTOKEN:
			err = KCF_PROV_INIT_TOKEN(pd, pops->po_pin,
			    pops->po_pin_len, pops->po_label, rhndl);
			break;

		case KCF_OP_MGMT_INITPIN:
			err = KCF_PROV_INIT_PIN(pd, pops->po_sid, pops->po_pin,
			    pops->po_pin_len, rhndl);
			break;

		case KCF_OP_MGMT_SETPIN:
			err = KCF_PROV_SET_PIN(pd, pops->po_sid,
			    pops->po_old_pin, pops->po_old_pin_len,
			    pops->po_pin, pops->po_pin_len, rhndl);
			break;

		default:
			break;
		}
		break;
	}

	case KCF_OG_NOSTORE_KEY: {
		kcf_key_ops_params_t *kops = &params->rp_u.key_params;

		ASSERT(ctx == NULL);
		KCF_SET_PROVIDER_MECHNUM(kops->ko_framework_mechtype, pd,
		    &kops->ko_mech);

		switch (optype) {
		case KCF_OP_KEY_GENERATE:
			err = KCF_PROV_NOSTORE_KEY_GENERATE(pd, kops->ko_sid,
			    &kops->ko_mech, kops->ko_key_template,
			    kops->ko_key_attribute_count,
			    kops->ko_out_template1,
			    kops->ko_out_attribute_count1, rhndl);
			break;

		case KCF_OP_KEY_GENERATE_PAIR:
			err = KCF_PROV_NOSTORE_KEY_GENERATE_PAIR(pd,
			    kops->ko_sid, &kops->ko_mech,
			    kops->ko_key_template, kops->ko_key_attribute_count,
			    kops->ko_private_key_template,
			    kops->ko_private_key_attribute_count,
			    kops->ko_out_template1,
			    kops->ko_out_attribute_count1,
			    kops->ko_out_template2,
			    kops->ko_out_attribute_count2,
			    rhndl);
			break;

		case KCF_OP_KEY_DERIVE:
			err = KCF_PROV_NOSTORE_KEY_DERIVE(pd, kops->ko_sid,
			    &kops->ko_mech, kops->ko_key,
			    kops->ko_key_template,
			    kops->ko_key_attribute_count,
			    kops->ko_out_template1,
			    kops->ko_out_attribute_count1, rhndl);
			break;

		default:
			break;
		}
		break;
	}
	default:
		break;
	}		/* end of switch(params->rp_opgrp) */

	KCF_PROV_INCRSTATS(pd, err);
	return (err);
}

/*
 * Emulate the call for a multipart dual ops with 2 single steps.
 * This routine is always called in the context of a working thread
 * running kcf_svc_do_run().
 * The single steps are submitted in a pure synchronous way (blocking).
 * When this routine returns, kcf_svc_do_run() will call kcf_aop_done()
 * so the originating consumer's callback gets invoked. kcf_aop_done()
 * takes care of freeing the operation context. So, this routine does
 * not free the operation context.
 *
 * The provider descriptor is assumed held by the callers.
 */
static int
kcf_emulate_dual(kcf_provider_desc_t *pd, crypto_ctx_t *ctx,
    kcf_req_params_t *params)
{
	int err = CRYPTO_ARGUMENTS_BAD;
	kcf_op_type_t optype;
	size_t save_len;
	off_t save_offset;

	optype = params->rp_optype;

	switch (params->rp_opgrp) {
	case KCF_OG_ENCRYPT_MAC: {
		kcf_encrypt_mac_ops_params_t *cmops =
		    &params->rp_u.encrypt_mac_params;
		kcf_context_t *encr_kcf_ctx;
		crypto_ctx_t *mac_ctx;
		kcf_req_params_t encr_params;

		encr_kcf_ctx = (kcf_context_t *)(ctx->cc_framework_private);

		switch (optype) {
		case KCF_OP_INIT: {
			encr_kcf_ctx->kc_secondctx = NULL;

			KCF_WRAP_ENCRYPT_OPS_PARAMS(&encr_params, KCF_OP_INIT,
			    pd->pd_sid, &cmops->em_encr_mech,
			    cmops->em_encr_key, NULL, NULL,
			    cmops->em_encr_templ);

			err = kcf_submit_request(pd, ctx, NULL, &encr_params,
			    B_FALSE);

			/* It can't be CRYPTO_QUEUED */
			if (err != CRYPTO_SUCCESS) {
				break;
			}

			err = crypto_mac_init(&cmops->em_mac_mech,
			    cmops->em_mac_key, cmops->em_mac_templ,
			    (crypto_context_t *)&mac_ctx, NULL);

			if (err == CRYPTO_SUCCESS) {
				encr_kcf_ctx->kc_secondctx = (kcf_context_t *)
				    mac_ctx->cc_framework_private;
				KCF_CONTEXT_REFHOLD((kcf_context_t *)
				    mac_ctx->cc_framework_private);
			}

			break;

		}
		case KCF_OP_UPDATE: {
			crypto_dual_data_t *ct = cmops->em_ciphertext;
			crypto_data_t *pt = cmops->em_plaintext;
			kcf_context_t *mac_kcf_ctx = encr_kcf_ctx->kc_secondctx;
			crypto_ctx_t *mac_ctx = &mac_kcf_ctx->kc_glbl_ctx;

			KCF_WRAP_ENCRYPT_OPS_PARAMS(&encr_params, KCF_OP_UPDATE,
			    pd->pd_sid, NULL, NULL, pt, (crypto_data_t *)ct,
			    NULL);

			err = kcf_submit_request(pd, ctx, NULL, &encr_params,
			    B_FALSE);

			/* It can't be CRYPTO_QUEUED */
			if (err != CRYPTO_SUCCESS) {
				break;
			}

			save_offset = ct->dd_offset1;
			save_len = ct->dd_len1;
			if (ct->dd_len2 == 0) {
				/*
				 * The previous encrypt step was an
				 * accumulation only and didn't produce any
				 * partial output
				 */
				if (ct->dd_len1 == 0)
					break;

			} else {
				ct->dd_offset1 = ct->dd_offset2;
				ct->dd_len1 = ct->dd_len2;
			}
			err = crypto_mac_update((crypto_context_t)mac_ctx,
			    (crypto_data_t *)ct, NULL);

			ct->dd_offset1 = save_offset;
			ct->dd_len1 = save_len;

			break;
		}
		case KCF_OP_FINAL: {
			crypto_dual_data_t *ct = cmops->em_ciphertext;
			crypto_data_t *mac = cmops->em_mac;
			kcf_context_t *mac_kcf_ctx = encr_kcf_ctx->kc_secondctx;
			crypto_ctx_t *mac_ctx = &mac_kcf_ctx->kc_glbl_ctx;
			crypto_context_t mac_context = mac_ctx;

			KCF_WRAP_ENCRYPT_OPS_PARAMS(&encr_params, KCF_OP_FINAL,
			    pd->pd_sid, NULL, NULL, NULL, (crypto_data_t *)ct,
			    NULL);

			err = kcf_submit_request(pd, ctx, NULL, &encr_params,
			    B_FALSE);

			/* It can't be CRYPTO_QUEUED */
			if (err != CRYPTO_SUCCESS) {
				crypto_cancel_ctx(mac_context);
				break;
			}

			if (ct->dd_len2 > 0) {
				save_offset = ct->dd_offset1;
				save_len = ct->dd_len1;
				ct->dd_offset1 = ct->dd_offset2;
				ct->dd_len1 = ct->dd_len2;

				err = crypto_mac_update(mac_context,
				    (crypto_data_t *)ct, NULL);

				ct->dd_offset1 = save_offset;
				ct->dd_len1 = save_len;

				if (err != CRYPTO_SUCCESS)  {
					crypto_cancel_ctx(mac_context);
					return (err);
				}
			}

			/* and finally, collect the MAC */
			err = crypto_mac_final(mac_context, mac, NULL);
			break;
		}

		default:
			break;
		}
		KCF_PROV_INCRSTATS(pd, err);
		break;
	}
	case KCF_OG_MAC_DECRYPT: {
		kcf_mac_decrypt_ops_params_t *mdops =
		    &params->rp_u.mac_decrypt_params;
		kcf_context_t *decr_kcf_ctx;
		crypto_ctx_t *mac_ctx;
		kcf_req_params_t decr_params;

		decr_kcf_ctx = (kcf_context_t *)(ctx->cc_framework_private);

		switch (optype) {
		case KCF_OP_INIT: {
			decr_kcf_ctx->kc_secondctx = NULL;

			err = crypto_mac_init(&mdops->md_mac_mech,
			    mdops->md_mac_key, mdops->md_mac_templ,
			    (crypto_context_t *)&mac_ctx, NULL);

			/* It can't be CRYPTO_QUEUED */
			if (err != CRYPTO_SUCCESS) {
				break;
			}

			KCF_WRAP_DECRYPT_OPS_PARAMS(&decr_params, KCF_OP_INIT,
			    pd->pd_sid, &mdops->md_decr_mech,
			    mdops->md_decr_key, NULL, NULL,
			    mdops->md_decr_templ);

			err = kcf_submit_request(pd, ctx, NULL, &decr_params,
			    B_FALSE);

			/* It can't be CRYPTO_QUEUED */
			if (err != CRYPTO_SUCCESS) {
				crypto_cancel_ctx((crypto_context_t)mac_ctx);
				break;
			}

			decr_kcf_ctx->kc_secondctx = (kcf_context_t *)
			    mac_ctx->cc_framework_private;
			KCF_CONTEXT_REFHOLD((kcf_context_t *)
			    mac_ctx->cc_framework_private);

			break;

		}
		case KCF_OP_UPDATE: {
			crypto_dual_data_t *ct = mdops->md_ciphertext;
			crypto_data_t *pt = mdops->md_plaintext;
			kcf_context_t *mac_kcf_ctx = decr_kcf_ctx->kc_secondctx;
			crypto_ctx_t *mac_ctx = &mac_kcf_ctx->kc_glbl_ctx;

			err = crypto_mac_update((crypto_context_t)mac_ctx,
			    (crypto_data_t *)ct, NULL);

			if (err != CRYPTO_SUCCESS)
				break;

			save_offset = ct->dd_offset1;
			save_len = ct->dd_len1;

			/* zero ct->dd_len2 means decrypt everything */
			if (ct->dd_len2 > 0) {
				ct->dd_offset1 = ct->dd_offset2;
				ct->dd_len1 = ct->dd_len2;
			}

			err = crypto_decrypt_update((crypto_context_t)ctx,
			    (crypto_data_t *)ct, pt, NULL);

			ct->dd_offset1 = save_offset;
			ct->dd_len1 = save_len;

			break;
		}
		case KCF_OP_FINAL: {
			crypto_data_t *pt = mdops->md_plaintext;
			crypto_data_t *mac = mdops->md_mac;
			kcf_context_t *mac_kcf_ctx = decr_kcf_ctx->kc_secondctx;
			crypto_ctx_t *mac_ctx = &mac_kcf_ctx->kc_glbl_ctx;

			err = crypto_mac_final((crypto_context_t)mac_ctx,
			    mac, NULL);

			if (err != CRYPTO_SUCCESS) {
				crypto_cancel_ctx(ctx);
				break;
			}

			/* Get the last chunk of plaintext */
			KCF_CONTEXT_REFHOLD(decr_kcf_ctx);
			err = crypto_decrypt_final((crypto_context_t)ctx, pt,
			    NULL);

			break;
		}
		}
		break;
	}
	default:

		break;
	}		/* end of switch(params->rp_opgrp) */

	return (err);
}