/* * 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. Load more
/* * 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,