drivers/char/hw_random/core.c

   1 /*
   2         Added support for the AMD Geode LX RNG
   3         (c) Copyright 2004-2005 Advanced Micro Devices, Inc.
   4
   5         derived from
   6
   7         Hardware driver for the Intel/AMD/VIA Random Number Generators (RNG)
   8         (c) Copyright 2003 Red Hat Inc <jgarzik@redhat.com>
   9
  10         derived from
  11
  12         Hardware driver for the AMD 768 Random Number Generator (RNG)
  13         (c) Copyright 2001 Red Hat Inc <alan@redhat.com>
  14
  15         derived from
  16
  17         Hardware driver for Intel i810 Random Number Generator (RNG)
  18         Copyright 2000,2001 Jeff Garzik <jgarzik@pobox.com>
  19         Copyright 2000,2001 Philipp Rumpf <prumpf@mandrakesoft.com>
  20
  21         Added generic RNG API
  22         Copyright 2006 Michael Buesch <m@bues.ch>
  23         Copyright 2005 (c) MontaVista Software, Inc.
  24
  25         Please read Documentation/hw_random.txt for details on use.
  26
  27         ----------------------------------------------------------
  28         This software may be used and distributed according to the terms
  29         of the GNU General Public License, incorporated herein by reference.
  30
  31  */
  32
  33
  34 #include <linux/device.h>
  35 #include <linux/hw_random.h>
  36 #include <linux/module.h>
  37 #include <linux/kernel.h>
  38 #include <linux/fs.h>
  39 #include <linux/sched.h>
  40 #include <linux/miscdevice.h>
  41 #include <linux/delay.h>
  42 #include <linux/slab.h>
  43 #include <linux/random.h>
  44 #include <asm/uaccess.h>
  45
  46
  47 #define RNG_MODULE_NAME         "hw_random"
  48 #define PFX                     RNG_MODULE_NAME ": "
  49 #define RNG_MISCDEV_MINOR       183 /* official */
  50
  51
  52 static struct hwrng *current_rng;
  53 static LIST_HEAD(rng_list);
  54 static DEFINE_MUTEX(rng_mutex);
  55 static int data_avail;
  56 static u8 *rng_buffer;
  57
  58 static size_t rng_buffer_size(void)
  59 {
  60         return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES;
  61 }
  62
  63 static inline int hwrng_init(struct hwrng *rng)
  64 {
  65         if (!rng->init)
  66                 return 0;
  67         return rng->init(rng);
  68 }
  69
  70 static inline void hwrng_cleanup(struct hwrng *rng)
  71 {
  72         if (rng && rng->cleanup)
  73                 rng->cleanup(rng);
  74 }
  75
  76 static int rng_dev_open(struct inode *inode, struct file *filp)
  77 {
  78         /* enforce read-only access to this chrdev */
  79         if ((filp->f_mode & FMODE_READ) == 0)
  80                 return -EINVAL;
  81         if (filp->f_mode & FMODE_WRITE)
  82                 return -EINVAL;
  83         return 0;
  84 }
  85
  86 static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
  87                         int wait) {
  88         int present;
  89
  90         if (rng->read)
  91                 return rng->read(rng, (void *)buffer, size, wait);
  92
  93         if (rng->data_present)
  94                 present = rng->data_present(rng, wait);
  95         else
  96                 present = 1;
  97
  98         if (present)
  99                 return rng->data_read(rng, (u32 *)buffer);
 100
 101         return 0;
 102 }
 103
 104 static ssize_t rng_dev_read(struct file *filp, char __user *buf,
 105                             size_t size, loff_t *offp)
 106 {
 107         ssize_t ret = 0;
 108         int err = 0;
 109         int bytes_read, len;
 110
 111         while (size) {
 112                 if (mutex_lock_interruptible(&rng_mutex)) {
 113                         err = -ERESTARTSYS;
 114                         goto out;
 115                 }
 116
 117                 if (!current_rng) {
 118                         err = -ENODEV;
 119                         goto out_unlock;
 120                 }
 121
 122                 if (!data_avail) {
 123                         bytes_read = rng_get_data(current_rng, rng_buffer,
 124                                 rng_buffer_size(),
 125                                 !(filp->f_flags & O_NONBLOCK));
 126                         if (bytes_read < 0) {
 127                                 err = bytes_read;
 128                                 goto out_unlock;
 129                         }
 130                         data_avail = bytes_read;
 131                 }
 132
 133                 if (!data_avail) {
 134                         if (filp->f_flags & O_NONBLOCK) {
 135                                 err = -EAGAIN;
 136                                 goto out_unlock;
 137                         }
 138                 } else {
 139                         len = data_avail;
 140                         if (len > size)
 141                                 len = size;
 142
 143                         data_avail -= len;
 144
 145                         if (copy_to_user(buf + ret, rng_buffer + data_avail,
 146                                                                 len)) {
 147                                 err = -EFAULT;
 148                                 goto out_unlock;
 149                         }
 150
 151                         size -= len;
 152                         ret += len;
 153                 }
 154
 155                 mutex_unlock(&rng_mutex);
 156
 157                 if (need_resched())
 158                         schedule_timeout_interruptible(1);
 159
 160                 if (signal_pending(current)) {
 161                         err = -ERESTARTSYS;
 162                         goto out;
 163                 }
 164         }
 165 out:
 166         return ret ? : err;
 167 out_unlock:
 168         mutex_unlock(&rng_mutex);
 169         goto out;
 170 }
 171
 172
 173 static const struct file_operations rng_chrdev_ops = {
 174         .owner          = THIS_MODULE,
 175         .open           = rng_dev_open,
 176         .read           = rng_dev_read,
 177         .llseek         = noop_llseek,
 178 };
 179
 180 static struct miscdevice rng_miscdev = {
 181         .minor          = RNG_MISCDEV_MINOR,
 182         .name           = RNG_MODULE_NAME,
 183         .nodename       = "hwrng",
 184         .fops           = &rng_chrdev_ops,
 185 };
 186
 187
 188 static ssize_t hwrng_attr_current_store(struct device *dev,
 189                                         struct device_attribute *attr,
 190                                         const char *buf, size_t len)
 191 {
 192         int err;
 193         struct hwrng *rng;
 194
 195         err = mutex_lock_interruptible(&rng_mutex);
 196         if (err)
 197                 return -ERESTARTSYS;
 198         err = -ENODEV;
 199         list_for_each_entry(rng, &rng_list, list) {
 200                 if (strcmp(rng->name, buf) == 0) {
 201                         if (rng == current_rng) {
 202                                 err = 0;
 203                                 break;
 204                         }
 205                         err = hwrng_init(rng);
 206                         if (err)
 207                                 break;
 208                         hwrng_cleanup(current_rng);
 209                         current_rng = rng;
 210                         err = 0;
 211                         break;
 212                 }
 213         }
 214         mutex_unlock(&rng_mutex);
 215
 216         return err ? : len;
 217 }
 218
 219 static ssize_t hwrng_attr_current_show(struct device *dev,
 220                                        struct device_attribute *attr,
 221                                        char *buf)
 222 {
 223         int err;
 224         ssize_t ret;
 225         const char *name = "none";
 226
 227         err = mutex_lock_interruptible(&rng_mutex);
 228         if (err)
 229                 return -ERESTARTSYS;
 230         if (current_rng)
 231                 name = current_rng->name;
 232         ret = snprintf(buf, PAGE_SIZE, "%s\n", name);
 233         mutex_unlock(&rng_mutex);
 234
 235         return ret;
 236 }
 237
 238 static ssize_t hwrng_attr_available_show(struct device *dev,
 239                                          struct device_attribute *attr,
 240                                          char *buf)
 241 {
 242         int err;
 243         ssize_t ret = 0;
 244         struct hwrng *rng;
 245
 246         err = mutex_lock_interruptible(&rng_mutex);
 247         if (err)
 248                 return -ERESTARTSYS;
 249         buf[0] = '\0';
 250         list_for_each_entry(rng, &rng_list, list) {
 251                 strncat(buf, rng->name, PAGE_SIZE - ret - 1);
 252                 ret += strlen(rng->name);
 253                 strncat(buf, " ", PAGE_SIZE - ret - 1);
 254                 ret++;
 255         }
 256         strncat(buf, "\n", PAGE_SIZE - ret - 1);
 257         ret++;
 258         mutex_unlock(&rng_mutex);
 259
 260         return ret;
 261 }
 262
 263 static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
 264                    hwrng_attr_current_show,
 265                    hwrng_attr_current_store);
 266 static DEVICE_ATTR(rng_available, S_IRUGO,
 267                    hwrng_attr_available_show,
 268                    NULL);
 269
 270
 271 static void unregister_miscdev(void)
 272 {
 273         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_available);
 274         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
 275         misc_deregister(&rng_miscdev);
 276 }
 277
 278 static int register_miscdev(void)
 279 {
 280         int err;
 281
 282         err = misc_register(&rng_miscdev);
 283         if (err)
 284                 goto out;
 285         err = device_create_file(rng_miscdev.this_device,
 286                                  &dev_attr_rng_current);
 287         if (err)
 288                 goto err_misc_dereg;
 289         err = device_create_file(rng_miscdev.this_device,
 290                                  &dev_attr_rng_available);
 291         if (err)
 292                 goto err_remove_current;
 293 out:
 294         return err;
 295
 296 err_remove_current:
 297         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
 298 err_misc_dereg:
 299         misc_deregister(&rng_miscdev);
 300         goto out;
 301 }
 302
 303 int hwrng_register(struct hwrng *rng)
 304 {
 305         int err = -EINVAL;
 306         struct hwrng *old_rng, *tmp;
 307         unsigned char bytes[16];
 308         int bytes_read;
 309
 310         if (rng->name == NULL ||
 311             (rng->data_read == NULL && rng->read == NULL))
 312                 goto out;
 313
 314         mutex_lock(&rng_mutex);
 315
 316         /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */
 317         err = -ENOMEM;
 318         if (!rng_buffer) {
 319                 rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL);
 320                 if (!rng_buffer)
 321                         goto out_unlock;
 322         }
 323
 324         /* Must not register two RNGs with the same name. */
 325         err = -EEXIST;
 326         list_for_each_entry(tmp, &rng_list, list) {
 327                 if (strcmp(tmp->name, rng->name) == 0)
 328                         goto out_unlock;
 329         }
 330
 331         old_rng = current_rng;
 332         if (!old_rng) {
 333                 err = hwrng_init(rng);
 334                 if (err)
 335                         goto out_unlock;
 336                 current_rng = rng;
 337         }
 338         err = 0;
 339         if (!old_rng) {
 340                 err = register_miscdev();
 341                 if (err) {
 342                         hwrng_cleanup(rng);
 343                         current_rng = NULL;
 344                         goto out_unlock;
 345                 }
 346         }
 347         INIT_LIST_HEAD(&rng->list);
 348         list_add_tail(&rng->list, &rng_list);
 349
 350         bytes_read = rng_get_data(rng, bytes, sizeof(bytes), 1);
 351         if (bytes_read > 0)
 352                 add_device_randomness(bytes, bytes_read);
 353 out_unlock:
 354         mutex_unlock(&rng_mutex);
 355 out:
 356         return err;
 357 }
 358 EXPORT_SYMBOL_GPL(hwrng_register);
 359
 360 void hwrng_unregister(struct hwrng *rng)
 361 {
 362         int err;
 363
 364         mutex_lock(&rng_mutex);
 365
 366         list_del(&rng->list);
 367         if (current_rng == rng) {
 368                 hwrng_cleanup(rng);
 369                 if (list_empty(&rng_list)) {
 370                         current_rng = NULL;
 371                 } else {
 372                         current_rng = list_entry(rng_list.prev, struct hwrng, list);
 373                         err = hwrng_init(current_rng);
 374                         if (err)
 375                                 current_rng = NULL;
 376                 }
 377         }
 378         if (list_empty(&rng_list))
 379                 unregister_miscdev();
 380
 381         mutex_unlock(&rng_mutex);
 382 }
 383 EXPORT_SYMBOL_GPL(hwrng_unregister);
 384
 385 static void __exit hwrng_exit(void)
 386 {
 387         mutex_lock(&rng_mutex);
 388         BUG_ON(current_rng);
 389         kfree(rng_buffer);
 390         mutex_unlock(&rng_mutex);
 391 }
 392
 393 module_exit(hwrng_exit);
 394
 395 MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
 396 MODULE_LICENSE("GPL");