 @@ -1,14 +1,14 @@
-/*	$NetBSD: crypto.c,v 1.87 2017/06/14 07:32:19 knakahara Exp $ */
+/*	$NetBSD: crypto.c,v 1.88 2017/06/14 07:36:24 knakahara Exp $ */
 /*	$FreeBSD: src/sys/opencrypto/crypto.c,v 1.4.2.5 2003/02/26 00:14:05 sam Exp $	*/
 /*	$OpenBSD: crypto.c,v 1.41 2002/07/17 23:52:38 art Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Coyote Point Systems, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -43,27 +43,27 @@
  * Permission to use, copy, and modify this software with or without fee
  * is hereby granted, provided that this entire notice is included in
  * all source code copies of any software which is or includes a copy or
  * modification of this software.
+ *
  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
  * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY
  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
  * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
  * PURPOSE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: crypto.c,v 1.87 2017/06/14 07:32:19 knakahara Exp $");
+__KERNEL_RCSID(0, "$NetBSD: crypto.c,v 1.88 2017/06/14 07:36:24 knakahara Exp $");
 #include <sys/param.h>
 #include <sys/reboot.h>
 #include <sys/systm.h>
 #include <sys/malloc.h>
 #include <sys/proc.h>
 #include <sys/pool.h>
 #include <sys/kthread.h>
 #include <sys/once.h>
 #include <sys/sysctl.h>
 #include <sys/intr.h>
 #include <sys/errno.h>
 #include <sys/module.h>
 @@ -491,49 +491,54 @@ crypto_destroy(bool exit_kthread)
 	pool_destroy(&cryptop_pool);
 	pool_destroy(&cryptodesc_pool);
 	pool_destroy(&cryptkop_pool);
 	cv_destroy(&cryptoret_cv);
 	mutex_destroy(&crypto_ret_q_mtx);
 	mutex_destroy(&crypto_q_mtx);
 	mutex_destroy(&crypto_drv_mtx);
 	return 0;
+}
-/*
+static bool
- * Create a new session.
+crypto_driver_suitable(struct cryptocap *cap, struct cryptoini *cri)
  */
 int
 crypto_newsession(u_int64_t *sid, struct cryptoini *cri, int hard)
+{
 	struct cryptoini *cr;
 	struct cryptocap *cap;
 	u_int32_t hid, lid;
 	int err = EINVAL;
-	mutex_enter(&crypto_drv_mtx);
+	for (cr = cri; cr; cr = cr->cri_next)
 		if (cap->cc_alg[cr->cri_alg] == 0) {
 			DPRINTF("alg %d not supported\n", cr->cri_alg);
 			return false;
+		}
-	/*
+	return true;
 	 * The algorithm we use here is pretty stupid; just use the
 	 * first driver that supports all the algorithms we need.
 /*
-	 * XXX We need more smarts here (in real life too, but that's
+ * The algorithm we use here is pretty stupid; just use the
-	 * XXX another story altogether).
+ * first driver that supports all the algorithms we need.
 	 */
  * XXX We need more smarts here (in real life too, but that's
  * XXX another story altogether).
  */
 static struct cryptocap *
 crypto_select_driver_lock(struct cryptoini *cri, int hard)
+{
 	u_int32_t hid;
 	for (hid = 0; hid < crypto_drivers_num; hid++) {
-		cap = crypto_checkdriver(hid);
+		struct cryptocap *cap = crypto_checkdriver(hid);
 		if (cap == NULL)
 			continue;
 		crypto_driver_lock(cap);
 		/*
 		 * If it's not initialized or has remaining sessions
 		 * referencing it, skip.
 		 */
 		if (cap->cc_newsession == NULL ||
 		    (cap->cc_flags & CRYPTOCAP_F_CLEANUP)) {
 			crypto_driver_unlock(cap);
 			continue;
 @@ -541,65 +546,79 @@ crypto_newsession(u_int64_t *sid, struct
 		/* Hardware required -- ignore software drivers. */
 		if (hard > 0 && (cap->cc_flags & CRYPTOCAP_F_SOFTWARE)) {
 			crypto_driver_unlock(cap);
 			continue;
+		}
 		/* Software required -- ignore hardware drivers. */
 		if (hard < 0 && (cap->cc_flags & CRYPTOCAP_F_SOFTWARE) == 0) {
 			crypto_driver_unlock(cap);
 			continue;
+		}
 		/* See if all the algorithms are supported. */
-		for (cr = cri; cr; cr = cr->cri_next)
+		if (crypto_driver_suitable(cap, cri)) {
-			if (cap->cc_alg[cr->cri_alg] == 0) {
+			/* keep holding crypto_driver_lock(cap) */
-				DPRINTF("alg %d not supported\n", cr->cri_alg);
+			return cap;
 				break;
-		if (cr == NULL) {
+		crypto_driver_unlock(cap);
 			/* Ok, all algorithms are supported. */
-			/*
+	return NULL;
 			 * Can't do everything in one session.
 			 * XXX Fix this. We need to inject a "virtual" session layer right
 			 * XXX about here.
 			 */
-			/* Call the driver initialization routine. */
+/*
-			lid = hid;		/* Pass the driver ID. */
+ * Create a new session.
-			crypto_driver_unlock(cap);
+ */
-			err = cap->cc_newsession(cap->cc_arg, &lid, cri);
+int
-			crypto_driver_lock(cap);
+crypto_newsession(u_int64_t *sid, struct cryptoini *cri, int hard)
 			if (err == 0) {
-				(*sid) = hid;
+	struct cryptocap *cap;
-				(*sid) <<= 32;
+	int err = EINVAL;
 				(*sid) |= (lid & 0xffffffff);
 				(cap->cc_sessions)++;
 			} else {
 				DPRINTF("crypto_drivers[%d].cc_newsession() failed. error=%d\n",
 					hid, err);
 			crypto_driver_unlock(cap);
 			goto done;
 			/*break;*/
 	mutex_enter(&crypto_drv_mtx);
 	cap = crypto_select_driver_lock(cri, hard);
 	if (cap != NULL) {
 		u_int32_t hid, lid;
 		hid = cap - crypto_drivers;
 		/*
 		 * Can't do everything in one session.
+		 *
 		 * XXX Fix this. We need to inject a "virtual" session layer right
 		 * XXX about here.
 		 */
 		/* Call the driver initialization routine. */
 		lid = hid;		/* Pass the driver ID. */
 		crypto_driver_unlock(cap);
 		err = cap->cc_newsession(cap->cc_arg, &lid, cri);
 		crypto_driver_lock(cap);
 		if (err == 0) {
 			(*sid) = hid;
 			(*sid) <<= 32;
 			(*sid) |= (lid & 0xffffffff);
 			(cap->cc_sessions)++;
 		} else {
 			DPRINTF("crypto_drivers[%d].cc_newsession() failed. error=%d\n",
 			    hid, err);
+		}
 		crypto_driver_unlock(cap);
+	}
 done:
 	mutex_exit(&crypto_drv_mtx);
 	return err;
+}
 /*
  * Delete an existing session (or a reserved session on an unregistered
  * driver).
  */
 int
 crypto_freesession(u_int64_t sid)
+{
 	struct cryptocap *cap;
 	int err = 0;