2 * A system independant way of adding entropy to the kernels pool
3 * this way the drivers can focus on the real work and we can take
4 * care of pushing it to the appropriate place in the kernel.
6 * This should be fast and callable from timers/interrupts
8 * Written by David McCullough <david_mccullough@mcafee.com>
9 * Copyright (C) 2006-2010 David McCullough
10 * Copyright (C) 2004-2005 Intel Corporation.
14 * The free distribution and use of this software in both source and binary
15 * form is allowed (with or without changes) provided that:
17 * 1. distributions of this source code include the above copyright
18 * notice, this list of conditions and the following disclaimer;
20 * 2. distributions in binary form include the above copyright
21 * notice, this list of conditions and the following disclaimer
22 * in the documentation and/or other associated materials;
24 * 3. the copyright holder's name is not used to endorse products
25 * built using this software without specific written permission.
27 * ALTERNATIVELY, provided that this notice is retained in full, this product
28 * may be distributed under the terms of the GNU General Public License (GPL),
29 * in which case the provisions of the GPL apply INSTEAD OF those given above.
33 * This software is provided 'as is' with no explicit or implied warranties
34 * in respect of its properties, including, but not limited to, correctness
35 * and/or fitness for purpose.
38 #include <linux/version.h>
39 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
40 #include <generated/autoconf.h>
42 #include <linux/autoconf.h>
44 #include <linux/module.h>
45 #include <linux/init.h>
46 #include <linux/list.h>
47 #include <linux/slab.h>
48 #include <linux/wait.h>
49 #include <linux/sched.h>
50 #include <linux/spinlock.h>
51 #include <linux/version.h>
52 #include <linux/unistd.h>
53 #include <linux/poll.h>
54 #include <linux/random.h>
55 #include <cryptodev.h>
57 #ifdef CONFIG_OCF_FIPS
61 #ifndef HAS_RANDOM_INPUT_WAIT
62 #error "Please do not enable OCF_RANDOMHARVEST unless you have applied patches"
65 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
66 #include <linux/sched.h>
67 #define kill_proc(p,s,v) send_sig(s,find_task_by_vpid(p),0)
71 * a hack to access the debug levels from the crypto driver
73 extern int crypto_debug;
74 #define debug crypto_debug
77 * a list of all registered random providers
79 static LIST_HEAD(random_ops);
80 static int started = 0;
81 static int initted = 0;
84 struct list_head random_list;
86 int (*read_random)(void *arg, u_int32_t *buf, int len);
90 static int random_proc(void *arg);
92 static pid_t randomproc = (pid_t) -1;
93 static spinlock_t random_lock;
96 * just init the spin locks
99 crypto_random_init(void)
101 spin_lock_init(&random_lock);
107 * Add the given random reader to our list (if not present)
108 * and start the thread (if not already started)
110 * we have to assume that driver id is ok for now
115 int (*read_random)(void *arg, u_int32_t *buf, int len),
120 struct random_op *rops, *tmp;
122 dprintk("%s,%d: %s(0x%x, %p, %p)\n", __FILE__, __LINE__,
123 __FUNCTION__, driverid, read_random, arg);
126 crypto_random_init();
129 struct cryptocap *cap;
131 cap = crypto_checkdriver(driverid);
136 list_for_each_entry_safe(rops, tmp, &random_ops, random_list) {
137 if (rops->driverid == driverid && rops->read_random == read_random)
141 rops = (struct random_op *) kmalloc(sizeof(*rops), GFP_KERNEL);
145 rops->driverid = driverid;
146 rops->read_random = read_random;
149 spin_lock_irqsave(&random_lock, flags);
150 list_add_tail(&rops->random_list, &random_ops);
152 randomproc = kernel_thread(random_proc, NULL, CLONE_FS|CLONE_FILES);
153 if (randomproc < 0) {
155 printk("crypto: crypto_rregister cannot start random thread; "
160 spin_unlock_irqrestore(&random_lock, flags);
164 EXPORT_SYMBOL(crypto_rregister);
167 crypto_runregister_all(u_int32_t driverid)
169 struct random_op *rops, *tmp;
172 dprintk("%s,%d: %s(0x%x)\n", __FILE__, __LINE__, __FUNCTION__, driverid);
174 list_for_each_entry_safe(rops, tmp, &random_ops, random_list) {
175 if (rops->driverid == driverid) {
176 list_del(&rops->random_list);
181 spin_lock_irqsave(&random_lock, flags);
182 if (list_empty(&random_ops) && started)
183 kill_proc(randomproc, SIGKILL, 1);
184 spin_unlock_irqrestore(&random_lock, flags);
187 EXPORT_SYMBOL(crypto_runregister_all);
190 * while we can add entropy to random.c continue to read random data from
191 * the drivers and push it to random.
194 random_proc(void *arg)
202 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
204 spin_lock_irq(¤t->sigmask_lock);
205 sigemptyset(¤t->blocked);
206 recalc_sigpending(current);
207 spin_unlock_irq(¤t->sigmask_lock);
208 sprintf(current->comm, "ocf-random");
210 daemonize("ocf-random");
211 allow_signal(SIGKILL);
217 #ifdef CONFIG_OCF_FIPS
218 #define NUM_INT (RNDTEST_NBYTES/sizeof(int))
224 * some devices can transferr their RNG data direct into memory,
225 * so make sure it is device friendly
227 buf = kmalloc(NUM_INT * sizeof(int), GFP_DMA);
229 printk("crypto: RNG could not allocate memory\n");
234 wantcnt = NUM_INT; /* start by adding some entropy */
237 * its possible due to errors or driver removal that we no longer
238 * have anything to do, if so exit or we will consume all the CPU
241 while (!list_empty(&random_ops)) {
242 struct random_op *rops, *tmp;
244 #ifdef CONFIG_OCF_FIPS
246 wantcnt = NUM_INT; /* FIPs mode can do 20000 bits or none */
249 /* see if we can get enough entropy to make the world
252 while (bufcnt < wantcnt && bufcnt < NUM_INT) {
253 list_for_each_entry_safe(rops, tmp, &random_ops, random_list) {
255 n = (*rops->read_random)(rops->arg, &buf[bufcnt],
258 /* on failure remove the random number generator */
260 list_del(&rops->random_list);
261 printk("crypto: RNG (driverid=0x%x) failed, disabling\n",
267 /* give up CPU for a bit, just in case as this is a loop */
272 #ifdef CONFIG_OCF_FIPS
273 if (bufcnt > 0 && rndtest_buf((unsigned char *) &buf[0])) {
274 dprintk("crypto: buffer had fips errors, discarding\n");
280 * if we have a certified buffer, we can send some data
281 * to /dev/random and move along
284 /* add what we have */
285 random_input_words(buf, bufcnt, bufcnt*sizeof(int)*8);
289 /* give up CPU for a bit so we don't hog while filling */
292 /* wait for needing more */
293 wantcnt = random_input_wait();
296 wantcnt = 0; /* try to get some info again */
298 /* round up to one word or we can loop forever */
299 wantcnt = (wantcnt + (sizeof(int)*8)) / (sizeof(int)*8);
300 if (wantcnt > NUM_INT) {
304 if (signal_pending(current)) {
305 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
306 spin_lock_irq(¤t->sigmask_lock);
308 flush_signals(current);
309 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
310 spin_unlock_irq(¤t->sigmask_lock);
318 spin_lock_irq(&random_lock);
319 randomproc = (pid_t) -1;
321 spin_unlock_irq(&random_lock);