random: allow fractional bits to be tracked

Allow fractional bits of entropy to be tracked by scaling the entropy
counter (fixed point).  This will be used in a subsequent patch that
accounts for entropy lost due to overwrites.

[ Modified by tytso to fix up a few missing places where the
  entropy_count wasn't properly converted from fractional bits to
  bits. ]

Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

1 files changed, 92 insertions, 46 deletions

diff --git a/drivers/char/random.c b/drivers/char/random.c
index 20651a2fd8a7..c2957656c5bc 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -280,6 +280,15 @@
 #define LONGS(x) (((x) + sizeof(unsigned long) - 1)/sizeof(unsigned long))
 
 /*
+ * To allow fractional bits to be tracked, the following fields contain
+ * this many fractional bits:
+ *
+ * entropy_count, trickle_thresh
+ */
+#define ENTROPY_SHIFT 3
+#define ENTROPY_BITS(r) ((r)->entropy_count >> ENTROPY_SHIFT)
+
+/*
  * The minimum number of bits of entropy before we wake up a read on
  * /dev/random.  Should be enough to do a significant reseed.
  */
@@ -296,8 +305,7 @@ static int random_write_wakeup_thresh = 128;
  * When the input pool goes over trickle_thresh, start dropping most
  * samples to avoid wasting CPU time and reduce lock contention.
  */
-
-static int trickle_thresh __read_mostly = INPUT_POOL_WORDS * 28;
+static const int trickle_thresh = (INPUT_POOL_WORDS * 28) << ENTROPY_SHIFT;
 
 static DEFINE_PER_CPU(int, trickle_count);
 
@@ -311,8 +319,8 @@ static DEFINE_PER_CPU(int, trickle_count);
  */
 
 static struct poolinfo {
-        int poolbitshift, poolwords, poolbytes, poolbits;
-#define S(x) ilog2(x)+5, (x), (x)*4, (x)*32
+        int poolbitshift, poolwords, poolbytes, poolbits, poolfracbits;
+#define S(x) ilog2(x)+5, (x), (x)*4, (x)*32, (x) << (ENTROPY_SHIFT+5)
         int tap1, tap2, tap3, tap4, tap5;
 } poolinfo_table[] = {
         /* x^128 + x^103 + x^76 + x^51 +x^25 + x + 1 -- 105 */
@@ -581,7 +589,9 @@ static void fast_mix(struct fast_pool *f, const void *in, int nbytes)
 }
 
 /*
- * Credit (or debit) the entropy store with n bits of entropy
+ * Credit (or debit) the entropy store with n bits of entropy.
+ * Use credit_entropy_bits_safe() if the value comes from userspace
+ * or otherwise should be checked for extreme values.
  */
 static void credit_entropy_bits(struct entropy_store *r, int nbits)
 {
@@ -593,13 +603,13 @@ static void credit_entropy_bits(struct entropy_store *r, int nbits)
         DEBUG_ENT("added %d entropy credits to %s\n", nbits, r->name);
 retry:
         entropy_count = orig = ACCESS_ONCE(r->entropy_count);
-        entropy_count += nbits;
+        entropy_count += nbits << ENTROPY_SHIFT;
 
         if (entropy_count < 0) {
                 DEBUG_ENT("negative entropy/overflow\n");
                 entropy_count = 0;
-        } else if (entropy_count > r->poolinfo->poolbits)
-                entropy_count = r->poolinfo->poolbits;
+        } else if (entropy_count > r->poolinfo->poolfracbits)
+                entropy_count = r->poolinfo->poolfracbits;
         if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig)
                 goto retry;
 
@@ -609,16 +619,29 @@ retry:
                         r->initialized = 1;
         }
 
-        trace_credit_entropy_bits(r->name, nbits, entropy_count,
+        trace_credit_entropy_bits(r->name, nbits,
+                                  entropy_count >> ENTROPY_SHIFT,
                                   r->entropy_total, _RET_IP_);
 
         /* should we wake readers? */
-        if (r == &input_pool && entropy_count >= random_read_wakeup_thresh) {
+        if (r == &input_pool &&
+            (entropy_count >> ENTROPY_SHIFT) >= random_read_wakeup_thresh) {
                 wake_up_interruptible(&random_read_wait);
                 kill_fasync(&fasync, SIGIO, POLL_IN);
         }
 }
 
+static void credit_entropy_bits_safe(struct entropy_store *r, int nbits)
+{
+        const int nbits_max = (int)(~0U >> (ENTROPY_SHIFT + 1));
+
+        /* Cap the value to avoid overflows */
+        nbits = min(nbits,  nbits_max);
+        nbits = max(nbits, -nbits_max);
+
+        credit_entropy_bits(r, nbits);
+}
+
 /*********************************************************************
  *
  * Entropy input management
@@ -674,7 +697,7 @@ static void add_timer_randomness(struct timer_rand_state *state, unsigned num)
 
         preempt_disable();
         /* if over the trickle threshold, use only 1 in 4096 samples */
-        if (input_pool.entropy_count > trickle_thresh &&
+        if (ENTROPY_BITS(&input_pool) > trickle_thresh &&
             ((__this_cpu_inc_return(trickle_count) - 1) & 0xfff))
                 goto out;
 
@@ -813,8 +836,9 @@ static void xfer_secondary_pool(struct entropy_store *r, size_t nbytes)
 {
         __u32   tmp[OUTPUT_POOL_WORDS];
 
-        if (r->pull && r->entropy_count < nbytes * 8 &&
-            r->entropy_count < r->poolinfo->poolbits) {
+        if (r->pull &&
+            r->entropy_count < (nbytes << (ENTROPY_SHIFT + 3)) &&
+            r->entropy_count < r->poolinfo->poolfracbits) {
                 /* If we're limited, always leave two wakeup worth's BITS */
                 int rsvd = r->limit ? 0 : random_read_wakeup_thresh/4;
                 int bytes = nbytes;
@@ -826,7 +850,8 @@ static void xfer_secondary_pool(struct entropy_store *r, size_t nbytes)
 
                 DEBUG_ENT("going to reseed %s with %d bits "
                           "(%zu of %d requested)\n",
-                          r->name, bytes * 8, nbytes * 8, r->entropy_count);
+                          r->name, bytes * 8, nbytes * 8,
+                          r->entropy_count >> ENTROPY_SHIFT);
 
                 bytes = extract_entropy(r->pull, tmp, bytes,
                                         random_read_wakeup_thresh / 8, rsvd);
@@ -852,41 +877,44 @@ static size_t account(struct entropy_store *r, size_t nbytes, int min,
 {
         unsigned long flags;
         int wakeup_write = 0;
+        int have_bytes;
+        int entropy_count, orig;
+        size_t ibytes;
 
         /* Hold lock while accounting */
         spin_lock_irqsave(&r->lock, flags);
 
-        BUG_ON(r->entropy_count > r->poolinfo->poolbits);
+        BUG_ON(r->entropy_count > r->poolinfo->poolfracbits);
         DEBUG_ENT("trying to extract %zu bits from %s\n",
                   nbytes * 8, r->name);
 
         /* Can we pull enough? */
-        if (r->entropy_count / 8 < min + reserved) {
-                nbytes = 0;
-        } else {
-                int entropy_count, orig;
 retry:
-                entropy_count = orig = ACCESS_ONCE(r->entropy_count);
+        entropy_count = orig = ACCESS_ONCE(r->entropy_count);
+        have_bytes = entropy_count >> (ENTROPY_SHIFT + 3);
+        ibytes = nbytes;
+        if (have_bytes < min + reserved) {
+                ibytes = 0;
+        } else {
                 /* If limited, never pull more than available */
-                if (r->limit && nbytes + reserved >= entropy_count / 8)
-                        nbytes = entropy_count/8 - reserved;
-
-                if (entropy_count / 8 >= nbytes + reserved) {
-                        entropy_count -= nbytes*8;
-                        if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig)
-                                goto retry;
-                } else {
-                        entropy_count = reserved;
-                        if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig)
-                                goto retry;
-                }
+                if (r->limit && ibytes + reserved >= have_bytes)
+                        ibytes = have_bytes - reserved;
+
+                if (have_bytes >= ibytes + reserved)
+                        entropy_count -= ibytes << (ENTROPY_SHIFT + 3);
+                else
+                        entropy_count = reserved << (ENTROPY_SHIFT + 3);
 
-                if (entropy_count < random_write_wakeup_thresh)
+                if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig)
+                        goto retry;
+
+                if ((r->entropy_count >> ENTROPY_SHIFT)
+                    < random_write_wakeup_thresh)
                         wakeup_write = 1;
         }
 
         DEBUG_ENT("debiting %zu entropy credits from %s%s\n",
-                  nbytes * 8, r->name, r->limit ? "" : " (unlimited)");
+                  ibytes * 8, r->name, r->limit ? "" : " (unlimited)");
 
         spin_unlock_irqrestore(&r->lock, flags);
 
@@ -895,7 +923,7 @@ retry:
                 kill_fasync(&fasync, SIGIO, POLL_OUT);
         }
 
-        return nbytes;
+        return ibytes;
 }
 
 static void extract_buf(struct entropy_store *r, __u8 *out)
@@ -973,7 +1001,7 @@ static ssize_t extract_entropy(struct entropy_store *r, void *buf,
                         r->last_data_init = true;
                         spin_unlock_irqrestore(&r->lock, flags);
                         trace_extract_entropy(r->name, EXTRACT_SIZE,
-                                              r->entropy_count, _RET_IP_);
+                                              ENTROPY_BITS(r), _RET_IP_);
                         xfer_secondary_pool(r, EXTRACT_SIZE);
                         extract_buf(r, tmp);
                         spin_lock_irqsave(&r->lock, flags);
@@ -982,7 +1010,7 @@ static ssize_t extract_entropy(struct entropy_store *r, void *buf,
                 spin_unlock_irqrestore(&r->lock, flags);
         }
 
-        trace_extract_entropy(r->name, nbytes, r->entropy_count, _RET_IP_);
+        trace_extract_entropy(r->name, nbytes, ENTROPY_BITS(r), _RET_IP_);
         xfer_secondary_pool(r, nbytes);
         nbytes = account(r, nbytes, min, reserved);
 
@@ -1015,7 +1043,7 @@ static ssize_t extract_entropy_user(struct entropy_store *r, void __user *buf,
         ssize_t ret = 0, i;
         __u8 tmp[EXTRACT_SIZE];
 
-        trace_extract_entropy_user(r->name, nbytes, r->entropy_count, _RET_IP_);
+        trace_extract_entropy_user(r->name, nbytes, ENTROPY_BITS(r), _RET_IP_);
         xfer_secondary_pool(r, nbytes);
         nbytes = account(r, nbytes, 0, 0);
 
@@ -1187,8 +1215,8 @@ random_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
                         DEBUG_ENT("sleeping?\n");
 
                         wait_event_interruptible(random_read_wait,
-                                input_pool.entropy_count >=
-                                                 random_read_wakeup_thresh);
+                                ENTROPY_BITS(&input_pool) >=
+                                random_read_wakeup_thresh);
 
                         DEBUG_ENT("awake\n");
 
@@ -1224,9 +1252,9 @@ random_poll(struct file *file, poll_table * wait)
         poll_wait(file, &random_read_wait, wait);
         poll_wait(file, &random_write_wait, wait);
         mask = 0;
-        if (input_pool.entropy_count >= random_read_wakeup_thresh)
+        if (ENTROPY_BITS(&input_pool) >= random_read_wakeup_thresh)
                 mask |= POLLIN | POLLRDNORM;
-        if (input_pool.entropy_count < random_write_wakeup_thresh)
+        if (ENTROPY_BITS(&input_pool) < random_write_wakeup_thresh)
                 mask |= POLLOUT | POLLWRNORM;
         return mask;
 }
@@ -1277,7 +1305,8 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
         switch (cmd) {
         case RNDGETENTCNT:
                 /* inherently racy, no point locking */
-                if (put_user(input_pool.entropy_count, p))
+                ent_count = ENTROPY_BITS(&input_pool);
+                if (put_user(ent_count, p))
                         return -EFAULT;
                 return 0;
         case RNDADDTOENTCNT:
@@ -1285,7 +1314,7 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
                         return -EPERM;
                 if (get_user(ent_count, p))
                         return -EFAULT;
-                credit_entropy_bits(&input_pool, ent_count);
+                credit_entropy_bits_safe(&input_pool, ent_count);
                 return 0;
         case RNDADDENTROPY:
                 if (!capable(CAP_SYS_ADMIN))
@@ -1300,7 +1329,7 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
                                     size);
                 if (retval < 0)
                         return retval;
-                credit_entropy_bits(&input_pool, ent_count);
+                credit_entropy_bits_safe(&input_pool, ent_count);
                 return 0;
         case RNDZAPENTCNT:
         case RNDCLEARPOOL:
@@ -1407,6 +1436,23 @@ static int proc_do_uuid(struct ctl_table *table, int write,
         return proc_dostring(&fake_table, write, buffer, lenp, ppos);
 }
 
+/*
+ * Return entropy available scaled to integral bits
+ */
+static int proc_do_entropy(ctl_table *table, int write,
+                           void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+        ctl_table fake_table;
+        int entropy_count;
+
+        entropy_count = *(int *)table->data >> ENTROPY_SHIFT;
+
+        fake_table.data = &entropy_count;
+        fake_table.maxlen = sizeof(entropy_count);
+
+        return proc_dointvec(&fake_table, write, buffer, lenp, ppos);
+}
+
 static int sysctl_poolsize = INPUT_POOL_WORDS * 32;
 extern struct ctl_table random_table[];
 struct ctl_table random_table[] = {
@@ -1421,7 +1467,7 @@ struct ctl_table random_table[] = {
                 .procname       = "entropy_avail",
                 .maxlen         = sizeof(int),
                 .mode           = 0444,
-                .proc_handler   = proc_dointvec,
+                .proc_handler   = proc_do_entropy,
                 .data           = &input_pool.entropy_count,
         },
         {