diff options
Diffstat (limited to 'sys')
| -rw-r--r-- | sys/dev/random.c | 151 | ||||
| -rw-r--r-- | sys/kern/files.kern | 3 | ||||
| -rw-r--r-- | sys/kern/kern_entropy.c | 30 | ||||
| -rw-r--r-- | sys/kern/sys_getrandom.c | 246 | ||||
| -rw-r--r-- | sys/kern/syscalls.master | 5 | ||||
| -rw-r--r-- | sys/rump/librump/rumpkern/Makefile.rumpkern | 3 | ||||
| -rw-r--r-- | sys/sys/Makefile | 4 | ||||
| -rw-r--r-- | sys/sys/entropy.h | 8 | ||||
| -rw-r--r-- | sys/sys/random.h | 69 |
9 files changed, 373 insertions, 146 deletions
diff --git a/sys/dev/random.c b/sys/dev/random.c index b5764026815..da6352c80f5 100644 --- a/sys/dev/random.c +++ b/sys/dev/random.c @@ -1,4 +1,4 @@ -/* $NetBSD: random.c,v 1.7 2020/05/08 16:05:36 riastradh Exp $ */ +/* $NetBSD: random.c,v 1.8 2020/08/14 00:53:16 riastradh Exp $ */ /*- * Copyright (c) 2019 The NetBSD Foundation, Inc. @@ -47,7 +47,7 @@ */ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: random.c,v 1.7 2020/05/08 16:05:36 riastradh Exp $"); +__KERNEL_RCSID(0, "$NetBSD: random.c,v 1.8 2020/08/14 00:53:16 riastradh Exp $"); #include <sys/param.h> #include <sys/types.h> @@ -62,13 +62,12 @@ __KERNEL_RCSID(0, "$NetBSD: random.c,v 1.7 2020/05/08 16:05:36 riastradh Exp $") #include <sys/kmem.h> #include <sys/lwp.h> #include <sys/poll.h> +#include <sys/random.h> #include <sys/rnd.h> #include <sys/rndsource.h> #include <sys/signalvar.h> #include <sys/systm.h> -#include <crypto/nist_hash_drbg/nist_hash_drbg.h> - #include "ioconf.h" static dev_type_open(random_open); @@ -209,138 +208,26 @@ random_kqfilter(dev_t dev, struct knote *kn) static int random_read(dev_t dev, struct uio *uio, int flags) { - uint8_t seed[NIST_HASH_DRBG_SEEDLEN_BYTES] = {0}; - struct nist_hash_drbg drbg; - uint8_t *buf; - int extractflags; - int error; - - /* Get a buffer for transfers. */ - buf = kmem_alloc(RANDOM_BUFSIZE, KM_SLEEP); - - /* - * If it's a short read from /dev/urandom, just generate the - * output directly with per-CPU cprng_strong. - */ - if (minor(dev) == RND_DEV_URANDOM && - uio->uio_resid <= RANDOM_BUFSIZE) { - /* Generate data and transfer it out. */ - cprng_strong(user_cprng, buf, uio->uio_resid, 0); - error = uiomove(buf, uio->uio_resid, uio); - goto out; - } - - /* - * If we're doing a blocking read from /dev/random, wait - * interruptibly. Otherwise, don't wait. - */ - if (minor(dev) == RND_DEV_RANDOM && !ISSET(flags, FNONBLOCK)) - extractflags = ENTROPY_WAIT|ENTROPY_SIG; - else - extractflags = 0; - - /* - * Query the entropy pool. For /dev/random, stop here if this - * fails. For /dev/urandom, go on either way -- - * entropy_extract will always fill the buffer with what we - * have from the global pool. - */ - error = entropy_extract(seed, sizeof seed, extractflags); - if (minor(dev) == RND_DEV_RANDOM && error) - goto out; - - /* Instantiate the DRBG. */ - if (nist_hash_drbg_instantiate(&drbg, seed, sizeof seed, NULL, 0, - NULL, 0)) - panic("nist_hash_drbg_instantiate"); - - /* Promptly zero the seed. */ - explicit_memset(seed, 0, sizeof seed); - - /* Generate data. */ - error = 0; - while (uio->uio_resid) { - size_t n = MIN(uio->uio_resid, RANDOM_BUFSIZE); - - /* - * Clamp /dev/random output to the entropy capacity and - * seed size. Programs can't rely on long reads. - */ - if (minor(dev) == RND_DEV_RANDOM) { - n = MIN(n, ENTROPY_CAPACITY); - n = MIN(n, sizeof seed); - /* - * Guarantee never to return more than one - * buffer in this case to minimize bookkeeping. - */ - CTASSERT(ENTROPY_CAPACITY <= RANDOM_BUFSIZE); - CTASSERT(sizeof seed <= RANDOM_BUFSIZE); - } - - /* - * Try to generate a block of data, but if we've hit - * the DRBG reseed interval, reseed. - */ - if (nist_hash_drbg_generate(&drbg, buf, n, NULL, 0)) { - /* - * Get a fresh seed without blocking -- we have - * already generated some output so it is not - * useful to block. This can fail only if the - * request is obscenely large, so it is OK for - * either /dev/random or /dev/urandom to fail: - * we make no promises about gigabyte-sized - * reads happening all at once. - */ - error = entropy_extract(seed, sizeof seed, 0); - if (error) - break; - - /* Reseed and try again. */ - if (nist_hash_drbg_reseed(&drbg, seed, sizeof seed, - NULL, 0)) - panic("nist_hash_drbg_reseed"); - - /* Promptly zero the seed. */ - explicit_memset(seed, 0, sizeof seed); - - /* If it fails now, that's a bug. */ - if (nist_hash_drbg_generate(&drbg, buf, n, NULL, 0)) - panic("nist_hash_drbg_generate"); - } - - /* Transfer n bytes out. */ - error = uiomove(buf, n, uio); - if (error) - break; + int gflags; - /* - * If this is /dev/random, stop here, return what we - * have, and force the next read to reseed. Programs - * can't rely on /dev/random for long reads. - */ - if (minor(dev) == RND_DEV_RANDOM) { - error = 0; - break; - } - - /* Yield if requested. */ - if (curcpu()->ci_schedstate.spc_flags & SPCF_SHOULDYIELD) - preempt(); - - /* Check for interruption after at least 256 bytes. */ - CTASSERT(RANDOM_BUFSIZE >= 256); - if (__predict_false(curlwp->l_flag & LW_PENDSIG) && - sigispending(curlwp, 0)) { - error = EINTR; - break; - } + /* Set the appropriate GRND_* mode. */ + switch (minor(dev)) { + case RND_DEV_RANDOM: + gflags = GRND_RANDOM; + break; + case RND_DEV_URANDOM: + gflags = GRND_INSECURE; + break; + default: + return ENXIO; } -out: /* Zero the buffer and free it. */ - explicit_memset(buf, 0, RANDOM_BUFSIZE); - kmem_free(buf, RANDOM_BUFSIZE); + /* Set GRND_NONBLOCK if the user requested FNONBLOCK. */ + if (flags & FNONBLOCK) + gflags |= GRND_NONBLOCK; - return error; + /* Defer to getrandom. */ + return dogetrandom(uio, gflags); } /* diff --git a/sys/kern/files.kern b/sys/kern/files.kern index 9d3acfd4229..d40d9d6b0df 100644 --- a/sys/kern/files.kern +++ b/sys/kern/files.kern @@ -1,4 +1,4 @@ -# $NetBSD: files.kern,v 1.50 2020/07/28 20:15:07 riastradh Exp $ +# $NetBSD: files.kern,v 1.51 2020/08/14 00:53:16 riastradh Exp $ # # kernel sources @@ -157,6 +157,7 @@ file kern/sys_aio.c aio file kern/sys_descrip.c kern file kern/sys_futex.c kern file kern/sys_generic.c kern +file kern/sys_getrandom.c kern file kern/sys_module.c kern file kern/sys_mqueue.c mqueue file kern/sys_lwp.c kern diff --git a/sys/kern/kern_entropy.c b/sys/kern/kern_entropy.c index f9519810312..1bb1350c68e 100644 --- a/sys/kern/kern_entropy.c +++ b/sys/kern/kern_entropy.c @@ -1,4 +1,4 @@ -/* $NetBSD: kern_entropy.c,v 1.22 2020/05/12 20:50:17 riastradh Exp $ */ +/* $NetBSD: kern_entropy.c,v 1.23 2020/08/14 00:53:16 riastradh Exp $ */ /*- * Copyright (c) 2019 The NetBSD Foundation, Inc. @@ -75,7 +75,7 @@ */ #include <sys/cdefs.h> -__KERNEL_RCSID(0, "$NetBSD: kern_entropy.c,v 1.22 2020/05/12 20:50:17 riastradh Exp $"); +__KERNEL_RCSID(0, "$NetBSD: kern_entropy.c,v 1.23 2020/08/14 00:53:16 riastradh Exp $"); #include <sys/param.h> #include <sys/types.h> @@ -612,6 +612,18 @@ entropy_epoch(void) } /* + * entropy_ready() + * + * True if the entropy pool has full entropy. + */ +bool +entropy_ready(void) +{ + + return atomic_load_relaxed(&E->needed) == 0; +} + +/* * entropy_account_cpu(ec) * * Consider whether to consolidate entropy into the global pool @@ -1231,6 +1243,8 @@ sysctl_entropy_gather(SYSCTLFN_ARGS) * * ENTROPY_WAIT Wait for entropy if not available yet. * ENTROPY_SIG Allow interruption by a signal during wait. + * ENTROPY_HARDFAIL Either fill the buffer with full entropy, + * or fail without filling it at all. * * Return zero on success, or error on failure: * @@ -1292,9 +1306,15 @@ entropy_extract(void *buf, size_t len, int flags) } } - /* Count failure -- but fill the buffer nevertheless. */ - if (error) + /* + * Count failure -- but fill the buffer nevertheless, unless + * the caller specified ENTROPY_HARDFAIL. + */ + if (error) { + if (ISSET(flags, ENTROPY_HARDFAIL)) + goto out; entropy_extract_fail_evcnt.ev_count++; + } /* * Report a warning if we have never yet reached full entropy. @@ -1324,7 +1344,7 @@ entropy_extract(void *buf, size_t len, int flags) entropy_deplete_evcnt.ev_count++; } - /* Release the global lock and return the error. */ +out: /* Release the global lock and return the error. */ if (E->stage >= ENTROPY_WARM) mutex_exit(&E->lock); return error; diff --git a/sys/kern/sys_getrandom.c b/sys/kern/sys_getrandom.c new file mode 100644 index 00000000000..947b5d79717 --- /dev/null +++ b/sys/kern/sys_getrandom.c @@ -0,0 +1,246 @@ +/* $NetBSD: sys_getrandom.c,v 1.1 2020/08/14 00:53:16 riastradh Exp $ */ + +/*- + * Copyright (c) 2020 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. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``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. + */ + +/* + * getrandom() system call + */ + +#include <sys/cdefs.h> +__KERNEL_RCSID(0, "$NetBSD: sys_getrandom.c,v 1.1 2020/08/14 00:53:16 riastradh Exp $"); + +#include <sys/types.h> +#include <sys/param.h> + +#include <sys/atomic.h> +#include <sys/cprng.h> +#include <sys/entropy.h> +#include <sys/kmem.h> +#include <sys/lwp.h> +#include <sys/proc.h> +#include <sys/random.h> +#include <sys/sched.h> +#include <sys/signalvar.h> +#include <sys/syscallargs.h> +#include <sys/uio.h> + +#include <crypto/nist_hash_drbg/nist_hash_drbg.h> + +#define RANDOM_BUFSIZE 512 + +int +dogetrandom(struct uio *uio, unsigned int flags) +{ + uint8_t seed[NIST_HASH_DRBG_SEEDLEN_BYTES] = {0}; + struct nist_hash_drbg drbg; + uint8_t *buf; + int extractflags = 0; + int error; + + KASSERT((flags & ~(GRND_RANDOM|GRND_INSECURE|GRND_NONBLOCK)) == 0); + KASSERT((flags & (GRND_RANDOM|GRND_INSECURE)) != + (GRND_RANDOM|GRND_INSECURE)); + + /* Get a buffer for transfers. */ + buf = kmem_alloc(RANDOM_BUFSIZE, KM_SLEEP); + + /* + * Fast path: for short reads other than from /dev/random, if + * seeded or if INSECURE, just draw from per-CPU cprng_strong. + */ + if (uio->uio_resid <= RANDOM_BUFSIZE && + !ISSET(flags, GRND_RANDOM) && + (entropy_ready() || ISSET(flags, GRND_INSECURE))) { + /* Generate data and transfer it out. */ + cprng_strong(user_cprng, buf, uio->uio_resid, 0); + error = uiomove(buf, uio->uio_resid, uio); + goto out; + } + + /* + * Try to get a seed from the entropy pool. Fail if we would + * block. If GRND_INSECURE, always return something even if it + * is partial entropy; if !GRND_INSECURE, set ENTROPY_HARDFAIL + * in order to tell entropy_extract not to bother drawing + * anything from a partial pool if we can't get full entropy. + */ + if (!ISSET(flags, GRND_NONBLOCK) && !ISSET(flags, GRND_INSECURE)) + extractflags |= ENTROPY_WAIT|ENTROPY_SIG; + if (!ISSET(flags, GRND_INSECURE)) + extractflags |= ENTROPY_HARDFAIL; + error = entropy_extract(seed, sizeof seed, extractflags); + if (error && !ISSET(flags, GRND_INSECURE)) + goto out; + + /* Instantiate the DRBG. */ + if (nist_hash_drbg_instantiate(&drbg, seed, sizeof seed, NULL, 0, + NULL, 0)) + panic("nist_hash_drbg_instantiate"); + + /* Promptly zero the seed. */ + explicit_memset(seed, 0, sizeof seed); + + /* Generate data. */ + error = 0; + while (uio->uio_resid) { + size_t n = MIN(uio->uio_resid, RANDOM_BUFSIZE); + + /* + * Clamp /dev/random output to the entropy capacity and + * seed size. Programs can't rely on long reads. + */ + if (ISSET(flags, GRND_RANDOM)) { + n = MIN(n, ENTROPY_CAPACITY); + n = MIN(n, sizeof seed); + /* + * Guarantee never to return more than one + * buffer in this case to minimize bookkeeping. + */ + CTASSERT(ENTROPY_CAPACITY <= RANDOM_BUFSIZE); + CTASSERT(sizeof seed <= RANDOM_BUFSIZE); + } + + /* + * Try to generate a block of data, but if we've hit + * the DRBG reseed interval, reseed. + */ + if (nist_hash_drbg_generate(&drbg, buf, n, NULL, 0)) { + /* + * Get a fresh seed without blocking -- we have + * already generated some output so it is not + * useful to block. This can fail only if the + * request is obscenely large, so it is OK for + * either /dev/random or /dev/urandom to fail: + * we make no promises about gigabyte-sized + * reads happening all at once. + */ + error = entropy_extract(seed, sizeof seed, + ENTROPY_HARDFAIL); + if (error) + break; + + /* Reseed and try again. */ + if (nist_hash_drbg_reseed(&drbg, seed, sizeof seed, + NULL, 0)) + panic("nist_hash_drbg_reseed"); + + /* Promptly zero the seed. */ + explicit_memset(seed, 0, sizeof seed); + + /* If it fails now, that's a bug. */ + if (nist_hash_drbg_generate(&drbg, buf, n, NULL, 0)) + panic("nist_hash_drbg_generate"); + } + + /* Transfer n bytes out. */ + error = uiomove(buf, n, uio); + if (error) + break; + + /* + * If this is /dev/random, stop here, return what we + * have, and force the next read to reseed. Programs + * can't rely on /dev/random for long reads. + */ + if (ISSET(flags, GRND_RANDOM)) { + error = 0; + break; + } + + /* Yield if requested. */ + if (curcpu()->ci_schedstate.spc_flags & SPCF_SHOULDYIELD) + preempt(); + + /* Check for interruption after at least 256 bytes. */ + CTASSERT(RANDOM_BUFSIZE >= 256); + if (__predict_false(curlwp->l_flag & LW_PENDSIG) && + sigispending(curlwp, 0)) { + error = EINTR; + break; + } + } + +out: /* Zero the buffer and free it. */ + explicit_memset(buf, 0, RANDOM_BUFSIZE); + kmem_free(buf, RANDOM_BUFSIZE); + + return error; +} + +int +sys_getrandom(struct lwp *l, const struct sys_getrandom_args *uap, + register_t *retval) +{ + /* { + syscallarg(void *) buf; + syscallarg(size_t) buflen; + syscallarg(unsigned) flags; + } */ + void *buf = SCARG(uap, buf); + size_t buflen = SCARG(uap, buflen); + int flags = SCARG(uap, flags); + int error; + + /* Set up an iov and uio to read into the user's buffer. */ + struct iovec iov = { .iov_base = buf, .iov_len = buflen }; + struct uio uio = { + .uio_iov = &iov, + .uio_iovcnt = 1, + .uio_offset = 0, + .uio_resid = buflen, + .uio_rw = UIO_READ, + .uio_vmspace = curproc->p_vmspace, + }; + + /* Validate the flags. */ + if (flags & ~(GRND_RANDOM|GRND_INSECURE|GRND_NONBLOCK)) { + /* Unknown flags. */ + error = EINVAL; + goto out; + } + if ((flags & (GRND_RANDOM|GRND_INSECURE)) == + (GRND_RANDOM|GRND_INSECURE)) { + /* Nonsensical combination. */ + error = EINVAL; + goto out; + } + + /* Do it. */ + error = dogetrandom(&uio, flags); + +out: /* + * If we transferred anything, return the number of bytes + * transferred and suppress error; otherwise return the error. + */ + *retval = buflen - uio.uio_resid; + if (*retval) + error = 0; + return error; +} diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master index a53b8a25b4b..f814c189ee6 100644 --- a/sys/kern/syscalls.master +++ b/sys/kern/syscalls.master @@ -1,4 +1,4 @@ - $NetBSD: syscalls.master,v 1.305 2020/05/16 18:31:50 christos Exp $ + $NetBSD: syscalls.master,v 1.306 2020/08/14 00:53:16 riastradh Exp $ ; @(#)syscalls.master 8.2 (Berkeley) 1/13/94 @@ -216,7 +216,8 @@ 89 COMPAT_43 MODULAR compat_43 \ { int|sys||getdtablesize(void); } ogetdtablesize 90 STD RUMP { int|sys||dup2(int from, int to); } -91 UNIMPL getdopt +91 STD RUMP { ssize_t|sys||getrandom(void *buf, size_t buflen, \ + unsigned int flags); } 92 STD RUMP { int|sys||fcntl(int fd, int cmd, ... void *arg); } 93 COMPAT_50 MODULAR compat_50 RUMP \ { int|sys||select(int nd, fd_set *in, fd_set *ou, \ diff --git a/sys/rump/librump/rumpkern/Makefile.rumpkern b/sys/rump/librump/rumpkern/Makefile.rumpkern index 46ce2c483a2..c96d77e697f 100644 --- a/sys/rump/librump/rumpkern/Makefile.rumpkern +++ b/sys/rump/librump/rumpkern/Makefile.rumpkern @@ -1,4 +1,4 @@ -# $NetBSD: Makefile.rumpkern,v 1.184 2020/07/28 20:15:07 riastradh Exp $ +# $NetBSD: Makefile.rumpkern,v 1.185 2020/08/14 00:53:16 riastradh Exp $ # IOCONFDIR:= ${.PARSEDIR} @@ -130,6 +130,7 @@ SRCS+= init_sysctl_base.c \ subr_xcall.c \ sys_descrip.c \ sys_generic.c \ + sys_getrandom.c \ sys_module.c \ sys_pipe.c \ sys_select.c \ diff --git a/sys/sys/Makefile b/sys/sys/Makefile index 6b7bd019374..291962f6936 100644 --- a/sys/sys/Makefile +++ b/sys/sys/Makefile @@ -1,4 +1,4 @@ -# $NetBSD: Makefile,v 1.175 2020/06/08 16:36:18 maxv Exp $ +# $NetBSD: Makefile,v 1.176 2020/08/14 00:53:16 riastradh Exp $ .include <bsd.own.mk> @@ -34,7 +34,7 @@ INCS= acct.h acl.h agpio.h aio.h ansi.h aout_mids.h ataio.h atomic.h \ param.h pcu.h pipe.h pmf.h poll.h pool.h power.h proc.h \ protosw.h pset.h psref.h ptrace.h ptree.h \ queue.h quota.h quotactl.h \ - radixtree.h ras.h rbtree.h reboot.h radioio.h resource.h \ + radioio.h radixtree.h random.h ras.h rbtree.h reboot.h resource.h \ resourcevar.h rmd160.h rnd.h rndio.h rwlock.h \ scanio.h sched.h scsiio.h sdt.h select.h selinfo.h sem.h semaphore.h \ sha1.h sha2.h sha3.h shm.h siginfo.h signal.h signalvar.h sigtypes.h \ diff --git a/sys/sys/entropy.h b/sys/sys/entropy.h index 7bf6a82bdc0..da6ef63abd6 100644 --- a/sys/sys/entropy.h +++ b/sys/sys/entropy.h @@ -1,4 +1,4 @@ -/* $NetBSD: entropy.h,v 1.3 2020/05/08 15:54:11 riastradh Exp $ */ +/* $NetBSD: entropy.h,v 1.4 2020/08/14 00:53:16 riastradh Exp $ */ /*- * Copyright (c) 2019 The NetBSD Foundation, Inc. @@ -44,12 +44,14 @@ struct knote; #define ENTROPY_CAPACITY ENTPOOL_CAPACITY /* bytes */ -#define ENTROPY_WAIT 0x01 -#define ENTROPY_SIG 0x02 +#define ENTROPY_WAIT 0x01 +#define ENTROPY_SIG 0x02 +#define ENTROPY_HARDFAIL 0x04 void entropy_bootrequest(void); void entropy_consolidate(void); unsigned entropy_epoch(void); +bool entropy_ready(void); int entropy_extract(void *, size_t, int); int entropy_poll(int); int entropy_kqfilter(struct knote *); diff --git a/sys/sys/random.h b/sys/sys/random.h new file mode 100644 index 00000000000..bb528d43289 --- /dev/null +++ b/sys/sys/random.h @@ -0,0 +1,69 @@ +/* $NetBSD: random.h,v 1.1 2020/08/14 00:53:16 riastradh Exp $ */ + +/*- + * Copyright (c) 2020 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. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``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. + */ + +#ifndef _SYS_RANDOM_H +#define _SYS_RANDOM_H + +#include <sys/cdefs.h> + +#include <machine/ansi.h> /* _BSD_SIZE_T_ */ + +#define GRND_NONBLOCK (1u << 0) +#define GRND_RANDOM (1u << 1) +#define GRND_INSECURE (1u << 2) + +#ifdef _KERNEL + +struct uio; + +int dogetrandom(struct uio *, unsigned int); + +#endif /* _KERNEL */ + +#ifndef _KERNEL +__BEGIN_DECLS + +#ifdef _BSD_SIZE_T_ +typedef _BSD_SIZE_T_ size_t; +#undef _BSD_SIZE_T_ +#endif + +#ifdef _BSD_SSIZE_T_ +typedef _BSD_SSIZE_T_ ssize_t; +#undef _BSD_SSIZE_T_ +#endif + +ssize_t getrandom(void *, size_t, unsigned int); + +__END_DECLS +#endif /* !_KERNEL */ + +#endif /* _SYS_RANDOM_H */ |
