 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_rndq.c,v 1.43 2015/04/08 14:13:55 riastradh Exp $	*/
+/*	$NetBSD: kern_rndq.c,v 1.44 2015/04/13 14:41:06 riastradh Exp $	*/
 /*-
  * Copyright (c) 1997-2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Michael Graff <explorer@flame.org> and Thor Lancelot Simon.
  * This code uses ideas and algorithms from the Linux driver written by
  * Ted Ts'o.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -22,27 +22,27 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_rndq.c,v 1.43 2015/04/08 14:13:55 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_rndq.c,v 1.44 2015/04/13 14:41:06 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/select.h>
 #include <sys/poll.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/conf.h>
 #include <sys/systm.h>
 @@ -1138,27 +1138,27 @@ skip:		SIMPLEQ_INSERT_TAIL(&df_samples,
 static void
 rnd_intr(void *arg)
+{
 	rnd_process_events();
+}
 static void
 rnd_wake(void *arg)
+{
 	rnd_wakeup_readers();
+}
-u_int32_t
+static uint32_t
 rnd_extract_data(void *p, u_int32_t len, u_int32_t flags)
+{
 	static int timed_in;
 	int entropy_count;
 	uint32_t retval;
 	mutex_spin_enter(&rndpool_mtx);
 	if (__predict_false(!timed_in)) {
 		if (boottime.tv_sec) {
 			rndpool_add_data(&rnd_pool, &boottime,
 					 sizeof(boottime), 0);
+		}
 		timed_in++;
 @@ -1216,26 +1216,87 @@ rnd_extract_data(void *p, u_int32_t len,
 #endif
 	entropy_count = rndpool_get_entropy_count(&rnd_pool);
 	if (entropy_count < (RND_ENTROPY_THRESHOLD * 2 + len) * NBBY) {
 		rnd_printf_verbose("rnd: empty, asking for %d bytes\n",
 		    (int)(howmany((RND_POOLBITS - entropy_count), NBBY)));
 		rnd_getmore(howmany((RND_POOLBITS - entropy_count), NBBY));
+	}
 	retval = rndpool_extract_data(&rnd_pool, p, len, flags);
 	mutex_spin_exit(&rndpool_mtx);
 	return retval;
+}
 /*
  * Fill the buffer with as much entropy as we can.  Return true if it
  * has full entropy and false if not.
  */
 bool
 rnd_extract(void *buffer, size_t bytes)
+{
 	const size_t extracted = rnd_extract_data(buffer, bytes,
 	    RND_EXTRACT_GOOD);
 	if (extracted < bytes) {
 		(void)rnd_extract_data((uint8_t *)buffer + extracted,
 		    bytes - extracted, RND_EXTRACT_ANY);
 		mutex_spin_enter(&rndpool_mtx);
 		rnd_getmore(bytes - extracted);
 		mutex_spin_exit(&rndpool_mtx);
 		return false;
+	}
 	return true;
+}
 /*
  * If we have as much entropy as is requested, fill the buffer with it
  * and return true.  Otherwise, leave the buffer alone and return
  * false.
  */
 CTASSERT(RND_ENTROPY_THRESHOLD <= 0xffffffffUL);
 CTASSERT(RNDSINK_MAX_BYTES <= (0xffffffffUL - RND_ENTROPY_THRESHOLD));
 CTASSERT((RNDSINK_MAX_BYTES + RND_ENTROPY_THRESHOLD) <=
 	    (0xffffffffUL / NBBY));
 bool
 rnd_tryextract(void *buffer, size_t bytes)
+{
 	bool ok;
 	KASSERT(bytes <= RNDSINK_MAX_BYTES);
 	const uint32_t bits_needed = ((bytes + RND_ENTROPY_THRESHOLD) * NBBY);
 	mutex_spin_enter(&rndpool_mtx);
 	if (bits_needed <= rndpool_get_entropy_count(&rnd_pool)) {
 		const uint32_t extracted __diagused =
 		    rndpool_extract_data(&rnd_pool, buffer, bytes,
 			RND_EXTRACT_GOOD);
 		KASSERT(extracted == bytes);
 		ok = true;
 	} else {
 		ok = false;
 		rnd_getmore(howmany(bits_needed -
 			rndpool_get_entropy_count(&rnd_pool), NBBY));
+	}
 	mutex_spin_exit(&rndpool_mtx);
 	return ok;
+}
 void
 rnd_seed(void *base, size_t len)
+{
 	SHA1_CTX s;
 	uint8_t digest[SHA1_DIGEST_LENGTH];
 	if (len != sizeof(*boot_rsp)) {
 		rnd_printf("rnd: bad seed length %d\n", (int)len);
 		return;
+	}
 	boot_rsp = (rndsave_t *)base;
 	SHA1Init(&s);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_rndsink.c,v 1.10 2014/10/26 18:22:32 tls Exp $	*/
+/*	$NetBSD: kern_rndsink.c,v 1.11 2015/04/13 14:41:06 riastradh Exp $	*/
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Taylor R. Campbell.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -20,27 +20,27 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_rndsink.c,v 1.10 2014/10/26 18:22:32 tls Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_rndsink.c,v 1.11 2015/04/13 14:41:06 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/condvar.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 #include <sys/queue.h>
 #include <sys/rnd.h>
 #include <sys/rndsink.h>
 #include <dev/rnd_private.h>	/* XXX provisional, for rnd_extract_data */
 enum rsink_state {
 @@ -76,108 +76,40 @@ static TAILQ_HEAD(, rndsink)	rndsinks =
 void
 rndsinks_init(void)
+{
 	/*
 	 * This mutex must be at an ipl as high as the highest ipl of
 	 * anyone who wants to call rndsink_request.
+	 *
 	 * XXX Call this IPL_RND, perhaps.
 	 */
 	mutex_init(&rndsinks_lock, MUTEX_DEFAULT, IPL_VM);
+}
 /*
  * XXX Provisional -- rndpool_extract and rndpool_maybe_extract should
  * move into kern_rndpool.c.
  */
 extern rndpool_t rnd_pool;
 extern kmutex_t rndpool_mtx;
 /*
  * Fill the buffer with as much entropy as we can.  Return true if it
  * has full entropy and false if not.
  */
 static bool
 rndpool_extract(void *buffer, size_t bytes)
 	const size_t extracted = rnd_extract_data(buffer, bytes,
 	    RND_EXTRACT_GOOD);
 	if (extracted < bytes) {
 		(void)rnd_extract_data((uint8_t *)buffer + extracted,
 		    bytes - extracted, RND_EXTRACT_ANY);
 		mutex_spin_enter(&rndpool_mtx);
 		rnd_getmore(bytes - extracted);
 		mutex_spin_exit(&rndpool_mtx);
 		return false;
 	return true;
 /*
  * If we have as much entropy as is requested, fill the buffer with it
  * and return true.  Otherwise, leave the buffer alone and return
  * false.
  */
 CTASSERT(RND_ENTROPY_THRESHOLD <= 0xffffffffUL);
 CTASSERT(RNDSINK_MAX_BYTES <= (0xffffffffUL - RND_ENTROPY_THRESHOLD));
 CTASSERT((RNDSINK_MAX_BYTES + RND_ENTROPY_THRESHOLD) <=
 	    (0xffffffffUL / NBBY));
 static bool
 rndpool_maybe_extract(void *buffer, size_t bytes)
 	bool ok;
 	KASSERT(bytes <= RNDSINK_MAX_BYTES);
 	const uint32_t bits_needed = ((bytes + RND_ENTROPY_THRESHOLD) * NBBY);
 	mutex_spin_enter(&rndpool_mtx);
 	if (bits_needed <= rndpool_get_entropy_count(&rnd_pool)) {
 		const uint32_t extracted __diagused =
 		    rndpool_extract_data(&rnd_pool, buffer, bytes,
 			RND_EXTRACT_GOOD);
 		KASSERT(extracted == bytes);
 		ok = true;
 	} else {
 		ok = false;
 		rnd_getmore(howmany(bits_needed -
 			rndpool_get_entropy_count(&rnd_pool), NBBY));
 	mutex_spin_exit(&rndpool_mtx);
 	return ok;
 void
 rndsinks_distribute(void)
+{
 	uint8_t buffer[RNDSINK_MAX_BYTES];
 	struct rndsink *rndsink;
 	explicit_memset(buffer, 0, sizeof(buffer)); /* paranoia */
 	mutex_spin_enter(&rndsinks_lock);
 	while ((rndsink = TAILQ_FIRST(&rndsinks)) != NULL) {
 		KASSERT(rndsink->rsink_state == RNDSINK_QUEUED);
 		/* Bail if we can't get some entropy for this rndsink.  */
-		if (!rndpool_maybe_extract(buffer, rndsink->rsink_bytes))
+		if (!rnd_tryextract(buffer, rndsink->rsink_bytes))
 			break;
 		/*
 		 * Got some entropy.  Take the sink off the queue and
 		 * feed the entropy to the callback, with rndsinks_lock
 		 * dropped.  While running the callback, lock out
 		 * rndsink_destroy by marking the sink in flight.
 		 */
 		TAILQ_REMOVE(&rndsinks, rndsink, rsink_entry);
 		rndsink->rsink_state = RNDSINK_IN_FLIGHT;
 		mutex_spin_exit(&rndsinks_lock);
 		(*rndsink->rsink_callback)(rndsink->rsink_arg, buffer,
 @@ -215,29 +147,32 @@ rndsinks_enqueue(struct rndsink *rndsink
 	/*
 	 * XXX This should request only rndsink->rs_bytes bytes of
 	 * entropy, but that might get buffered up indefinitely because
 	 * kern_rndq has no bound on the duration before it will
 	 * process queued entropy samples.  To work around this, we are
 	 * a little too incestuous with kern_rndq: we avoid marking polled
 	 * sources "fast" there, and know here that for non-fast sources,
 	 * that code will buffer two ints worth of data per source.
 	 * Later, we ought to (a) bound the duration before
 	 * queued entropy samples get processed, and (b) add a target
 	 * or something -- as soon as we get that much from the entropy
 	 * sources, distribute it.
 	 */
+    {
 	extern kmutex_t rndpool_mtx;
 	mutex_spin_enter(&rndpool_mtx);
 	rnd_getmore(MAX(rndsink->rsink_bytes, 2 * sizeof(uint32_t)));
 	mutex_spin_exit(&rndpool_mtx);
+    }
 	switch (rndsink->rsink_state) {
 	case RNDSINK_IDLE:
 		/* Not on the queue and nobody is handling it.  */
 		TAILQ_INSERT_TAIL(&rndsinks, rndsink, rsink_entry);
 		rndsink->rsink_state = RNDSINK_QUEUED;
 		break;
 	case RNDSINK_QUEUED:
 		/* Already on the queue.  */
 		break;
 	case RNDSINK_IN_FLIGHT:
 @@ -321,20 +256,20 @@ rndsink_schedule(struct rndsink *rndsink
 		mutex_spin_enter(&rndsinks_lock);
 		rndsinks_enqueue(rndsink);
 		mutex_spin_exit(&rndsinks_lock);
+	}
+}
 bool
 rndsink_request(struct rndsink *rndsink, void *buffer, size_t bytes)
+{
 	KASSERT(bytes == rndsink->rsink_bytes);
 	mutex_spin_enter(&rndsinks_lock);
-	const bool full_entropy = rndpool_extract(buffer, bytes);
+	const bool full_entropy = rnd_extract(buffer, bytes);
 	if (!full_entropy)
 		rndsinks_enqueue(rndsink);
 	mutex_spin_exit(&rndsinks_lock);
 	return full_entropy;
+}

 @@ -1,14 +1,14 @@
-/*      $NetBSD: rnd_private.h,v 1.5 2015/04/13 14:30:05 riastradh Exp $     */
+/*      $NetBSD: rnd_private.h,v 1.6 2015/04/13 14:41:06 riastradh Exp $     */
 /*-
  * Copyright (c) 1997 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Michael Graff <explorer@flame.org>.  This code uses ideas and
  * algorithms from the Linux driver written by Ted Ts'o.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -37,15 +37,16 @@
  * rnd.c and rndpool.c to decide when enough entropy exists to do a
  * hash to extract it.
  */
 #define RND_ENTROPY_THRESHOLD   10
 /*
  * Used by rnd_extract_data() and rndpool_extract_data() to describe how
  * "good" the data has to be.
  */
 #define RND_EXTRACT_ANY		0  /* extract anything, even if no entropy */
 #define RND_EXTRACT_GOOD	1  /* return as many good bytes
 				      (short read ok) */
-uint32_t        rnd_extract_data(void *, uint32_t, uint32_t);
+bool	rnd_extract(void *, size_t);
 bool	rnd_tryextract(void *, size_t);
 #endif