random: clarify bits/bytes in wakeup thresholds

These are a recurring cause of confusion, so rename them to
hopefully be clearer.

Signed-off-by: Greg Price <price@mit.edu>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

1 files changed, 17 insertions, 17 deletions

diff --git a/drivers/char/random.c b/drivers/char/random.c
index 581d806823e9..8cc7d6515676 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -295,14 +295,14 @@
  * The minimum number of bits of entropy before we wake up a read on
  * /dev/random.  Should be enough to do a significant reseed.
  */
-static int random_read_wakeup_thresh = 64;
+static int random_read_wakeup_bits = 64;
 
 /*
  * If the entropy count falls under this number of bits, then we
  * should wake up processes which are selecting or polling on write
  * access to /dev/random.
  */
-static int random_write_wakeup_thresh = 28 * OUTPUT_POOL_WORDS;
+static int random_write_wakeup_bits = 28 * OUTPUT_POOL_WORDS;
 
 /*
  * The minimum number of seconds between urandom pool reseeding.  We
@@ -669,7 +669,7 @@ retry:
                 int entropy_bits = entropy_count >> ENTROPY_SHIFT;
 
                 /* should we wake readers? */
-                if (entropy_bits >= random_read_wakeup_thresh) {
+                if (entropy_bits >= random_read_wakeup_bits) {
                         wake_up_interruptible(&random_read_wait);
                         kill_fasync(&fasync, SIGIO, POLL_IN);
                 }
@@ -678,9 +678,9 @@ retry:
                  * forth between them, until the output pools are 75%
                  * full.
                  */
-                if (entropy_bits > random_write_wakeup_thresh &&
+                if (entropy_bits > random_write_wakeup_bits &&
                     r->initialized &&
-                    r->entropy_total >= 2*random_read_wakeup_thresh) {
+                    r->entropy_total >= 2*random_read_wakeup_bits) {
                         static struct entropy_store *last = &blocking_pool;
                         struct entropy_store *other = &blocking_pool;
 
@@ -924,19 +924,19 @@ static void _xfer_secondary_pool(struct entropy_store *r, size_t nbytes)
 {
         __u32   tmp[OUTPUT_POOL_WORDS];
 
-        /* For /dev/random's pool, always leave two wakeup worth's BITS */
-        int rsvd = r->limit ? 0 : random_read_wakeup_thresh/4;
+        /* For /dev/random's pool, always leave two wakeups' worth */
+        int rsvd_bytes = r->limit ? 0 : random_read_wakeup_bits / 4;
         int bytes = nbytes;
 
-        /* pull at least as many as BYTES as wakeup BITS */
-        bytes = max_t(int, bytes, random_read_wakeup_thresh / 8);
+        /* pull at least as much as a wakeup */
+        bytes = max_t(int, bytes, random_read_wakeup_bits / 8);
         /* but never more than the buffer size */
         bytes = min_t(int, bytes, sizeof(tmp));
 
         trace_xfer_secondary_pool(r->name, bytes * 8, nbytes * 8,
                                   ENTROPY_BITS(r), ENTROPY_BITS(r->pull));
         bytes = extract_entropy(r->pull, tmp, bytes,
-                                random_read_wakeup_thresh / 8, rsvd);
+                                random_read_wakeup_bits / 8, rsvd_bytes);
         mix_pool_bytes(r, tmp, bytes, NULL);
         credit_entropy_bits(r, bytes*8);
 }
@@ -952,7 +952,7 @@ static void push_to_pool(struct work_struct *work)
         struct entropy_store *r = container_of(work, struct entropy_store,
                                               push_work);
         BUG_ON(!r);
-        _xfer_secondary_pool(r, random_read_wakeup_thresh/8);
+        _xfer_secondary_pool(r, random_read_wakeup_bits/8);
         trace_push_to_pool(r->name, r->entropy_count >> ENTROPY_SHIFT,
                            r->pull->entropy_count >> ENTROPY_SHIFT);
 }
@@ -987,7 +987,7 @@ retry:
 
         trace_debit_entropy(r->name, 8 * ibytes);
         if (ibytes &&
-            (r->entropy_count >> ENTROPY_SHIFT) < random_write_wakeup_thresh) {
+            (r->entropy_count >> ENTROPY_SHIFT) < random_write_wakeup_bits) {
                 wake_up_interruptible(&random_write_wait);
                 kill_fasync(&fasync, SIGIO, POLL_OUT);
         }
@@ -1303,7 +1303,7 @@ random_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
 
                 wait_event_interruptible(random_read_wait,
                         ENTROPY_BITS(&input_pool) >=
-                        random_read_wakeup_thresh);
+                        random_read_wakeup_bits);
                 if (signal_pending(current))
                         return -ERESTARTSYS;
         }
@@ -1334,9 +1334,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 (ENTROPY_BITS(&input_pool) >= random_read_wakeup_thresh)
+        if (ENTROPY_BITS(&input_pool) >= random_read_wakeup_bits)
                 mask |= POLLIN | POLLRDNORM;
-        if (ENTROPY_BITS(&input_pool) < random_write_wakeup_thresh)
+        if (ENTROPY_BITS(&input_pool) < random_write_wakeup_bits)
                 mask |= POLLOUT | POLLWRNORM;
         return mask;
 }
@@ -1559,7 +1559,7 @@ struct ctl_table random_table[] = {
         },
         {
                 .procname       = "read_wakeup_threshold",
-                .data           = &random_read_wakeup_thresh,
+                .data           = &random_read_wakeup_bits,
                 .maxlen         = sizeof(int),
                 .mode           = 0644,
                 .proc_handler   = proc_dointvec_minmax,
@@ -1568,7 +1568,7 @@ struct ctl_table random_table[] = {
         },
         {
                 .procname       = "write_wakeup_threshold",
-                .data           = &random_write_wakeup_thresh,
+                .data           = &random_write_wakeup_bits,
                 .maxlen         = sizeof(int),
                 .mode           = 0644,
                 .proc_handler   = proc_dointvec_minmax,