804 lines · 16.6 KB · C
RawDownload
/* * hw_random/core.c: HWRNG core API * * Copyright 2006 Michael Buesch <m@bues.ch> * Copyright 2005 (c) MontaVista Software, Inc. * * Please read Documentation/admin-guide/hw_random.rst for details on use. * * This software may be used and distributed according to the terms * of the GNU General Public License, incorporated herein by reference. */ #include <linux/delay.h>#include <linux/device.h>#include <linux/err.h>#include <linux/fs.h>#include <linux/hw_random.h>#include <linux/kernel.h>#include <linux/kthread.h>#include <linux/lockdep.h>#include <linux/miscdevice.h>#include <linux/module.h>#include <linux/notifier.h>#include <linux/random.h>#include <linux/rcupdate.h>#include <linux/sched.h>#include <linux/sched/signal.h>#include <linux/slab.h>#include <linux/string.h>#include <linux/suspend.h>#include <linux/sysfs.h>#include <linux/uaccess.h>#include <linux/workqueue.h> #define RNG_MODULE_NAME		"hw_random" #define RNG_BUFFER_SIZE		MAX(32, SMP_CACHE_BYTES) static struct hwrng __rcu *current_rng;/* the current rng has been explicitly chosen by user via sysfs */static int cur_rng_set_by_user;static struct task_struct *hwrng_fill;/* list of registered rngs */static LIST_HEAD(rng_list);/* Protects rng_list, hwrng_fill and updating on current_rng */static DEFINE_MUTEX(rng_mutex);/* Protects rng read functions, data_avail, rng_buffer and rng_fillbuf */static DEFINE_MUTEX(reading_mutex);static int data_avail;static u8 *rng_buffer, *rng_fillbuf;/* Set to true during suspend-resume by PM notifier, protected by rng_mutex */static bool hwrng_fillfn_stopped;static unsigned short current_quality;static unsigned short default_quality = 1024; /* default to maximum */ module_param(current_quality, ushort, 0644);MODULE_PARM_DESC(current_quality,		 "current hwrng entropy estimation per 1024 bits of input -- obsolete, use rng_quality instead");module_param(default_quality, ushort, 0644);MODULE_PARM_DESC(default_quality,		 "default maximum entropy content of hwrng per 1024 bits of input"); static int hwrng_init(struct hwrng *rng);static int hwrng_fillfn(void *unused);static void hwrng_start_hwrng_fillfn(void);static void hwrng_stop_hwrng_fillfn(void); static size_t rng_buffer_size(void){	return RNG_BUFFER_SIZE;} static void cleanup_rng_work(struct work_struct *work){	struct hwrng *rng = container_of(work, struct hwrng, cleanup_work); 	/*	 * Hold rng_mutex here so we serialize in case they set_current_rng	 * on rng again immediately.	 */	mutex_lock(&rng_mutex); 	/* Skip if rng has been reinitialized. */	if (kref_read(&rng->ref)) {		mutex_unlock(&rng_mutex);		return;	} 	if (rng->cleanup)		rng->cleanup(rng); 	complete(&rng->cleanup_done);	mutex_unlock(&rng_mutex);} static inline void cleanup_rng(struct kref *kref){	struct hwrng *rng = container_of(kref, struct hwrng, ref); 	schedule_work(&rng->cleanup_work);} static int set_current_rng(struct hwrng *rng){	struct hwrng *old_rng;	int err; 	BUG_ON(!mutex_is_locked(&rng_mutex)); 	err = hwrng_init(rng);	if (err)		return err; 	old_rng = rcu_dereference_protected(current_rng,					    lockdep_is_held(&rng_mutex));	rcu_assign_pointer(current_rng, rng); 	if (old_rng) {		synchronize_rcu();		kref_put(&old_rng->ref, cleanup_rng);	} 	/* if necessary, start hwrng thread */	hwrng_start_hwrng_fillfn(); 	return 0;} static void drop_current_rng(void){	struct hwrng *rng; 	rng = rcu_dereference_protected(current_rng,					lockdep_is_held(&rng_mutex));	if (!rng)		return; 	RCU_INIT_POINTER(current_rng, NULL);	synchronize_rcu(); 	hwrng_stop_hwrng_fillfn(); 	/* decrease last reference for triggering the cleanup */	kref_put(&rng->ref, cleanup_rng);} /* Returns NULL or refcounted hwrng */static struct hwrng *get_current_rng_nolock(void){	struct hwrng *rng; 	rng = rcu_dereference_protected(current_rng,					lockdep_is_held(&rng_mutex));	if (rng)		kref_get(&rng->ref); 	return rng;} static struct hwrng *get_current_rng(void){	struct hwrng *rng; 	rcu_read_lock();	rng = rcu_dereference(current_rng);	if (rng)		kref_get(&rng->ref); 	rcu_read_unlock(); 	return rng;} static void put_rng(struct hwrng *rng){	if (rng)		kref_put(&rng->ref, cleanup_rng);} static int hwrng_init(struct hwrng *rng){	if (kref_get_unless_zero(&rng->ref))		goto skip_init; 	if (rng->init) {		int ret; 		ret =  rng->init(rng);		if (ret)			return ret;	} 	kref_init(&rng->ref);	reinit_completion(&rng->cleanup_done); skip_init:	current_quality = rng->quality; /* obsolete */ 	return 0;} 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;} static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size, bool wait){	int present; 	BUG_ON(!mutex_is_locked(&reading_mutex));	if (rng->read) {		int err; 		err = rng->read(rng, buffer, size, wait);		if (WARN_ON_ONCE(err > 0 && err > size))			err = size; 		return err;	} 	if (rng->data_present)		present = rng->data_present(rng, wait);	else		present = 1; 	if (present)		return rng->data_read(rng, (u32 *)buffer); 	return 0;} static ssize_t rng_dev_read(struct file *filp, char __user *buf,			    size_t size, loff_t *offp){	u8 buffer[RNG_BUFFER_SIZE];	ssize_t ret = 0;	int err = 0;	int bytes_read, len;	struct hwrng *rng; 	while (size) {		rng = get_current_rng();		if (!rng) {			err = -ENODEV;			goto out;		} 		if (mutex_lock_interruptible(&reading_mutex)) {			err = -ERESTARTSYS;			goto out_put;		}		if (!data_avail) {			bytes_read = rng_get_data(rng, rng_buffer,				rng_buffer_size(),				!(filp->f_flags & O_NONBLOCK));			if (bytes_read < 0) {				err = bytes_read;				goto out_unlock_reading;			} else if (bytes_read == 0 &&				   (filp->f_flags & O_NONBLOCK)) {				err = -EAGAIN;				goto out_unlock_reading;			} 			data_avail = bytes_read;		} 		len = data_avail;		if (len) {			if (len > size)				len = size; 			data_avail -= len; 			memcpy(buffer, rng_buffer + data_avail, len);		}		mutex_unlock(&reading_mutex);		put_rng(rng); 		if (len) {			if (copy_to_user(buf + ret, buffer, len)) {				err = -EFAULT;				goto out;			} 			size -= len;			ret += len;		}  		if (need_resched())			schedule_timeout_interruptible(1); 		if (signal_pending(current)) {			err = -ERESTARTSYS;			goto out;		}	}out:	memzero_explicit(buffer, sizeof(buffer));	return ret ? : err; out_unlock_reading:	mutex_unlock(&reading_mutex);out_put:	put_rng(rng);	goto out;} static const struct file_operations rng_chrdev_ops = {	.owner		= THIS_MODULE,	.open		= rng_dev_open,	.read		= rng_dev_read,	.llseek		= noop_llseek,}; static const struct attribute_group *rng_dev_groups[]; static struct miscdevice rng_miscdev = {	.minor		= HWRNG_MINOR,	.name		= RNG_MODULE_NAME,	.nodename	= "hwrng",	.fops		= &rng_chrdev_ops,	.groups		= rng_dev_groups,}; static int enable_best_rng(void){	struct hwrng *rng, *cur_rng, *new_rng = NULL;	int ret = -ENODEV; 	BUG_ON(!mutex_is_locked(&rng_mutex)); 	/* no rng to use? */	if (list_empty(&rng_list)) {		drop_current_rng();		cur_rng_set_by_user = 0;		return 0;	} 	/* use the rng which offers the best quality */	list_for_each_entry(rng, &rng_list, list) {		if (!new_rng || rng->quality > new_rng->quality)			new_rng = rng;	} 	cur_rng = rcu_dereference_protected(current_rng,					    lockdep_is_held(&rng_mutex));	ret = ((new_rng == cur_rng) ? 0 : set_current_rng(new_rng));	if (!ret)		cur_rng_set_by_user = 0; 	return ret;} static ssize_t rng_current_store(struct device *dev,				 struct device_attribute *attr,				 const char *buf, size_t len){	int err;	struct hwrng *rng, *new_rng; 	err = mutex_lock_interruptible(&rng_mutex);	if (err)		return -ERESTARTSYS; 	if (sysfs_streq(buf, "")) {		err = enable_best_rng();	} else if (sysfs_streq(buf, "none")) {		cur_rng_set_by_user = 1;		drop_current_rng();	} else {		list_for_each_entry(rng, &rng_list, list) {			if (sysfs_streq(rng->name, buf)) {				err = set_current_rng(rng);				if (!err)					cur_rng_set_by_user = 1;				break;			}		}	}	new_rng = get_current_rng_nolock();	mutex_unlock(&rng_mutex); 	if (new_rng)		put_rng(new_rng); 	return err ? : len;} static ssize_t rng_current_show(struct device *dev,				struct device_attribute *attr,				char *buf){	ssize_t ret;	struct hwrng *rng; 	rng = get_current_rng(); 	ret = sysfs_emit(buf, "%s\n", rng ? rng->name : "none");	put_rng(rng); 	return ret;} static ssize_t rng_available_show(struct device *dev,				  struct device_attribute *attr,				  char *buf){	struct hwrng *rng;	int len = 0; 	if (mutex_lock_interruptible(&rng_mutex))		return -ERESTARTSYS;	list_for_each_entry(rng, &rng_list, list)		len += sysfs_emit_at(buf, len, "%s ", rng->name);	len += sysfs_emit_at(buf, len, "none\n");	mutex_unlock(&rng_mutex); 	return len;} static ssize_t rng_selected_show(struct device *dev,				 struct device_attribute *attr,				 char *buf){	return sysfs_emit(buf, "%d\n", cur_rng_set_by_user);} static ssize_t rng_quality_show(struct device *dev,				struct device_attribute *attr,				char *buf){	ssize_t ret;	struct hwrng *rng; 	rng = get_current_rng(); 	if (!rng) /* no need to put_rng */		return -ENODEV; 	ret = sysfs_emit(buf, "%hu\n", rng->quality);	put_rng(rng); 	return ret;} static ssize_t rng_quality_store(struct device *dev,				 struct device_attribute *attr,				 const char *buf, size_t len){	struct hwrng *rng;	u16 quality;	int ret = -EINVAL; 	if (len < 2)		return -EINVAL; 	ret = mutex_lock_interruptible(&rng_mutex);	if (ret)		return -ERESTARTSYS; 	ret = kstrtou16(buf, 0, &quality);	if (ret || quality > 1024) {		ret = -EINVAL;		goto out;	} 	rng = rcu_dereference_protected(current_rng, lockdep_is_held(&rng_mutex));	if (!rng) {		ret = -ENODEV;		goto out;	} 	rng->quality = quality;	current_quality = quality; /* obsolete */ 	/* the best available RNG may have changed */	ret = enable_best_rng(); out:	mutex_unlock(&rng_mutex);	return ret ? ret : len;} static DEVICE_ATTR_RW(rng_current);static DEVICE_ATTR_RO(rng_available);static DEVICE_ATTR_RO(rng_selected);static DEVICE_ATTR_RW(rng_quality); static struct attribute *rng_dev_attrs[] = {	&dev_attr_rng_current.attr,	&dev_attr_rng_available.attr,	&dev_attr_rng_selected.attr,

Lines 1–500 of 804.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t