9 files changed, 68 insertions, 499 deletions

diff --git a/sys/crypto/aesni/aesni.c b/sys/crypto/aesni/aesni.c
index 5d259f3c708a5..6e574b2b4da5a 100644
--- a/sys/crypto/aesni/aesni.c
+++ b/sys/crypto/aesni/aesni.c
@@ -42,7 +42,6 @@ __FBSDID("$FreeBSD$");
 #include <sys/lock.h>
 #include <sys/module.h>
 #include <sys/malloc.h>
-#include <sys/rwlock.h>
 #include <sys/bus.h>
 #include <sys/uio.h>
 #include <sys/mbuf.h>
@@ -69,13 +68,9 @@ static struct mtx_padalign *ctx_mtx;
 static struct fpu_kern_ctx **ctx_fpu;
 
 struct aesni_softc {
-	int	dieing;
 	int32_t cid;
-	uint32_t sid;
 	bool	has_aes;
 	bool	has_sha;
-	TAILQ_HEAD(aesni_sessions_head, aesni_session) sessions;
-	struct rwlock lock;
 };
 
 #define ACQUIRE_CTX(i, ctx)					\
@@ -91,10 +86,8 @@ struct aesni_softc {
 		(ctx) = NULL;					\
 	} while (0)
 
-static int aesni_newsession(device_t, uint32_t *sidp, struct cryptoini *cri);
-static int aesni_freesession(device_t, uint64_t tid);
-static void aesni_freesession_locked(struct aesni_softc *sc,
-    struct aesni_session *ses);
+static int aesni_newsession(device_t, crypto_session_t cses,
+    struct cryptoini *cri);
 static int aesni_cipher_setup(struct aesni_session *ses,
     struct cryptoini *encini, struct cryptoini *authini);
 static int aesni_cipher_process(struct aesni_session *ses,
@@ -172,12 +165,9 @@ aesni_attach(device_t dev)
 	int i;
 
 	sc = device_get_softc(dev);
-	sc->dieing = 0;
-	TAILQ_INIT(&sc->sessions);
-	sc->sid = 1;
 
-	sc->cid = crypto_get_driverid(dev, CRYPTOCAP_F_HARDWARE |
-	    CRYPTOCAP_F_SYNC);
+	sc->cid = crypto_get_driverid(dev, sizeof(struct aesni_session),
+	    CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SYNC);
 	if (sc->cid < 0) {
 		device_printf(dev, "Could not get crypto driver id.\n");
 		return (ENOMEM);
@@ -193,8 +183,6 @@ aesni_attach(device_t dev)
 		mtx_init(&ctx_mtx[i], "anifpumtx", NULL, MTX_DEF|MTX_NEW);
 	}
 
-	rw_init(&sc->lock, "aesni_lock");
-
 	detect_cpu_features(&sc->has_aes, &sc->has_sha);
 	if (sc->has_aes) {
 		crypto_register(sc->cid, CRYPTO_AES_CBC, 0, 0);
@@ -217,36 +205,18 @@ static int
 aesni_detach(device_t dev)
 {
 	struct aesni_softc *sc;
-	struct aesni_session *ses;
 
 	sc = device_get_softc(dev);
 
-	rw_wlock(&sc->lock);
-	TAILQ_FOREACH(ses, &sc->sessions, next) {
-		if (ses->used) {
-			rw_wunlock(&sc->lock);
-			device_printf(dev,
-			    "Cannot detach, sessions still active.\n");
-			return (EBUSY);
-		}
-	}
-	sc->dieing = 1;
-	while ((ses = TAILQ_FIRST(&sc->sessions)) != NULL) {
-		TAILQ_REMOVE(&sc->sessions, ses, next);
-		free(ses, M_AESNI);
-	}
-	rw_wunlock(&sc->lock);
 	crypto_unregister_all(sc->cid);
 
-	rw_destroy(&sc->lock);
-
 	aesni_cleanctx();
 
 	return (0);
 }
 
 static int
-aesni_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
+aesni_newsession(device_t dev, crypto_session_t cses, struct cryptoini *cri)
 {
 	struct aesni_softc *sc;
 	struct aesni_session *ses;
@@ -254,16 +224,16 @@ aesni_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
 	bool gcm_hash, gcm;
 	int error;
 
-	if (sidp == NULL || cri == NULL) {
-		CRYPTDEB("no sidp or cri");
+	KASSERT(cses != NULL, ("EDOOFUS"));
+	if (cri == NULL) {
+		CRYPTDEB("no cri");
 		return (EINVAL);
 	}
 
 	sc = device_get_softc(dev);
-	if (sc->dieing)
-		return (EINVAL);
 
-	ses = NULL;
+	ses = crypto_get_driver_session(cses);
+
 	authini = NULL;
 	encini = NULL;
 	gcm = false;
@@ -321,30 +291,6 @@ unhandled:
 	if (gcm_hash != gcm)
 		return (EINVAL);
 
-	rw_wlock(&sc->lock);
-	if (sc->dieing) {
-		rw_wunlock(&sc->lock);
-		return (EINVAL);
-	}
-	/*
-	 * Free sessions are inserted at the head of the list.  So if the first
-	 * session is used, none are free and we must allocate a new one.
-	 */
-	ses = TAILQ_FIRST(&sc->sessions);
-	if (ses == NULL || ses->used) {
-		ses = malloc(sizeof(*ses), M_AESNI, M_NOWAIT | M_ZERO);
-		if (ses == NULL) {
-			rw_wunlock(&sc->lock);
-			return (ENOMEM);
-		}
-		ses->id = sc->sid++;
-	} else {
-		TAILQ_REMOVE(&sc->sessions, ses, next);
-	}
-	ses->used = 1;
-	TAILQ_INSERT_TAIL(&sc->sessions, ses, next);
-	rw_wunlock(&sc->lock);
-
 	if (encini != NULL)
 		ses->algo = encini->cri_alg;
 	if (authini != NULL)
@@ -353,50 +299,9 @@ unhandled:
 	error = aesni_cipher_setup(ses, encini, authini);
 	if (error != 0) {
 		CRYPTDEB("setup failed");
-		rw_wlock(&sc->lock);
-		aesni_freesession_locked(sc, ses);
-		rw_wunlock(&sc->lock);
 		return (error);
 	}
 
-	*sidp = ses->id;
-	return (0);
-}
-
-static void
-aesni_freesession_locked(struct aesni_softc *sc, struct aesni_session *ses)
-{
-	uint32_t sid;
-
-	rw_assert(&sc->lock, RA_WLOCKED);
-
-	sid = ses->id;
-	TAILQ_REMOVE(&sc->sessions, ses, next);
-	explicit_bzero(ses, sizeof(*ses));
-	ses->id = sid;
-	TAILQ_INSERT_HEAD(&sc->sessions, ses, next);
-}
-
-static int
-aesni_freesession(device_t dev, uint64_t tid)
-{
-	struct aesni_softc *sc;
-	struct aesni_session *ses;
-	uint32_t sid;
-
-	sc = device_get_softc(dev);
-	sid = ((uint32_t)tid) & 0xffffffff;
-	rw_wlock(&sc->lock);
-	TAILQ_FOREACH_REVERSE(ses, &sc->sessions, aesni_sessions_head, next) {
-		if (ses->id == sid)
-			break;
-	}
-	if (ses == NULL) {
-		rw_wunlock(&sc->lock);
-		return (EINVAL);
-	}
-	aesni_freesession_locked(sc, ses);
-	rw_wunlock(&sc->lock);
 	return (0);
 }
 
@@ -419,7 +324,8 @@ aesni_process(device_t dev, struct cryptop *crp, int hint __unused)
 	if (crp == NULL)
 		return (EINVAL);
 
-	if (crp->crp_callback == NULL || crp->crp_desc == NULL) {
+	if (crp->crp_callback == NULL || crp->crp_desc == NULL ||
+	    crp->crp_session == NULL) {
 		error = EINVAL;
 		goto out;
 	}
@@ -472,16 +378,8 @@ aesni_process(device_t dev, struct cryptop *crp, int hint __unused)
 		goto out;
 	}
 
-	rw_rlock(&sc->lock);
-	TAILQ_FOREACH_REVERSE(ses, &sc->sessions, aesni_sessions_head, next) {
-		if (ses->id == (crp->crp_sid & 0xffffffff))
-			break;
-	}
-	rw_runlock(&sc->lock);
-	if (ses == NULL) {
-		error = EINVAL;
-		goto out;
-	}
+	ses = crypto_get_driver_session(crp->crp_session);
+	KASSERT(ses != NULL, ("EDOOFUS"));
 
 	error = aesni_cipher_process(ses, enccrd, authcrd, crp);
 	if (error != 0)
@@ -537,7 +435,6 @@ static device_method_t aesni_methods[] = {
 	DEVMETHOD(device_detach, aesni_detach),
 
 	DEVMETHOD(cryptodev_newsession, aesni_newsession),
-	DEVMETHOD(cryptodev_freesession, aesni_freesession),
 	DEVMETHOD(cryptodev_process, aesni_process),
 
 	DEVMETHOD_END
diff --git a/sys/crypto/aesni/aesni.h b/sys/crypto/aesni/aesni.h
index c1b95c7d61625..2caa43f7d763d 100644
--- a/sys/crypto/aesni/aesni.h
+++ b/sys/crypto/aesni/aesni.h
@@ -66,8 +66,6 @@ struct aesni_session {
 	int used;
 	int auth_algo;
 	int mlen;
-	uint32_t id;
-	TAILQ_ENTRY(aesni_session) next;
 };
 
 /*
diff --git a/sys/crypto/armv8/armv8_crypto.c b/sys/crypto/armv8/armv8_crypto.c
index 4f753dc16012f..c11053cc8e172 100644
--- a/sys/crypto/armv8/armv8_crypto.c
+++ b/sys/crypto/armv8/armv8_crypto.c
@@ -63,8 +63,6 @@ __FBSDID("$FreeBSD$");
 struct armv8_crypto_softc {
 	int		dieing;
 	int32_t		cid;
-	uint32_t	sid;
-	TAILQ_HEAD(armv8_crypto_sessions_head, armv8_crypto_session) sessions;
 	struct rwlock	lock;
 };
 
@@ -84,8 +82,6 @@ static struct fpu_kern_ctx **ctx_vfp;
 		(ctx) = NULL;					\
 	} while (0)
 
-static void armv8_crypto_freesession_locked(struct armv8_crypto_softc *,
-    struct armv8_crypto_session *);
 static int armv8_crypto_cipher_process(struct armv8_crypto_session *,
     struct cryptodesc *, struct cryptop *);
 
@@ -130,12 +126,10 @@ armv8_crypto_attach(device_t dev)
 	int i;
 
 	sc = device_get_softc(dev);
-	TAILQ_INIT(&sc->sessions);
 	sc->dieing = 0;
-	sc->sid = 1;
 
-	sc->cid = crypto_get_driverid(dev, CRYPTOCAP_F_HARDWARE |
-	    CRYPTOCAP_F_SYNC);
+	sc->cid = crypto_get_driverid(dev, sizeof(struct armv8_crypto_session),
+	    CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SYNC);
 	if (sc->cid < 0) {
 		device_printf(dev, "Could not get crypto driver id.\n");
 		return (ENOMEM);
@@ -162,25 +156,12 @@ static int
 armv8_crypto_detach(device_t dev)
 {
 	struct armv8_crypto_softc *sc;
-	struct armv8_crypto_session *ses;
 	int i;
 
 	sc = device_get_softc(dev);
 
 	rw_wlock(&sc->lock);
-	TAILQ_FOREACH(ses, &sc->sessions, next) {
-		if (ses->used) {
-			rw_wunlock(&sc->lock);
-			device_printf(dev,
-			    "Cannot detach, sessions still active.\n");
-			return (EBUSY);
-		}
-	}
 	sc->dieing = 1;
-	while ((ses = TAILQ_FIRST(&sc->sessions)) != NULL) {
-		TAILQ_REMOVE(&sc->sessions, ses, next);
-		free(ses, M_ARMV8_CRYPTO);
-	}
 	rw_wunlock(&sc->lock);
 	crypto_unregister_all(sc->cid);
 
@@ -241,15 +222,16 @@ armv8_crypto_cipher_setup(struct armv8_crypto_session *ses,
 }
 
 static int
-armv8_crypto_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
+armv8_crypto_newsession(device_t dev, crypto_session_t cses,
+    struct cryptoini *cri)
 {
 	struct armv8_crypto_softc *sc;
 	struct armv8_crypto_session *ses;
 	struct cryptoini *encini;
 	int error;
 
-	if (sidp == NULL || cri == NULL) {
-		CRYPTDEB("no sidp or cri");
+	if (cri == NULL) {
+		CRYPTDEB("no cri");
 		return (EINVAL);
 	}
 
@@ -284,83 +266,21 @@ armv8_crypto_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
 		return (EINVAL);
 	}
 
-	/*
-	 * Free sessions goes first, so if first session is used, we need to
-	 * allocate one.
-	 */
-	ses = TAILQ_FIRST(&sc->sessions);
-	if (ses == NULL || ses->used) {
-		ses = malloc(sizeof(*ses), M_ARMV8_CRYPTO, M_NOWAIT | M_ZERO);
-		if (ses == NULL) {
-			rw_wunlock(&sc->lock);
-			return (ENOMEM);
-		}
-		ses->id = sc->sid++;
-	} else {
-		TAILQ_REMOVE(&sc->sessions, ses, next);
-	}
-	ses->used = 1;
-	TAILQ_INSERT_TAIL(&sc->sessions, ses, next);
-	rw_wunlock(&sc->lock);
+	ses = crypto_get_driver_session(cses);
 	ses->algo = encini->cri_alg;
 
 	error = armv8_crypto_cipher_setup(ses, encini);
 	if (error != 0) {
 		CRYPTDEB("setup failed");
-		rw_wlock(&sc->lock);
-		armv8_crypto_freesession_locked(sc, ses);
-		rw_wunlock(&sc->lock);
 		return (error);
 	}
 
-	*sidp = ses->id;
-	return (0);
-}
-
-static void
-armv8_crypto_freesession_locked(struct armv8_crypto_softc *sc,
-    struct armv8_crypto_session *ses)
-{
-	uint32_t sid;
-
-	rw_assert(&sc->lock, RA_WLOCKED);
-
-	sid = ses->id;
-	TAILQ_REMOVE(&sc->sessions, ses, next);
-	*ses = (struct armv8_crypto_session){};
-	ses->id = sid;
-	TAILQ_INSERT_HEAD(&sc->sessions, ses, next);
-}
-
-static int
-armv8_crypto_freesession(device_t dev, uint64_t tid)
-{
-	struct armv8_crypto_softc *sc;
-	struct armv8_crypto_session *ses;
-	uint32_t sid;
-
-	sc = device_get_softc(dev);
-	sid = ((uint32_t)tid) & 0xffffffff;
-	rw_wlock(&sc->lock);
-	TAILQ_FOREACH_REVERSE(ses, &sc->sessions, armv8_crypto_sessions_head,
-	    next) {
-		if (ses->id == sid)
-			break;
-	}
-	if (ses == NULL) {
-		rw_wunlock(&sc->lock);
-		return (EINVAL);
-	}
-	armv8_crypto_freesession_locked(sc, ses);
-	rw_wunlock(&sc->lock);
-
 	return (0);
 }
 
 static int
 armv8_crypto_process(device_t dev, struct cryptop *crp, int hint __unused)
 {
-	struct armv8_crypto_softc *sc = device_get_softc(dev);
 	struct cryptodesc *crd, *enccrd;
 	struct armv8_crypto_session *ses;
 	int error;
@@ -403,18 +323,7 @@ armv8_crypto_process(device_t dev, struct cryptop *crp, int hint __unused)
 		goto out;
 	}
 
-	rw_rlock(&sc->lock);
-	TAILQ_FOREACH_REVERSE(ses, &sc->sessions, armv8_crypto_sessions_head,
-	    next) {
-		if (ses->id == (crp->crp_sid & 0xffffffff))
-			break;
-	}
-	rw_runlock(&sc->lock);
-	if (ses == NULL) {
-		error = EINVAL;
-		goto out;
-	}
-
+	ses = crypto_get_driver_session(crp->crp_session);
 	error = armv8_crypto_cipher_process(ses, enccrd, crp);
 
 out:
@@ -546,7 +455,6 @@ static device_method_t armv8_crypto_methods[] = {
 	DEVMETHOD(device_detach,	armv8_crypto_detach),
 
 	DEVMETHOD(cryptodev_newsession,	armv8_crypto_newsession),
-	DEVMETHOD(cryptodev_freesession, armv8_crypto_freesession),
 	DEVMETHOD(cryptodev_process,	armv8_crypto_process),
 
 	DEVMETHOD_END,
diff --git a/sys/crypto/armv8/armv8_crypto.h b/sys/crypto/armv8/armv8_crypto.h
index 32a2b2107185c..01d31f7cec787 100644
--- a/sys/crypto/armv8/armv8_crypto.h
+++ b/sys/crypto/armv8/armv8_crypto.h
@@ -42,9 +42,6 @@ struct armv8_crypto_session {
 	uint32_t dec_schedule[AES_SCHED_LEN/4];
 	int algo;
 	int rounds;
-	int used;
-	uint32_t id;
-	TAILQ_ENTRY(armv8_crypto_session) next;
 };
 
 void armv8_aes_encrypt_cbc(int, const void *, size_t, const uint8_t *,
diff --git a/sys/crypto/blake2/blake2_cryptodev.c b/sys/crypto/blake2/blake2_cryptodev.c
index 597aa493ef562..f6c0a56576290 100644
--- a/sys/crypto/blake2/blake2_cryptodev.c
+++ b/sys/crypto/blake2/blake2_cryptodev.c
@@ -53,17 +53,12 @@ struct blake2_session {
 	size_t klen;
 	size_t mlen;
 	uint8_t key[BLAKE2B_KEYBYTES];
-	bool used;
-	uint32_t id;
-	TAILQ_ENTRY(blake2_session) next;
 };
 CTASSERT((size_t)BLAKE2B_KEYBYTES > (size_t)BLAKE2S_KEYBYTES);
 
 struct blake2_softc {
 	bool	dying;
 	int32_t cid;
-	uint32_t sid;
-	TAILQ_HEAD(blake2_sessions_head, blake2_session) sessions;
 	struct rwlock lock;
 };
 
@@ -83,10 +78,8 @@ static struct fpu_kern_ctx **ctx_fpu;
 		(ctx) = NULL;					\
 	} while (0)
 
-static int blake2_newsession(device_t, uint32_t *sidp, struct cryptoini *cri);
-static int blake2_freesession(device_t, uint64_t tid);
-static void blake2_freesession_locked(struct blake2_softc *sc,
-    struct blake2_session *ses);
+static int blake2_newsession(device_t, crypto_session_t cses,
+    struct cryptoini *cri);
 static int blake2_cipher_setup(struct blake2_session *ses,
     struct cryptoini *authini);
 static int blake2_cipher_process(struct blake2_session *ses,
@@ -138,11 +131,9 @@ blake2_attach(device_t dev)
 
 	sc = device_get_softc(dev);
 	sc->dying = false;
-	TAILQ_INIT(&sc->sessions);
-	sc->sid = 1;
 
-	sc->cid = crypto_get_driverid(dev, CRYPTOCAP_F_HARDWARE |
-	    CRYPTOCAP_F_SYNC);
+	sc->cid = crypto_get_driverid(dev, sizeof(struct blake2_session),
+	    CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SYNC);
 	if (sc->cid < 0) {
 		device_printf(dev, "Could not get crypto driver id.\n");
 		return (ENOMEM);
@@ -169,24 +160,11 @@ static int
 blake2_detach(device_t dev)
 {
 	struct blake2_softc *sc;
-	struct blake2_session *ses;
 
 	sc = device_get_softc(dev);
 
 	rw_wlock(&sc->lock);
-	TAILQ_FOREACH(ses, &sc->sessions, next) {
-		if (ses->used) {
-			rw_wunlock(&sc->lock);
-			device_printf(dev,
-			    "Cannot detach, sessions still active.\n");
-			return (EBUSY);
-		}
-	}
 	sc->dying = true;
-	while ((ses = TAILQ_FIRST(&sc->sessions)) != NULL) {
-		TAILQ_REMOVE(&sc->sessions, ses, next);
-		free(ses, M_BLAKE2);
-	}
 	rw_wunlock(&sc->lock);
 	crypto_unregister_all(sc->cid);
 
@@ -198,21 +176,20 @@ blake2_detach(device_t dev)
 }
 
 static int
-blake2_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
+blake2_newsession(device_t dev, crypto_session_t cses, struct cryptoini *cri)
 {
 	struct blake2_softc *sc;
 	struct blake2_session *ses;
 	struct cryptoini *authini;
 	int error;
 
-	if (sidp == NULL || cri == NULL) {
-		CRYPTDEB("no sidp or cri");
+	if (cri == NULL) {
+		CRYPTDEB("no cri");
 		return (EINVAL);
 	}
 
 	sc = device_get_softc(dev);
 
-	ses = NULL;
 	authini = NULL;
 	for (; cri != NULL; cri = cri->cri_next) {
 		switch (cri->cri_alg) {
@@ -239,85 +216,27 @@ blake2_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
 		rw_wunlock(&sc->lock);
 		return (EINVAL);
 	}
-	/*
-	 * Free sessions are inserted at the head of the list.  So if the first
-	 * session is used, none are free and we must allocate a new one.
-	 */
-	ses = TAILQ_FIRST(&sc->sessions);
-	if (ses == NULL || ses->used) {
-		ses = malloc(sizeof(*ses), M_BLAKE2, M_NOWAIT | M_ZERO);
-		if (ses == NULL) {
-			rw_wunlock(&sc->lock);
-			return (ENOMEM);
-		}
-		ses->id = sc->sid++;
-	} else {
-		TAILQ_REMOVE(&sc->sessions, ses, next);
-	}
-	ses->used = true;
-	TAILQ_INSERT_TAIL(&sc->sessions, ses, next);
 	rw_wunlock(&sc->lock);
 
+	ses = crypto_get_driver_session(cses);
+
 	ses->algo = authini->cri_alg;
 	error = blake2_cipher_setup(ses, authini);
 	if (error != 0) {
 		CRYPTDEB("setup failed");
-		rw_wlock(&sc->lock);
-		blake2_freesession_locked(sc, ses);
-		rw_wunlock(&sc->lock);
 		return (error);
 	}
 
-	*sidp = ses->id;
-	return (0);
-}
-
-static void
-blake2_freesession_locked(struct blake2_softc *sc, struct blake2_session *ses)
-{
-	uint32_t sid;
-
-	rw_assert(&sc->lock, RA_WLOCKED);
-
-	sid = ses->id;
-	TAILQ_REMOVE(&sc->sessions, ses, next);
-	explicit_bzero(ses, sizeof(*ses));
-	ses->id = sid;
-	TAILQ_INSERT_HEAD(&sc->sessions, ses, next);
-}
-
-static int
-blake2_freesession(device_t dev, uint64_t tid)
-{
-	struct blake2_softc *sc;
-	struct blake2_session *ses;
-	uint32_t sid;
-
-	sc = device_get_softc(dev);
-	sid = ((uint32_t)tid) & 0xffffffff;
-	rw_wlock(&sc->lock);
-	TAILQ_FOREACH_REVERSE(ses, &sc->sessions, blake2_sessions_head, next) {
-		if (ses->id == sid)
-			break;
-	}
-	if (ses == NULL) {
-		rw_wunlock(&sc->lock);
-		return (EINVAL);
-	}
-	blake2_freesession_locked(sc, ses);
-	rw_wunlock(&sc->lock);
 	return (0);
 }
 
 static int
 blake2_process(device_t dev, struct cryptop *crp, int hint __unused)
 {
-	struct blake2_softc *sc;
 	struct blake2_session *ses;
 	struct cryptodesc *crd, *authcrd;
 	int error;
 
-	sc = device_get_softc(dev);
 	ses = NULL;
 	error = 0;
 	authcrd = NULL;
@@ -348,17 +267,7 @@ blake2_process(device_t dev, struct cryptop *crp, int hint __unused)
 		}
 	}
 
-	rw_rlock(&sc->lock);
-	TAILQ_FOREACH_REVERSE(ses, &sc->sessions, blake2_sessions_head, next) {
-		if (ses->id == (crp->crp_sid & 0xffffffff))
-			break;
-	}
-	rw_runlock(&sc->lock);
-	if (ses == NULL) {
-		error = EINVAL;
-		goto out;
-	}
-
+	ses = crypto_get_driver_session(crp->crp_session);
 	error = blake2_cipher_process(ses, crp);
 	if (error != 0)
 		goto out;
@@ -376,7 +285,6 @@ static device_method_t blake2_methods[] = {
 	DEVMETHOD(device_detach, blake2_detach),
 
 	DEVMETHOD(cryptodev_newsession, blake2_newsession),
-	DEVMETHOD(cryptodev_freesession, blake2_freesession),
 	DEVMETHOD(cryptodev_process, blake2_process),
 
 	DEVMETHOD_END
diff --git a/sys/crypto/ccp/ccp.c b/sys/crypto/ccp/ccp.c
index e50407a8f599a..f6235bc1610be 100644
--- a/sys/crypto/ccp/ccp.c
+++ b/sys/crypto/ccp/ccp.c
@@ -238,7 +238,8 @@ ccp_attach(device_t dev)
 	sc = device_get_softc(dev);
 	sc->dev = dev;
 
-	sc->cid = crypto_get_driverid(dev, CRYPTOCAP_F_HARDWARE);
+	sc->cid = crypto_get_driverid(dev, sizeof(struct ccp_session),
+	    CRYPTOCAP_F_HARDWARE);
 	if (sc->cid < 0) {
 		device_printf(dev, "could not get crypto driver id\n");
 		return (ENXIO);
@@ -281,17 +282,10 @@ static int
 ccp_detach(device_t dev)
 {
 	struct ccp_softc *sc;
-	int i;
 
 	sc = device_get_softc(dev);
 
 	mtx_lock(&sc->lock);
-	for (i = 0; i < sc->nsessions; i++) {
-		if (sc->sessions[i].active || sc->sessions[i].pending != 0) {
-			mtx_unlock(&sc->lock);
-			return (EBUSY);
-		}
-	}
 	sc->detaching = true;
 	mtx_unlock(&sc->lock);
 
@@ -305,7 +299,6 @@ ccp_detach(device_t dev)
 	if (g_ccp_softc == sc)
 		g_ccp_softc = NULL;
 
-	free(sc->sessions, M_CCP);
 	mtx_destroy(&sc->lock);
 	return (0);
 }
@@ -393,7 +386,7 @@ ccp_aes_setkey(struct ccp_session *s, int alg, const void *key, int klen)
 }
 
 static int
-ccp_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
+ccp_newsession(device_t dev, crypto_session_t cses, struct cryptoini *cri)
 {
 	struct ccp_softc *sc;
 	struct ccp_session *s;
@@ -403,12 +396,14 @@ ccp_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
 	unsigned auth_mode, iv_len;
 	unsigned partial_digest_len;
 	unsigned q;
-	int error, i, sess;
+	int error;
 	bool gcm_hash;
 
-	if (sidp == NULL || cri == NULL)
+	if (cri == NULL)
 		return (EINVAL);
 
+	s = crypto_get_driver_session(cses);
+
 	gcm_hash = false;
 	cipher = NULL;
 	hash = NULL;
@@ -510,29 +505,6 @@ ccp_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
 		mtx_unlock(&sc->lock);
 		return (ENXIO);
 	}
-	sess = -1;
-	for (i = 0; i < sc->nsessions; i++) {
-		if (!sc->sessions[i].active && sc->sessions[i].pending == 0) {
-			sess = i;
-			break;
-		}
-	}
-	if (sess == -1) {
-		s = malloc(sizeof(*s) * (sc->nsessions + 1), M_CCP,
-		    M_NOWAIT | M_ZERO);
-		if (s == NULL) {
-			mtx_unlock(&sc->lock);
-			return (ENOMEM);
-		}
-		if (sc->sessions != NULL)
-			memcpy(s, sc->sessions, sizeof(*s) * sc->nsessions);
-		sess = sc->nsessions;
-		free(sc->sessions, M_CCP);
-		sc->sessions = s;
-		sc->nsessions++;
-	}
-
-	s = &sc->sessions[sess];
 
 	/* Just grab the first usable queue for now. */
 	for (q = 0; q < nitems(sc->queues); q++)
@@ -581,32 +553,21 @@ ccp_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
 	s->active = true;
 	mtx_unlock(&sc->lock);
 
-	*sidp = sess;
 	return (0);
 }
 
-static int
-ccp_freesession(device_t dev, uint64_t tid)
+static void
+ccp_freesession(device_t dev, crypto_session_t cses)
 {
-	struct ccp_softc *sc;
-	uint32_t sid;
-	int error;
+	struct ccp_session *s;
 
-	sc = device_get_softc(dev);
-	sid = CRYPTO_SESID2LID(tid);
-	mtx_lock(&sc->lock);
-	if (sid >= sc->nsessions || !sc->sessions[sid].active)
-		error = EINVAL;
-	else {
-		if (sc->sessions[sid].pending != 0)
-			device_printf(dev,
-			    "session %d freed with %d pending requests\n", sid,
-			    sc->sessions[sid].pending);
-		sc->sessions[sid].active = false;
-		error = 0;
-	}
-	mtx_unlock(&sc->lock);
-	return (error);
+	s = crypto_get_driver_session(cses);
+
+	if (s->pending != 0)
+		device_printf(dev,
+		    "session %p freed with %d pending requests\n", s,
+		    s->pending);
+	s->active = false;
 }
 
 static int
@@ -616,7 +577,6 @@ ccp_process(device_t dev, struct cryptop *crp, int hint)
 	struct ccp_queue *qp;
 	struct ccp_session *s;
 	struct cryptodesc *crd, *crda, *crde;
-	uint32_t sid;
 	int error;
 	bool qpheld;
 
@@ -626,16 +586,9 @@ ccp_process(device_t dev, struct cryptop *crp, int hint)
 		return (EINVAL);
 
 	crd = crp->crp_desc;
-	sid = CRYPTO_SESID2LID(crp->crp_sid);
+	s = crypto_get_driver_session(crp->crp_session);
 	sc = device_get_softc(dev);
 	mtx_lock(&sc->lock);
-	if (sid >= sc->nsessions || !sc->sessions[sid].active) {
-		mtx_unlock(&sc->lock);
-		error = EINVAL;
-		goto out;
-	}
-
-	s = &sc->sessions[sid];
 	qp = &sc->queues[s->queue];
 	mtx_unlock(&sc->lock);
 	error = ccp_queue_acquire_reserve(qp, 1 /* placeholder */, M_NOWAIT);
@@ -856,7 +809,6 @@ db_show_ccp_sc(struct ccp_softc *sc)
 
 	db_printf("ccp softc at %p\n", sc);
 	db_printf(" cid: %d\n", (int)sc->cid);
-	db_printf(" nsessions: %d\n", sc->nsessions);
 
 	db_printf(" lock: ");
 	db_show_lock(&sc->lock);
diff --git a/sys/crypto/ccp/ccp.h b/sys/crypto/ccp/ccp.h
index 57959258132a8..e622e475f0a85 100644
--- a/sys/crypto/ccp/ccp.h
+++ b/sys/crypto/ccp/ccp.h
@@ -134,8 +134,6 @@ struct ccp_completion_ctx {
 struct ccp_softc {
 	device_t dev;
 	int32_t cid;
-	struct ccp_session *sessions;
-	int nsessions;
 	struct mtx lock;
 	bool detaching;
 
diff --git a/sys/crypto/via/padlock.c b/sys/crypto/via/padlock.c
index e53946b3251af..66ef76bf05bbe 100644
--- a/sys/crypto/via/padlock.c
+++ b/sys/crypto/via/padlock.c
@@ -58,15 +58,12 @@ __FBSDID("$FreeBSD$");
 
 struct padlock_softc {
 	int32_t		sc_cid;
-	uint32_t	sc_sid;
-	TAILQ_HEAD(padlock_sessions_head, padlock_session) sc_sessions;
-	struct rwlock	sc_sessions_lock;
 };
 
-static int padlock_newsession(device_t, uint32_t *sidp, struct cryptoini *cri);
-static int padlock_freesession(device_t, uint64_t tid);
+static int padlock_newsession(device_t, crypto_session_t cses, struct cryptoini *cri);
+static void padlock_freesession(device_t, crypto_session_t cses);
 static void padlock_freesession_one(struct padlock_softc *sc,
-    struct padlock_session *ses, int locked);
+    struct padlock_session *ses);
 static int padlock_process(device_t, struct cryptop *crp, int hint __unused);
 
 MALLOC_DEFINE(M_PADLOCK, "padlock_data", "PadLock Data");
@@ -119,16 +116,13 @@ padlock_attach(device_t dev)
 {
 	struct padlock_softc *sc = device_get_softc(dev);
 
-	TAILQ_INIT(&sc->sc_sessions);
-	sc->sc_sid = 1;
-
-	sc->sc_cid = crypto_get_driverid(dev, CRYPTOCAP_F_HARDWARE);
+	sc->sc_cid = crypto_get_driverid(dev, sizeof(struct padlock_session),
+	    CRYPTOCAP_F_HARDWARE);
 	if (sc->sc_cid < 0) {
 		device_printf(dev, "Could not get crypto driver id.\n");
 		return (ENOMEM);
 	}
 
-	rw_init(&sc->sc_sessions_lock, "padlock_lock");
 	crypto_register(sc->sc_cid, CRYPTO_AES_CBC, 0, 0);
 	crypto_register(sc->sc_cid, CRYPTO_MD5_HMAC, 0, 0);
 	crypto_register(sc->sc_cid, CRYPTO_SHA1_HMAC, 0, 0);
@@ -143,29 +137,13 @@ static int
 padlock_detach(device_t dev)
 {
 	struct padlock_softc *sc = device_get_softc(dev);
-	struct padlock_session *ses;
 
-	rw_wlock(&sc->sc_sessions_lock);
-	TAILQ_FOREACH(ses, &sc->sc_sessions, ses_next) {
-		if (ses->ses_used) {
-			rw_wunlock(&sc->sc_sessions_lock);
-			device_printf(dev,
-			    "Cannot detach, sessions still active.\n");
-			return (EBUSY);
-		}
-	}
-	while ((ses = TAILQ_FIRST(&sc->sc_sessions)) != NULL) {
-		TAILQ_REMOVE(&sc->sc_sessions, ses, ses_next);
-		fpu_kern_free_ctx(ses->ses_fpu_ctx);
-		free(ses, M_PADLOCK);
-	}
-	rw_destroy(&sc->sc_sessions_lock);
 	crypto_unregister_all(sc->sc_cid);
 	return (0);
 }
 
 static int
-padlock_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
+padlock_newsession(device_t dev, crypto_session_t cses, struct cryptoini *cri)
 {
 	struct padlock_softc *sc = device_get_softc(dev);
 	struct padlock_session *ses = NULL;
@@ -173,7 +151,7 @@ padlock_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
 	struct thread *td;
 	int error;
 
-	if (sidp == NULL || cri == NULL)
+	if (cri == NULL)
 		return (EINVAL);
 
 	encini = macini = NULL;
@@ -208,39 +186,12 @@ padlock_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
 	if (encini == NULL)
 		return (EINVAL);
 
-	/*
-	 * Let's look for a free session structure.
-	 */
-	rw_wlock(&sc->sc_sessions_lock);
-	/*
-	 * Free sessions goes first, so if first session is used, we need to
-	 * allocate one.
-	 */
-	ses = TAILQ_FIRST(&sc->sc_sessions);
-	if (ses == NULL || ses->ses_used) {
-		ses = malloc(sizeof(*ses), M_PADLOCK, M_NOWAIT | M_ZERO);
-		if (ses == NULL) {
-			rw_wunlock(&sc->sc_sessions_lock);
-			return (ENOMEM);
-		}
-		ses->ses_fpu_ctx = fpu_kern_alloc_ctx(FPU_KERN_NORMAL |
-		    FPU_KERN_NOWAIT);
-		if (ses->ses_fpu_ctx == NULL) {
-			free(ses, M_PADLOCK);
-			rw_wunlock(&sc->sc_sessions_lock);
-			return (ENOMEM);
-		}
-		ses->ses_id = sc->sc_sid++;
-	} else {
-		TAILQ_REMOVE(&sc->sc_sessions, ses, ses_next);
-	}
-	ses->ses_used = 1;
-	TAILQ_INSERT_TAIL(&sc->sc_sessions, ses, ses_next);
-	rw_wunlock(&sc->sc_sessions_lock);
+	ses = crypto_get_driver_session(cses);
+	ses->ses_fpu_ctx = fpu_kern_alloc_ctx(FPU_KERN_NORMAL);
 
 	error = padlock_cipher_setup(ses, encini);
 	if (error != 0) {
-		padlock_freesession_one(sc, ses, 0);
+		padlock_freesession_one(sc, ses);
 		return (error);
 	}
 
@@ -251,62 +202,35 @@ padlock_newsession(device_t dev, uint32_t *sidp, struct cryptoini *cri)
 		error = padlock_hash_setup(ses, macini);
 		fpu_kern_leave(td, ses->ses_fpu_ctx);
 		if (error != 0) {
-			padlock_freesession_one(sc, ses, 0);
+			padlock_freesession_one(sc, ses);
 			return (error);
 		}
 	}
 
-	*sidp = ses->ses_id;
 	return (0);
 }
 
 static void
-padlock_freesession_one(struct padlock_softc *sc, struct padlock_session *ses,
-    int locked)
+padlock_freesession_one(struct padlock_softc *sc, struct padlock_session *ses)
 {
-	struct fpu_kern_ctx *ctx;
-	uint32_t sid = ses->ses_id;
 
-	if (!locked)
-		rw_wlock(&sc->sc_sessions_lock);
-	TAILQ_REMOVE(&sc->sc_sessions, ses, ses_next);
 	padlock_hash_free(ses);
-	ctx = ses->ses_fpu_ctx;
-	bzero(ses, sizeof(*ses));
-	ses->ses_used = 0;
-	ses->ses_id = sid;
-	ses->ses_fpu_ctx = ctx;
-	TAILQ_INSERT_HEAD(&sc->sc_sessions, ses, ses_next);
-	if (!locked)
-		rw_wunlock(&sc->sc_sessions_lock);
+	fpu_kern_free_ctx(ses->ses_fpu_ctx);
 }
 
-static int
-padlock_freesession(device_t dev, uint64_t tid)
+static void
+padlock_freesession(device_t dev, crypto_session_t cses)
 {
 	struct padlock_softc *sc = device_get_softc(dev);
 	struct padlock_session *ses;
-	uint32_t sid = ((uint32_t)tid) & 0xffffffff;
 
-	rw_wlock(&sc->sc_sessions_lock);
-	TAILQ_FOREACH_REVERSE(ses, &sc->sc_sessions, padlock_sessions_head,
-	    ses_next) {
-		if (ses->ses_id == sid)
-			break;
-	}
-	if (ses == NULL) {
-		rw_wunlock(&sc->sc_sessions_lock);
-		return (EINVAL);
-	}
-	padlock_freesession_one(sc, ses, 1);
-	rw_wunlock(&sc->sc_sessions_lock);
-	return (0);
+	ses = crypto_get_driver_session(cses);
+	padlock_freesession_one(sc, ses);
 }
 
 static int
 padlock_process(device_t dev, struct cryptop *crp, int hint __unused)
 {
-	struct padlock_softc *sc = device_get_softc(dev);
 	struct padlock_session *ses = NULL;
 	struct cryptodesc *crd, *enccrd, *maccrd;
 	int error = 0;
@@ -353,17 +277,7 @@ padlock_process(device_t dev, struct cryptop *crp, int hint __unused)
 		goto out;
 	}
 
-	rw_rlock(&sc->sc_sessions_lock);
-	TAILQ_FOREACH_REVERSE(ses, &sc->sc_sessions, padlock_sessions_head,
-	    ses_next) {
-		if (ses->ses_id == (crp->crp_sid & 0xffffffff))
-			break;
-	}
-	rw_runlock(&sc->sc_sessions_lock);
-	if (ses == NULL) {
-		error = EINVAL;
-		goto out;
-	}
+	ses = crypto_get_driver_session(crp->crp_session);
 
 	/* Perform data authentication if requested before encryption. */
 	if (maccrd != NULL && maccrd->crd_next == enccrd) {
diff --git a/sys/crypto/via/padlock.h b/sys/crypto/via/padlock.h
index 77a4673d9e593..3b75238b98a33 100644
--- a/sys/crypto/via/padlock.h
+++ b/sys/crypto/via/padlock.h
@@ -73,9 +73,6 @@ struct padlock_session {
 	uint8_t		*ses_ictx;
 	uint8_t		*ses_octx;
 	int		ses_mlen;
-	int		ses_used;
-	uint32_t	ses_id;
-	TAILQ_ENTRY(padlock_session) ses_next;
 	struct fpu_kern_ctx *ses_fpu_ctx;
 };