diff -urpNX dontdiff linux-2.5.50/drivers/char/random.c linux-2.5.50-random/drivers/char/random.c
--- linux-2.5.50/drivers/char/random.c 2002-11-17 23:29:22.000000000 -0500
+++ linux-2.5.50-random/drivers/char/random.c 2002-11-29 17:03:10.000000000 -0500
@@ -240,25 +240,25 @@
* Eastlake, Steve Crocker, and Jeff Schiller.
*/
-#include <linux/utsname.h>
#include <linux/config.h>
-#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/genhd.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/major.h>
+#include <linux/module.h>
+#include <linux/poll.h>
+#include <linux/random.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
#include <linux/string.h>
+#include <linux/utsname.h>
+#include <linux/wait.h>
#include <linux/fcntl.h>
-#include <linux/slab.h>
-#include <linux/random.h>
-#include <linux/poll.h>
-#include <linux/init.h>
-#include <linux/fs.h>
-#include <linux/workqueue.h>
-#include <linux/genhd.h>
#include <asm/processor.h>
#include <asm/uaccess.h>
-#include <asm/irq.h>
-#include <asm/io.h>
/*
* Configuration information
@@ -341,7 +341,7 @@ static struct poolinfo {
* (See M. Matsumoto & Y. Kurita, 1992. Twisted GFSR generators. ACM
* Transactions on Modeling and Computer Simulation 2(3):179-194.
* Also see M. Matsumoto & Y. Kurita, 1994. Twisted GFSR generators
- * II. ACM Transactions on Mdeling and Computer Simulation 4:254-266)
+ * II. ACM Transactions on Modeling and Computer Simulation 4:254-266)
*
* Thanks to Colin Plumb for suggesting this.
*
@@ -625,23 +625,43 @@ static __u32 *batch_entropy_pool;
static int *batch_entropy_credit;
static int batch_max;
static int batch_head, batch_tail;
-static void batch_entropy_process(void *private_);
-static DECLARE_WORK(batch_work, batch_entropy_process, NULL);
+
+/*
+ * entropy_lock protects these 5 variables and the data they point to.
+ * Is acquired in interrupt context so must be acquired in process or BH
+ * context with interrupts disabled.
+ */
+static spinlock_t entropy_lock = SPIN_LOCK_UNLOCKED;
+
+static void batch_entropy_process(unsigned long private_);
+static DECLARE_TASKLET(batch_work, batch_entropy_process, 0);
+struct entropy_data {
+ __u32 entropy[2];
+ int credit;
+};
/* note: the size must be a power of 2 */
static int __init batch_entropy_init(int size, struct entropy_store *r)
{
- batch_entropy_pool = kmalloc(2*size*sizeof(__u32), GFP_KERNEL);
- if (!batch_entropy_pool)
+ void *pool, *credit;
+
+ pool = kmalloc(2*size*sizeof(__u32), GFP_KERNEL);
+ if (!pool)
return -1;
- batch_entropy_credit =kmalloc(size*sizeof(int), GFP_KERNEL);
- if (!batch_entropy_credit) {
- kfree(batch_entropy_pool);
+ credit = kmalloc(size*sizeof(int), GFP_KERNEL);
+ if (!credit) {
+ kfree(pool);
return -1;
}
+
+ spin_lock_irq(&entropy_lock);
+ batch_entropy_pool = pool;
+ batch_entropy_credit = credit;
batch_head = batch_tail = 0;
batch_max = size;
- batch_work.data = r;
+ batch_work.data = (unsigned long)r;
+ spin_unlock_irq(&entropy_lock);
+
return 0;
}
@@ -649,15 +669,21 @@ static int __init batch_entropy_init(int
* Changes to the entropy data is put into a queue rather than being added to
* the entropy counts directly. This is presumably to avoid doing heavy
* hashing calculations during an interrupt in add_timer_randomness().
- * Instead, the entropy is only added to the pool by keventd.
+ * Instead, the entropy is added to the pool next time we run the tasklets.
*/
void batch_entropy_store(u32 a, u32 b, int num)
{
int new;
+ unsigned long flags;
if (!batch_max)
return;
-
+
+ /*
+ * This function is _probably_ only called in irq context, but
+ * better safe than sorry.
+ */
+ spin_lock_irqsave(&entropy_lock, flags);
batch_entropy_pool[2*batch_head] = a;
batch_entropy_pool[(2*batch_head) + 1] = b;
batch_entropy_credit[batch_head] = num;
@@ -667,11 +693,12 @@ void batch_entropy_store(u32 a, u32 b, i
/*
* Schedule it for the next timer tick:
*/
- schedule_delayed_work(&batch_work, 1);
+ tasklet_schedule(&batch_work);
batch_head = new;
} else {
DEBUG_ENT("batch entropy buffer full\n");
}
+ spin_unlock_irqrestore(&entropy_lock, flags);
}
/*
@@ -679,25 +706,34 @@ void batch_entropy_store(u32 a, u32 b, i
* store (normally random_state). If that store has enough entropy, alternate
* between randomizing the data of the primary and secondary stores.
*/
-static void batch_entropy_process(void *private_)
+static void batch_entropy_process(unsigned long private_)
{
struct entropy_store *r = (struct entropy_store *) private_, *p;
int max_entropy = r->poolinfo.POOLBITS;
+ struct entropy_data cache;
if (!batch_max)
return;
p = r;
+ spin_lock_irq(&entropy_lock);
while (batch_head != batch_tail) {
+ cache.entropy[0] = batch_entropy_pool[2*batch_tail];
+ cache.entropy[1] = batch_entropy_pool[2*batch_tail + 1];
+ cache.credit = batch_entropy_credit[batch_tail];
+ batch_tail = (batch_tail+1) & (batch_max-1);
+ spin_unlock_irq(&entropy_lock);
+
if (r->entropy_count >= max_entropy) {
r = (r == sec_random_state) ? random_state :
sec_random_state;
max_entropy = r->poolinfo.POOLBITS;
}
- add_entropy_words(r, batch_entropy_pool + 2*batch_tail, 2);
- credit_entropy_store(r, batch_entropy_credit[batch_tail]);
- batch_tail = (batch_tail+1) & (batch_max-1);
+ add_entropy_words(r, cache.entropy, 2);
+ credit_entropy_store(r, cache.credit);
+ spin_lock_irq(&entropy_lock);
}
+ spin_unlock_irq(&entropy_lock);
if (p->entropy_count >= random_read_wakeup_thresh)
wake_up_interruptible(&random_read_wait);
}
@@ -1738,7 +1774,8 @@ static int change_poolsize(int poolsize)
sysctl_init_random(new_store);
old_store = random_state;
- random_state = batch_work.data = new_store;
+ random_state = new_store;
+ batch_work.data = (unsigned long)new_store;
free_entropy_store(old_store);
return 0;
}
