diff --git a/Makefile b/Makefile index 814ac1ce..f6c9d384 100644 --- a/Makefile +++ b/Makefile @@ -310,6 +310,8 @@ C_FILES = \ freebsd/cam/cam.c \ freebsd/cam/scsi/scsi_all.c \ freebsd/dev/usb/storage/umass.c \ + freebsd/dev/random/harvest.c \ + freebsd/libkern/random.c \ freebsd/dev/re/if_re.c \ freebsd/dev/fxp/if_fxp.c \ freebsd/dev/e1000/e1000_80003es2lan.c \ diff --git a/freebsd-to-rtems.py b/freebsd-to-rtems.py index cf3d8eb6..749c6eaf 100755 --- a/freebsd-to-rtems.py +++ b/freebsd-to-rtems.py @@ -1109,11 +1109,14 @@ devNic = Module('dev_nic') devNic.addHeaderFiles( [ # 'sys/taskqueue.h', + 'dev/random/randomdev_soft.h', ] ) devNic.addSourceFiles( [ # 'kern/subr_taskqueue.c', + 'dev/random/harvest.c', + 'libkern/random.c', ] ) diff --git a/freebsd/dev/random/harvest.c b/freebsd/dev/random/harvest.c new file mode 100644 index 00000000..68c60676 --- /dev/null +++ b/freebsd/dev/random/harvest.c @@ -0,0 +1,137 @@ +#include + +/*- + * Copyright (c) 2000-2004 Mark R V Murray + * All rights reserved. + * + * 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 + * in this position and unchanged. + * 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 AUTHOR ``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 AUTHOR 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 +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +static int read_random_phony(void *, int); + +/* Structure holding the desired entropy sources */ +struct harvest_select harvest = { 1, 1, 1, 0 }; + +/* hold the address of the routine which is actually called if + * the randomdev is loaded + */ +static void (*reap_func)(u_int64_t, const void *, u_int, u_int, u_int, + enum esource) = NULL; +static int (*read_func)(void *, int) = read_random_phony; + +/* Initialise the harvester at load time */ +void +random_yarrow_init_harvester(void (*reaper)(u_int64_t, const void *, u_int, + u_int, u_int, enum esource), int (*reader)(void *, int)) +{ + reap_func = reaper; + read_func = reader; +} + +/* Deinitialise the harvester at unload time */ +void +random_yarrow_deinit_harvester(void) +{ + reap_func = NULL; + read_func = read_random_phony; +} + +/* Entropy harvesting routine. This is supposed to be fast; do + * not do anything slow in here! + * Implemented as in indirect call to allow non-inclusion of + * the entropy device. + * + * XXXRW: get_cyclecount() is cheap on most modern hardware, where cycle + * counters are built in, but on older hardware it will do a real time clock + * read which can be quite expensive. + */ +void +random_harvest(void *entropy, u_int count, u_int bits, u_int frac, + enum esource origin) +{ + if (reap_func) + (*reap_func)(get_cyclecount(), entropy, count, bits, frac, + origin); +} + +/* Userland-visible version of read_random */ +int +read_random(void *buf, int count) +{ + return ((*read_func)(buf, count)); +} + +/* If the entropy device is not loaded, make a token effort to + * provide _some_ kind of randomness. This should only be used + * inside other RNG's, like arc4random(9). + */ +static int +read_random_phony(void *buf, int count) +{ + u_long randval; + int size, i; + + /* srandom() is called in kern/init_main.c:proc0_post() */ + + /* Fill buf[] with random(9) output */ + for (i = 0; i < count; i+= (int)sizeof(u_long)) { + randval = random(); + size = MIN(count - i, sizeof(u_long)); + memcpy(&((char *)buf)[i], &randval, (size_t)size); + } + + return (count); +} + +/* Helper routine to enable kproc_exit() to work while the module is + * being (or has been) unloaded. + * This routine is in this file because it is always linked into the kernel, + * and will thus never be unloaded. This is critical for unloadable modules + * that have threads. + */ +void +random_set_wakeup_exit(void *control) +{ + wakeup(control); + kproc_exit(0); + /* NOTREACHED */ +} diff --git a/freebsd/dev/random/randomdev_soft.h b/freebsd/dev/random/randomdev_soft.h new file mode 100644 index 00000000..489d45a3 --- /dev/null +++ b/freebsd/dev/random/randomdev_soft.h @@ -0,0 +1,94 @@ +/*- + * Copyright (c) 2000-2004 Mark R V Murray + * All rights reserved. + * + * 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 + * in this position and unchanged. + * 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 AUTHOR ``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 AUTHOR 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. + * + * $FreeBSD$ + */ + +/* This header contains only those definitions that are global + * and harvester-specific for the entropy processor + */ + +/* #define ENTROPYSOURCE nn entropy sources (actually classes) + * This is properly defined in + * an enum in sys/random.h + */ + +/* Cryptographic block size in bits */ +#define BLOCKSIZE 256 + +/* The ring size _MUST_ be a power of 2 */ +#define HARVEST_RING_SIZE 1024 /* harvest ring buffer size */ +#define HARVEST_RING_MASK (HARVEST_RING_SIZE - 1) + +#define HARVESTSIZE 16 /* max size of each harvested entropy unit */ + +MALLOC_DECLARE(M_ENTROPY); + +/* These are used to queue harvested packets of entropy. The entropy + * buffer size is pretty arbitrary. + */ +struct harvest { + uintmax_t somecounter; /* fast counter for clock jitter */ + u_char entropy[HARVESTSIZE]; /* the harvested entropy */ + u_int size, bits, frac; /* stats about the entropy */ + enum esource source; /* stats about the entropy */ + STAILQ_ENTRY(harvest) next; /* next item on the list */ +}; + +void random_yarrow_init(void); +void random_yarrow_deinit(void); + +int random_yarrow_read(void *, int); +void random_yarrow_write(void *, int); + +void random_yarrow_init_harvester(void (*)(u_int64_t, const void *, u_int, + u_int, u_int, enum esource), int (*)(void *, int)); +void random_yarrow_deinit_harvester(void); + +void random_set_wakeup_exit(void *); +void random_process_event(struct harvest *event); +void random_yarrow_reseed(void); +void random_yarrow_unblock(void); + +void random_yarrow_init_alg(struct sysctl_ctx_list *, struct sysctl_oid *); +void random_yarrow_deinit_alg(void); + +extern struct random_systat random_yarrow; +extern struct mtx random_reseed_mtx; + +/* If this was c++, this would be a template */ +#define RANDOM_CHECK_UINT(name, min, max) \ +static int \ +random_check_uint_##name(SYSCTL_HANDLER_ARGS) \ +{ \ + if (oidp->oid_arg1 != NULL) { \ + if (*(u_int *)(oidp->oid_arg1) <= (min)) \ + *(u_int *)(oidp->oid_arg1) = (min); \ + else if (*(u_int *)(oidp->oid_arg1) > (max)) \ + *(u_int *)(oidp->oid_arg1) = (max); \ + } \ + return sysctl_handle_int(oidp, oidp->oid_arg1, oidp->oid_arg2, \ + req); \ +} diff --git a/freebsd/libkern/random.c b/freebsd/libkern/random.c new file mode 100644 index 00000000..87cc9591 --- /dev/null +++ b/freebsd/libkern/random.c @@ -0,0 +1,80 @@ +#include + +/*- + * Copyright (c) 1992, 1993 + * The Regents of the University of California. All rights reserved. + * + * 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. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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. + * + * @(#)random.c 8.1 (Berkeley) 6/10/93 + */ + +#include +__FBSDID("$FreeBSD$"); + +#include + +#define NSHUFF 50 /* to drop some "seed -> 1st value" linearity */ + +static u_long randseed = 937186357; /* after srandom(1), NSHUFF counted */ + +void +srandom(seed) + u_long seed; +{ + int i; + + randseed = seed; + for (i = 0; i < NSHUFF; i++) + (void)random(); +} + +/* + * Pseudo-random number generator for randomizing the profiling clock, + * and whatever else we might use it for. The result is uniform on + * [0, 2^31 - 1]. + */ +u_long +random() +{ + register long x, hi, lo, t; + + /* + * Compute x[n + 1] = (7^5 * x[n]) mod (2^31 - 1). + * From "Random number generators: good ones are hard to find", + * Park and Miller, Communications of the ACM, vol. 31, no. 10, + * October 1988, p. 1195. + */ + /* Can't be initialized with 0, so use another value. */ + if ((x = randseed) == 0) + x = 123459876; + hi = x / 127773; + lo = x % 127773; + t = 16807 * lo - 2836 * hi; + if (t < 0) + t += 0x7fffffff; + randseed = t; + return (t); +}