2006-06-26 07:24:59 +00:00
|
|
|
/*
|
2016-12-13 14:51:11 +00:00
|
|
|
* hw_random/core.c: HWRNG core API
|
|
|
|
*
|
|
|
|
* Copyright 2006 Michael Buesch <m@bues.ch>
|
|
|
|
* Copyright 2005 (c) MontaVista Software, Inc.
|
|
|
|
*
|
2019-06-27 17:56:51 +00:00
|
|
|
* Please read Documentation/admin-guide/hw_random.rst for details on use.
|
2016-12-13 14:51:11 +00:00
|
|
|
*
|
|
|
|
* This software may be used and distributed according to the terms
|
|
|
|
* of the GNU General Public License, incorporated herein by reference.
|
2006-06-26 07:24:59 +00:00
|
|
|
*/
|
|
|
|
|
2016-12-13 14:51:12 +00:00
|
|
|
#include <linux/delay.h>
|
2006-06-26 07:24:59 +00:00
|
|
|
#include <linux/device.h>
|
2016-12-13 14:51:12 +00:00
|
|
|
#include <linux/err.h>
|
2019-08-05 23:32:41 +00:00
|
|
|
#include <linux/freezer.h>
|
2016-12-13 14:51:12 +00:00
|
|
|
#include <linux/fs.h>
|
2006-06-26 07:24:59 +00:00
|
|
|
#include <linux/hw_random.h>
|
|
|
|
#include <linux/kernel.h>
|
2014-06-15 03:46:03 +00:00
|
|
|
#include <linux/kthread.h>
|
2017-02-02 18:15:33 +00:00
|
|
|
#include <linux/sched/signal.h>
|
2016-12-13 14:51:12 +00:00
|
|
|
#include <linux/miscdevice.h>
|
|
|
|
#include <linux/module.h>
|
2014-03-03 23:51:48 +00:00
|
|
|
#include <linux/random.h>
|
2016-12-13 14:51:12 +00:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/slab.h>
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2006-06-26 07:24:59 +00:00
|
|
|
|
|
|
|
#define RNG_MODULE_NAME "hw_random"
|
|
|
|
|
|
|
|
static struct hwrng *current_rng;
|
2017-07-11 07:36:23 +00:00
|
|
|
/* the current rng has been explicitly chosen by user via sysfs */
|
|
|
|
static int cur_rng_set_by_user;
|
2014-06-15 03:46:03 +00:00
|
|
|
static struct task_struct *hwrng_fill;
|
2017-07-11 07:36:22 +00:00
|
|
|
/* list of registered rngs, sorted decending by quality */
|
2006-06-26 07:24:59 +00:00
|
|
|
static LIST_HEAD(rng_list);
|
2014-12-08 08:50:35 +00:00
|
|
|
/* Protects rng_list and current_rng */
|
2006-06-26 07:24:59 +00:00
|
|
|
static DEFINE_MUTEX(rng_mutex);
|
2014-12-08 08:50:35 +00:00
|
|
|
/* Protects rng read functions, data_avail, rng_buffer and rng_fillbuf */
|
|
|
|
static DEFINE_MUTEX(reading_mutex);
|
2009-12-01 06:47:32 +00:00
|
|
|
static int data_avail;
|
2014-06-15 03:46:03 +00:00
|
|
|
static u8 *rng_buffer, *rng_fillbuf;
|
2014-06-15 03:48:41 +00:00
|
|
|
static unsigned short current_quality;
|
|
|
|
static unsigned short default_quality; /* = 0; default to "off" */
|
2014-06-15 03:46:03 +00:00
|
|
|
|
|
|
|
module_param(current_quality, ushort, 0644);
|
|
|
|
MODULE_PARM_DESC(current_quality,
|
2018-09-25 16:35:18 +00:00
|
|
|
"current hwrng entropy estimation per 1024 bits of input");
|
2014-06-15 03:48:41 +00:00
|
|
|
module_param(default_quality, ushort, 0644);
|
|
|
|
MODULE_PARM_DESC(default_quality,
|
2018-09-25 16:35:18 +00:00
|
|
|
"default entropy content of hwrng per 1024 bits of input");
|
2014-06-15 03:46:03 +00:00
|
|
|
|
2014-12-23 05:40:21 +00:00
|
|
|
static void drop_current_rng(void);
|
2014-12-23 05:40:22 +00:00
|
|
|
static int hwrng_init(struct hwrng *rng);
|
2014-06-15 03:46:03 +00:00
|
|
|
static void start_khwrngd(void);
|
2013-03-04 23:37:08 +00:00
|
|
|
|
2014-07-10 10:12:34 +00:00
|
|
|
static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
|
|
|
|
int wait);
|
|
|
|
|
2013-03-04 23:37:08 +00:00
|
|
|
static size_t rng_buffer_size(void)
|
|
|
|
{
|
|
|
|
return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES;
|
|
|
|
}
|
2006-06-26 07:24:59 +00:00
|
|
|
|
2014-07-10 10:12:34 +00:00
|
|
|
static void add_early_randomness(struct hwrng *rng)
|
|
|
|
{
|
|
|
|
int bytes_read;
|
2016-10-17 17:06:27 +00:00
|
|
|
size_t size = min_t(size_t, 16, rng_buffer_size());
|
2014-07-10 10:12:34 +00:00
|
|
|
|
2014-12-08 08:50:35 +00:00
|
|
|
mutex_lock(&reading_mutex);
|
2019-09-17 09:54:50 +00:00
|
|
|
bytes_read = rng_get_data(rng, rng_buffer, size, 0);
|
2014-12-08 08:50:35 +00:00
|
|
|
mutex_unlock(&reading_mutex);
|
2014-07-10 10:12:34 +00:00
|
|
|
if (bytes_read > 0)
|
2016-10-17 17:06:27 +00:00
|
|
|
add_device_randomness(rng_buffer, bytes_read);
|
2014-07-10 10:12:34 +00:00
|
|
|
}
|
|
|
|
|
2014-12-08 08:50:37 +00:00
|
|
|
static inline void cleanup_rng(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct hwrng *rng = container_of(kref, struct hwrng, ref);
|
|
|
|
|
|
|
|
if (rng->cleanup)
|
|
|
|
rng->cleanup(rng);
|
2014-12-08 08:50:38 +00:00
|
|
|
|
2014-12-23 05:40:17 +00:00
|
|
|
complete(&rng->cleanup_done);
|
2014-12-08 08:50:37 +00:00
|
|
|
}
|
|
|
|
|
2014-12-23 05:40:22 +00:00
|
|
|
static int set_current_rng(struct hwrng *rng)
|
2014-12-08 08:50:37 +00:00
|
|
|
{
|
2014-12-23 05:40:22 +00:00
|
|
|
int err;
|
|
|
|
|
2014-12-08 08:50:37 +00:00
|
|
|
BUG_ON(!mutex_is_locked(&rng_mutex));
|
2014-12-23 05:40:22 +00:00
|
|
|
|
|
|
|
err = hwrng_init(rng);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2014-12-23 05:40:21 +00:00
|
|
|
drop_current_rng();
|
2014-12-08 08:50:37 +00:00
|
|
|
current_rng = rng;
|
2014-12-23 05:40:22 +00:00
|
|
|
|
|
|
|
return 0;
|
2014-12-08 08:50:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void drop_current_rng(void)
|
|
|
|
{
|
|
|
|
BUG_ON(!mutex_is_locked(&rng_mutex));
|
|
|
|
if (!current_rng)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* decrease last reference for triggering the cleanup */
|
|
|
|
kref_put(¤t_rng->ref, cleanup_rng);
|
|
|
|
current_rng = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns ERR_PTR(), NULL or refcounted hwrng */
|
|
|
|
static struct hwrng *get_current_rng(void)
|
|
|
|
{
|
|
|
|
struct hwrng *rng;
|
|
|
|
|
|
|
|
if (mutex_lock_interruptible(&rng_mutex))
|
|
|
|
return ERR_PTR(-ERESTARTSYS);
|
|
|
|
|
|
|
|
rng = current_rng;
|
|
|
|
if (rng)
|
|
|
|
kref_get(&rng->ref);
|
|
|
|
|
|
|
|
mutex_unlock(&rng_mutex);
|
|
|
|
return rng;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void put_rng(struct hwrng *rng)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Hold rng_mutex here so we serialize in case they set_current_rng
|
|
|
|
* on rng again immediately.
|
|
|
|
*/
|
|
|
|
mutex_lock(&rng_mutex);
|
|
|
|
if (rng)
|
|
|
|
kref_put(&rng->ref, cleanup_rng);
|
|
|
|
mutex_unlock(&rng_mutex);
|
|
|
|
}
|
|
|
|
|
2014-12-23 05:40:22 +00:00
|
|
|
static int hwrng_init(struct hwrng *rng)
|
2006-06-26 07:24:59 +00:00
|
|
|
{
|
2014-12-23 05:40:18 +00:00
|
|
|
if (kref_get_unless_zero(&rng->ref))
|
|
|
|
goto skip_init;
|
|
|
|
|
2014-07-10 10:12:34 +00:00
|
|
|
if (rng->init) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = rng->init(rng);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2014-12-23 05:40:18 +00:00
|
|
|
|
|
|
|
kref_init(&rng->ref);
|
|
|
|
reinit_completion(&rng->cleanup_done);
|
|
|
|
|
|
|
|
skip_init:
|
2014-07-10 10:12:34 +00:00
|
|
|
add_early_randomness(rng);
|
2014-06-15 03:46:03 +00:00
|
|
|
|
2014-06-15 03:48:41 +00:00
|
|
|
current_quality = rng->quality ? : default_quality;
|
2015-03-18 07:17:00 +00:00
|
|
|
if (current_quality > 1024)
|
|
|
|
current_quality = 1024;
|
2014-06-15 03:48:41 +00:00
|
|
|
|
|
|
|
if (current_quality == 0 && hwrng_fill)
|
|
|
|
kthread_stop(hwrng_fill);
|
2014-06-15 03:46:03 +00:00
|
|
|
if (current_quality > 0 && !hwrng_fill)
|
|
|
|
start_khwrngd();
|
|
|
|
|
2014-07-10 10:12:34 +00:00
|
|
|
return 0;
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int rng_dev_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
/* enforce read-only access to this chrdev */
|
|
|
|
if ((filp->f_mode & FMODE_READ) == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
if (filp->f_mode & FMODE_WRITE)
|
|
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-01 06:47:32 +00:00
|
|
|
static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
|
|
|
|
int wait) {
|
|
|
|
int present;
|
|
|
|
|
2014-12-08 08:50:35 +00:00
|
|
|
BUG_ON(!mutex_is_locked(&reading_mutex));
|
2009-12-01 06:47:32 +00:00
|
|
|
if (rng->read)
|
|
|
|
return rng->read(rng, (void *)buffer, size, wait);
|
|
|
|
|
|
|
|
if (rng->data_present)
|
|
|
|
present = rng->data_present(rng, wait);
|
|
|
|
else
|
|
|
|
present = 1;
|
|
|
|
|
|
|
|
if (present)
|
|
|
|
return rng->data_read(rng, (u32 *)buffer);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-26 07:24:59 +00:00
|
|
|
static ssize_t rng_dev_read(struct file *filp, char __user *buf,
|
|
|
|
size_t size, loff_t *offp)
|
|
|
|
{
|
|
|
|
ssize_t ret = 0;
|
2007-11-21 04:24:45 +00:00
|
|
|
int err = 0;
|
2009-12-01 06:47:32 +00:00
|
|
|
int bytes_read, len;
|
2014-12-08 08:50:37 +00:00
|
|
|
struct hwrng *rng;
|
2006-06-26 07:24:59 +00:00
|
|
|
|
|
|
|
while (size) {
|
2014-12-08 08:50:37 +00:00
|
|
|
rng = get_current_rng();
|
|
|
|
if (IS_ERR(rng)) {
|
|
|
|
err = PTR_ERR(rng);
|
2006-06-26 07:24:59 +00:00
|
|
|
goto out;
|
2009-12-01 06:47:32 +00:00
|
|
|
}
|
2014-12-08 08:50:37 +00:00
|
|
|
if (!rng) {
|
2006-06-26 07:24:59 +00:00
|
|
|
err = -ENODEV;
|
2014-12-08 08:50:37 +00:00
|
|
|
goto out;
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
2007-11-21 04:24:45 +00:00
|
|
|
|
2015-11-27 15:50:43 +00:00
|
|
|
if (mutex_lock_interruptible(&reading_mutex)) {
|
|
|
|
err = -ERESTARTSYS;
|
|
|
|
goto out_put;
|
|
|
|
}
|
2009-12-01 06:47:32 +00:00
|
|
|
if (!data_avail) {
|
2014-12-08 08:50:37 +00:00
|
|
|
bytes_read = rng_get_data(rng, rng_buffer,
|
2013-03-04 23:37:08 +00:00
|
|
|
rng_buffer_size(),
|
2009-12-01 06:47:32 +00:00
|
|
|
!(filp->f_flags & O_NONBLOCK));
|
|
|
|
if (bytes_read < 0) {
|
|
|
|
err = bytes_read;
|
2014-12-08 08:50:35 +00:00
|
|
|
goto out_unlock_reading;
|
2009-12-01 06:47:32 +00:00
|
|
|
}
|
|
|
|
data_avail = bytes_read;
|
2008-04-17 05:46:14 +00:00
|
|
|
}
|
2006-06-26 07:24:59 +00:00
|
|
|
|
2009-12-01 06:47:32 +00:00
|
|
|
if (!data_avail) {
|
|
|
|
if (filp->f_flags & O_NONBLOCK) {
|
|
|
|
err = -EAGAIN;
|
2014-12-08 08:50:35 +00:00
|
|
|
goto out_unlock_reading;
|
2009-12-01 06:47:32 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
len = data_avail;
|
|
|
|
if (len > size)
|
|
|
|
len = size;
|
|
|
|
|
|
|
|
data_avail -= len;
|
|
|
|
|
|
|
|
if (copy_to_user(buf + ret, rng_buffer + data_avail,
|
|
|
|
len)) {
|
|
|
|
err = -EFAULT;
|
2014-12-08 08:50:35 +00:00
|
|
|
goto out_unlock_reading;
|
2009-12-01 06:47:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
size -= len;
|
|
|
|
ret += len;
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
|
|
|
|
2014-12-08 08:50:35 +00:00
|
|
|
mutex_unlock(&reading_mutex);
|
2014-12-08 08:50:37 +00:00
|
|
|
put_rng(rng);
|
2009-12-01 06:47:32 +00:00
|
|
|
|
2006-06-26 07:24:59 +00:00
|
|
|
if (need_resched())
|
|
|
|
schedule_timeout_interruptible(1);
|
2009-12-01 06:47:32 +00:00
|
|
|
|
|
|
|
if (signal_pending(current)) {
|
|
|
|
err = -ERESTARTSYS;
|
2006-06-26 07:24:59 +00:00
|
|
|
goto out;
|
2009-12-01 06:47:32 +00:00
|
|
|
}
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret ? : err;
|
2014-12-08 08:50:37 +00:00
|
|
|
|
2014-12-08 08:50:35 +00:00
|
|
|
out_unlock_reading:
|
|
|
|
mutex_unlock(&reading_mutex);
|
2015-11-27 15:50:43 +00:00
|
|
|
out_put:
|
2014-12-08 08:50:37 +00:00
|
|
|
put_rng(rng);
|
|
|
|
goto out;
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
|
|
|
|
2006-07-03 07:24:21 +00:00
|
|
|
static const struct file_operations rng_chrdev_ops = {
|
2006-06-26 07:24:59 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = rng_dev_open,
|
|
|
|
.read = rng_dev_read,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 16:52:59 +00:00
|
|
|
.llseek = noop_llseek,
|
2006-06-26 07:24:59 +00:00
|
|
|
};
|
|
|
|
|
2015-02-02 14:44:55 +00:00
|
|
|
static const struct attribute_group *rng_dev_groups[];
|
|
|
|
|
2006-06-26 07:24:59 +00:00
|
|
|
static struct miscdevice rng_miscdev = {
|
2016-12-13 14:51:13 +00:00
|
|
|
.minor = HWRNG_MINOR,
|
2006-06-26 07:24:59 +00:00
|
|
|
.name = RNG_MODULE_NAME,
|
2009-09-18 21:01:12 +00:00
|
|
|
.nodename = "hwrng",
|
2006-06-26 07:24:59 +00:00
|
|
|
.fops = &rng_chrdev_ops,
|
2015-02-02 14:44:55 +00:00
|
|
|
.groups = rng_dev_groups,
|
2006-06-26 07:24:59 +00:00
|
|
|
};
|
|
|
|
|
2017-10-27 17:04:04 +00:00
|
|
|
static int enable_best_rng(void)
|
|
|
|
{
|
|
|
|
int ret = -ENODEV;
|
|
|
|
|
|
|
|
BUG_ON(!mutex_is_locked(&rng_mutex));
|
|
|
|
|
|
|
|
/* rng_list is sorted by quality, use the best (=first) one */
|
|
|
|
if (!list_empty(&rng_list)) {
|
|
|
|
struct hwrng *new_rng;
|
|
|
|
|
|
|
|
new_rng = list_entry(rng_list.next, struct hwrng, list);
|
|
|
|
ret = ((new_rng == current_rng) ? 0 : set_current_rng(new_rng));
|
|
|
|
if (!ret)
|
|
|
|
cur_rng_set_by_user = 0;
|
2017-12-15 19:55:59 +00:00
|
|
|
} else {
|
|
|
|
drop_current_rng();
|
|
|
|
cur_rng_set_by_user = 0;
|
|
|
|
ret = 0;
|
2017-10-27 17:04:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-07-27 23:16:04 +00:00
|
|
|
static ssize_t hwrng_attr_current_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
2006-06-26 07:24:59 +00:00
|
|
|
const char *buf, size_t len)
|
|
|
|
{
|
2017-10-27 17:04:04 +00:00
|
|
|
int err = -ENODEV;
|
2006-06-26 07:24:59 +00:00
|
|
|
struct hwrng *rng;
|
|
|
|
|
|
|
|
err = mutex_lock_interruptible(&rng_mutex);
|
|
|
|
if (err)
|
|
|
|
return -ERESTARTSYS;
|
2017-10-27 17:04:04 +00:00
|
|
|
|
|
|
|
if (sysfs_streq(buf, "")) {
|
|
|
|
err = enable_best_rng();
|
|
|
|
} else {
|
|
|
|
list_for_each_entry(rng, &rng_list, list) {
|
|
|
|
if (sysfs_streq(rng->name, buf)) {
|
|
|
|
cur_rng_set_by_user = 1;
|
2014-12-23 05:40:22 +00:00
|
|
|
err = set_current_rng(rng);
|
2017-10-27 17:04:04 +00:00
|
|
|
break;
|
|
|
|
}
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
|
|
|
}
|
2017-10-27 17:04:04 +00:00
|
|
|
|
2006-06-26 07:24:59 +00:00
|
|
|
mutex_unlock(&rng_mutex);
|
|
|
|
|
|
|
|
return err ? : len;
|
|
|
|
}
|
|
|
|
|
2006-07-27 23:16:04 +00:00
|
|
|
static ssize_t hwrng_attr_current_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
2006-06-26 07:24:59 +00:00
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
ssize_t ret;
|
2014-12-08 08:50:37 +00:00
|
|
|
struct hwrng *rng;
|
2006-06-26 07:24:59 +00:00
|
|
|
|
2014-12-08 08:50:37 +00:00
|
|
|
rng = get_current_rng();
|
|
|
|
if (IS_ERR(rng))
|
|
|
|
return PTR_ERR(rng);
|
|
|
|
|
|
|
|
ret = snprintf(buf, PAGE_SIZE, "%s\n", rng ? rng->name : "none");
|
|
|
|
put_rng(rng);
|
2006-06-26 07:24:59 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-07-27 23:16:04 +00:00
|
|
|
static ssize_t hwrng_attr_available_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
2006-06-26 07:24:59 +00:00
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct hwrng *rng;
|
|
|
|
|
|
|
|
err = mutex_lock_interruptible(&rng_mutex);
|
|
|
|
if (err)
|
|
|
|
return -ERESTARTSYS;
|
|
|
|
buf[0] = '\0';
|
|
|
|
list_for_each_entry(rng, &rng_list, list) {
|
2014-10-16 21:17:23 +00:00
|
|
|
strlcat(buf, rng->name, PAGE_SIZE);
|
|
|
|
strlcat(buf, " ", PAGE_SIZE);
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
2014-10-16 21:17:23 +00:00
|
|
|
strlcat(buf, "\n", PAGE_SIZE);
|
2006-06-26 07:24:59 +00:00
|
|
|
mutex_unlock(&rng_mutex);
|
|
|
|
|
2014-10-16 21:17:23 +00:00
|
|
|
return strlen(buf);
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
|
|
|
|
2017-07-11 07:36:23 +00:00
|
|
|
static ssize_t hwrng_attr_selected_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", cur_rng_set_by_user);
|
|
|
|
}
|
|
|
|
|
2006-07-27 23:16:04 +00:00
|
|
|
static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
|
|
|
|
hwrng_attr_current_show,
|
|
|
|
hwrng_attr_current_store);
|
|
|
|
static DEVICE_ATTR(rng_available, S_IRUGO,
|
|
|
|
hwrng_attr_available_show,
|
|
|
|
NULL);
|
2017-07-11 07:36:23 +00:00
|
|
|
static DEVICE_ATTR(rng_selected, S_IRUGO,
|
|
|
|
hwrng_attr_selected_show,
|
|
|
|
NULL);
|
2006-06-26 07:24:59 +00:00
|
|
|
|
2015-02-02 14:44:55 +00:00
|
|
|
static struct attribute *rng_dev_attrs[] = {
|
|
|
|
&dev_attr_rng_current.attr,
|
|
|
|
&dev_attr_rng_available.attr,
|
2017-07-11 07:36:23 +00:00
|
|
|
&dev_attr_rng_selected.attr,
|
2015-02-02 14:44:55 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
ATTRIBUTE_GROUPS(rng_dev);
|
2006-06-26 07:24:59 +00:00
|
|
|
|
2014-12-23 05:40:19 +00:00
|
|
|
static void __exit unregister_miscdev(void)
|
2006-06-26 07:24:59 +00:00
|
|
|
{
|
2008-03-23 19:28:24 +00:00
|
|
|
misc_deregister(&rng_miscdev);
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
|
|
|
|
2014-12-23 05:40:19 +00:00
|
|
|
static int __init register_miscdev(void)
|
2006-06-26 07:24:59 +00:00
|
|
|
{
|
2015-02-02 14:44:55 +00:00
|
|
|
return misc_register(&rng_miscdev);
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
|
|
|
|
2014-06-15 03:46:03 +00:00
|
|
|
static int hwrng_fillfn(void *unused)
|
|
|
|
{
|
|
|
|
long rc;
|
|
|
|
|
2019-08-05 23:32:41 +00:00
|
|
|
set_freezable();
|
|
|
|
|
|
|
|
while (!kthread_freezable_should_stop(NULL)) {
|
2014-12-08 08:50:37 +00:00
|
|
|
struct hwrng *rng;
|
|
|
|
|
|
|
|
rng = get_current_rng();
|
|
|
|
if (IS_ERR(rng) || !rng)
|
2014-06-15 03:46:03 +00:00
|
|
|
break;
|
2014-12-08 08:50:35 +00:00
|
|
|
mutex_lock(&reading_mutex);
|
2014-12-08 08:50:37 +00:00
|
|
|
rc = rng_get_data(rng, rng_fillbuf,
|
2014-06-15 03:46:03 +00:00
|
|
|
rng_buffer_size(), 1);
|
2014-12-08 08:50:35 +00:00
|
|
|
mutex_unlock(&reading_mutex);
|
2014-12-08 08:50:37 +00:00
|
|
|
put_rng(rng);
|
2014-06-15 03:46:03 +00:00
|
|
|
if (rc <= 0) {
|
|
|
|
pr_warn("hwrng: no data available\n");
|
|
|
|
msleep_interruptible(10000);
|
|
|
|
continue;
|
|
|
|
}
|
2014-12-08 08:50:35 +00:00
|
|
|
/* Outside lock, sure, but y'know: randomness. */
|
2014-06-15 03:46:03 +00:00
|
|
|
add_hwgenerator_randomness((void *)rng_fillbuf, rc,
|
2014-07-25 22:19:18 +00:00
|
|
|
rc * current_quality * 8 >> 10);
|
2014-06-15 03:46:03 +00:00
|
|
|
}
|
2014-06-16 14:24:09 +00:00
|
|
|
hwrng_fill = NULL;
|
2014-06-15 03:46:03 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void start_khwrngd(void)
|
|
|
|
{
|
|
|
|
hwrng_fill = kthread_run(hwrng_fillfn, NULL, "hwrng");
|
2015-07-24 11:13:30 +00:00
|
|
|
if (IS_ERR(hwrng_fill)) {
|
2017-09-25 07:45:00 +00:00
|
|
|
pr_err("hwrng_fill thread creation failed\n");
|
2014-06-15 03:46:03 +00:00
|
|
|
hwrng_fill = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-26 07:24:59 +00:00
|
|
|
int hwrng_register(struct hwrng *rng)
|
|
|
|
{
|
|
|
|
int err = -EINVAL;
|
|
|
|
struct hwrng *old_rng, *tmp;
|
2017-07-11 07:36:22 +00:00
|
|
|
struct list_head *rng_list_ptr;
|
2006-06-26 07:24:59 +00:00
|
|
|
|
2016-12-13 14:51:10 +00:00
|
|
|
if (!rng->name || (!rng->data_read && !rng->read))
|
2006-06-26 07:24:59 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
mutex_lock(&rng_mutex);
|
|
|
|
/* Must not register two RNGs with the same name. */
|
|
|
|
err = -EEXIST;
|
|
|
|
list_for_each_entry(tmp, &rng_list, list) {
|
|
|
|
if (strcmp(tmp->name, rng->name) == 0)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2014-12-23 05:40:18 +00:00
|
|
|
init_completion(&rng->cleanup_done);
|
|
|
|
complete(&rng->cleanup_done);
|
|
|
|
|
2017-07-11 07:36:22 +00:00
|
|
|
/* rng_list is sorted by decreasing quality */
|
|
|
|
list_for_each(rng_list_ptr, &rng_list) {
|
|
|
|
tmp = list_entry(rng_list_ptr, struct hwrng, list);
|
|
|
|
if (tmp->quality < rng->quality)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
list_add_tail(&rng->list, rng_list_ptr);
|
|
|
|
|
2006-06-26 07:24:59 +00:00
|
|
|
old_rng = current_rng;
|
2014-12-08 08:50:39 +00:00
|
|
|
err = 0;
|
2017-07-11 07:36:23 +00:00
|
|
|
if (!old_rng ||
|
|
|
|
(!cur_rng_set_by_user && rng->quality > old_rng->quality)) {
|
2017-07-11 07:36:22 +00:00
|
|
|
/*
|
|
|
|
* Set new rng as current as the new rng source
|
2017-07-11 07:36:23 +00:00
|
|
|
* provides better entropy quality and was not
|
|
|
|
* chosen by userspace.
|
2017-07-11 07:36:22 +00:00
|
|
|
*/
|
2014-12-23 05:40:22 +00:00
|
|
|
err = set_current_rng(rng);
|
2006-06-26 07:24:59 +00:00
|
|
|
if (err)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2014-03-03 23:51:48 +00:00
|
|
|
|
2014-07-10 10:12:34 +00:00
|
|
|
if (old_rng && !rng->init) {
|
|
|
|
/*
|
|
|
|
* Use a new device's input to add some randomness to
|
|
|
|
* the system. If this rng device isn't going to be
|
|
|
|
* used right away, its init function hasn't been
|
|
|
|
* called yet; so only use the randomness from devices
|
|
|
|
* that don't need an init callback.
|
|
|
|
*/
|
|
|
|
add_early_randomness(rng);
|
|
|
|
}
|
|
|
|
|
2006-06-26 07:24:59 +00:00
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&rng_mutex);
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hwrng_register);
|
|
|
|
|
2008-03-23 19:28:24 +00:00
|
|
|
void hwrng_unregister(struct hwrng *rng)
|
2006-06-26 07:24:59 +00:00
|
|
|
{
|
2018-06-14 18:08:11 +00:00
|
|
|
int err;
|
|
|
|
|
2006-06-26 07:24:59 +00:00
|
|
|
mutex_lock(&rng_mutex);
|
|
|
|
|
|
|
|
list_del(&rng->list);
|
2018-06-14 18:08:11 +00:00
|
|
|
if (current_rng == rng) {
|
|
|
|
err = enable_best_rng();
|
|
|
|
if (err) {
|
|
|
|
drop_current_rng();
|
|
|
|
cur_rng_set_by_user = 0;
|
|
|
|
}
|
|
|
|
}
|
2014-12-08 08:50:37 +00:00
|
|
|
|
2014-06-15 03:46:03 +00:00
|
|
|
if (list_empty(&rng_list)) {
|
2014-12-08 08:50:36 +00:00
|
|
|
mutex_unlock(&rng_mutex);
|
2014-06-15 03:46:03 +00:00
|
|
|
if (hwrng_fill)
|
|
|
|
kthread_stop(hwrng_fill);
|
2014-12-08 08:50:36 +00:00
|
|
|
} else
|
|
|
|
mutex_unlock(&rng_mutex);
|
2014-12-08 08:50:38 +00:00
|
|
|
|
2014-12-23 05:40:17 +00:00
|
|
|
wait_for_completion(&rng->cleanup_done);
|
2006-06-26 07:24:59 +00:00
|
|
|
}
|
2008-03-23 19:28:24 +00:00
|
|
|
EXPORT_SYMBOL_GPL(hwrng_unregister);
|
2006-06-26 07:24:59 +00:00
|
|
|
|
2015-03-12 21:00:02 +00:00
|
|
|
static void devm_hwrng_release(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
hwrng_unregister(*(struct hwrng **)res);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int devm_hwrng_match(struct device *dev, void *res, void *data)
|
|
|
|
{
|
|
|
|
struct hwrng **r = res;
|
|
|
|
|
|
|
|
if (WARN_ON(!r || !*r))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return *r == data;
|
|
|
|
}
|
|
|
|
|
|
|
|
int devm_hwrng_register(struct device *dev, struct hwrng *rng)
|
|
|
|
{
|
|
|
|
struct hwrng **ptr;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
ptr = devres_alloc(devm_hwrng_release, sizeof(*ptr), GFP_KERNEL);
|
|
|
|
if (!ptr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
error = hwrng_register(rng);
|
|
|
|
if (error) {
|
|
|
|
devres_free(ptr);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
*ptr = rng;
|
|
|
|
devres_add(dev, ptr);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_hwrng_register);
|
|
|
|
|
|
|
|
void devm_hwrng_unregister(struct device *dev, struct hwrng *rng)
|
|
|
|
{
|
|
|
|
devres_release(dev, devm_hwrng_release, devm_hwrng_match, rng);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_hwrng_unregister);
|
|
|
|
|
2014-12-23 05:40:19 +00:00
|
|
|
static int __init hwrng_modinit(void)
|
|
|
|
{
|
2016-09-07 14:48:02 +00:00
|
|
|
int ret = -ENOMEM;
|
|
|
|
|
|
|
|
/* kmalloc makes this safe for virt_to_page() in virtio_rng.c */
|
|
|
|
rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL);
|
|
|
|
if (!rng_buffer)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL);
|
|
|
|
if (!rng_fillbuf) {
|
|
|
|
kfree(rng_buffer);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = register_miscdev();
|
|
|
|
if (ret) {
|
|
|
|
kfree(rng_fillbuf);
|
|
|
|
kfree(rng_buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2014-12-23 05:40:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit hwrng_modexit(void)
|
2013-03-20 00:58:51 +00:00
|
|
|
{
|
|
|
|
mutex_lock(&rng_mutex);
|
|
|
|
BUG_ON(current_rng);
|
|
|
|
kfree(rng_buffer);
|
2014-06-15 03:46:03 +00:00
|
|
|
kfree(rng_fillbuf);
|
2013-03-20 00:58:51 +00:00
|
|
|
mutex_unlock(&rng_mutex);
|
2014-12-23 05:40:19 +00:00
|
|
|
|
|
|
|
unregister_miscdev();
|
2013-03-20 00:58:51 +00:00
|
|
|
}
|
|
|
|
|
2014-12-23 05:40:19 +00:00
|
|
|
module_init(hwrng_modinit);
|
|
|
|
module_exit(hwrng_modexit);
|
2006-06-26 07:24:59 +00:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
|
|
|
|
MODULE_LICENSE("GPL");
|