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 inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
  59                                int wait);
  60
  61 static size_t rng_buffer_size(void)
  62 {
  63         return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES;
  64 }
  65
  66 static void add_early_randomness(struct hwrng *rng)
  67 {
  68         unsigned char bytes[16];
  69         int bytes_read;
  70
  71         bytes_read = rng_get_data(rng, bytes, sizeof(bytes), 1);
  72         if (bytes_read > 0)
  73                 add_device_randomness(bytes, bytes_read);
  74 }
  75
  76 static inline int hwrng_init(struct hwrng *rng)
  77 {
  78         if (rng->init) {
  79                 int ret;
  80
  81                 ret =  rng->init(rng);
  82                 if (ret)
  83                         return ret;
  84         }
  85         add_early_randomness(rng);
  86         return 0;
  87 }
  88
  89 static inline void hwrng_cleanup(struct hwrng *rng)
  90 {
  91         if (rng && rng->cleanup)
  92                 rng->cleanup(rng);
  93 }
  94
  95 static int rng_dev_open(struct inode *inode, struct file *filp)
  96 {
  97         /* enforce read-only access to this chrdev */
  98         if ((filp->f_mode & FMODE_READ) == 0)
  99                 return -EINVAL;
 100         if (filp->f_mode & FMODE_WRITE)
 101                 return -EINVAL;
 102         return 0;
 103 }
 104
 105 static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
 106                         int wait) {
 107         int present;
 108
 109         if (rng->read)
 110                 return rng->read(rng, (void *)buffer, size, wait);
 111
 112         if (rng->data_present)
 113                 present = rng->data_present(rng, wait);
 114         else
 115                 present = 1;
 116
 117         if (present)
 118                 return rng->data_read(rng, (u32 *)buffer);
 119
 120         return 0;
 121 }
 122
 123 static ssize_t rng_dev_read(struct file *filp, char __user *buf,
 124                             size_t size, loff_t *offp)
 125 {
 126         ssize_t ret = 0;
 127         int err = 0;
 128         int bytes_read, len;
 129
 130         while (size) {
 131                 if (mutex_lock_interruptible(&rng_mutex)) {
 132                         err = -ERESTARTSYS;
 133                         goto out;
 134                 }
 135
 136                 if (!current_rng) {
 137                         err = -ENODEV;
 138                         goto out_unlock;
 139                 }
 140
 141                 if (!data_avail) {
 142                         bytes_read = rng_get_data(current_rng, rng_buffer,
 143                                 rng_buffer_size(),
 144                                 !(filp->f_flags & O_NONBLOCK));
 145                         if (bytes_read < 0) {
 146                                 err = bytes_read;
 147                                 goto out_unlock;
 148                         }
 149                         data_avail = bytes_read;
 150                 }
 151
 152                 if (!data_avail) {
 153                         if (filp->f_flags & O_NONBLOCK) {
 154                                 err = -EAGAIN;
 155                                 goto out_unlock;
 156                         }
 157                 } else {
 158                         len = data_avail;
 159                         if (len > size)
 160                                 len = size;
 161
 162                         data_avail -= len;
 163
 164                         if (copy_to_user(buf + ret, rng_buffer + data_avail,
 165                                                                 len)) {
 166                                 err = -EFAULT;
 167                                 goto out_unlock;
 168                         }
 169
 170                         size -= len;
 171                         ret += len;
 172                 }
 173
 174                 mutex_unlock(&rng_mutex);
 175
 176                 if (need_resched())
 177                         schedule_timeout_interruptible(1);
 178
 179                 if (signal_pending(current)) {
 180                         err = -ERESTARTSYS;
 181                         goto out;
 182                 }
 183         }
 184 out:
 185         return ret ? : err;
 186 out_unlock:
 187         mutex_unlock(&rng_mutex);
 188         goto out;
 189 }
 190
 191
 192 static const struct file_operations rng_chrdev_ops = {
 193         .owner          = THIS_MODULE,
 194         .open           = rng_dev_open,
 195         .read           = rng_dev_read,
 196         .llseek         = noop_llseek,
 197 };
 198
 199 static struct miscdevice rng_miscdev = {
 200         .minor          = RNG_MISCDEV_MINOR,
 201         .name           = RNG_MODULE_NAME,
 202         .nodename       = "hwrng",
 203         .fops           = &rng_chrdev_ops,
 204 };
 205
 206
 207 static ssize_t hwrng_attr_current_store(struct device *dev,
 208                                         struct device_attribute *attr,
 209                                         const char *buf, size_t len)
 210 {
 211         int err;
 212         struct hwrng *rng;
 213
 214         err = mutex_lock_interruptible(&rng_mutex);
 215         if (err)
 216                 return -ERESTARTSYS;
 217         err = -ENODEV;
 218         list_for_each_entry(rng, &rng_list, list) {
 219                 if (strcmp(rng->name, buf) == 0) {
 220                         if (rng == current_rng) {
 221                                 err = 0;
 222                                 break;
 223                         }
 224                         err = hwrng_init(rng);
 225                         if (err)
 226                                 break;
 227                         hwrng_cleanup(current_rng);
 228                         current_rng = rng;
 229                         err = 0;
 230                         break;
 231                 }
 232         }
 233         mutex_unlock(&rng_mutex);
 234
 235         return err ? : len;
 236 }
 237
 238 static ssize_t hwrng_attr_current_show(struct device *dev,
 239                                        struct device_attribute *attr,
 240                                        char *buf)
 241 {
 242         int err;
 243         ssize_t ret;
 244         const char *name = "none";
 245
 246         err = mutex_lock_interruptible(&rng_mutex);
 247         if (err)
 248                 return -ERESTARTSYS;
 249         if (current_rng)
 250                 name = current_rng->name;
 251         ret = snprintf(buf, PAGE_SIZE, "%s\n", name);
 252         mutex_unlock(&rng_mutex);
 253
 254         return ret;
 255 }
 256
 257 static ssize_t hwrng_attr_available_show(struct device *dev,
 258                                          struct device_attribute *attr,
 259                                          char *buf)
 260 {
 261         int err;
 262         ssize_t ret = 0;
 263         struct hwrng *rng;
 264
 265         err = mutex_lock_interruptible(&rng_mutex);
 266         if (err)
 267                 return -ERESTARTSYS;
 268         buf[0] = '\0';
 269         list_for_each_entry(rng, &rng_list, list) {
 270                 strncat(buf, rng->name, PAGE_SIZE - ret - 1);
 271                 ret += strlen(rng->name);
 272                 strncat(buf, " ", PAGE_SIZE - ret - 1);
 273                 ret++;
 274         }
 275         strncat(buf, "\n", PAGE_SIZE - ret - 1);
 276         ret++;
 277         mutex_unlock(&rng_mutex);
 278
 279         return ret;
 280 }
 281
 282 static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
 283                    hwrng_attr_current_show,
 284                    hwrng_attr_current_store);
 285 static DEVICE_ATTR(rng_available, S_IRUGO,
 286                    hwrng_attr_available_show,
 287                    NULL);
 288
 289
 290 static void unregister_miscdev(void)
 291 {
 292         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_available);
 293         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
 294         misc_deregister(&rng_miscdev);
 295 }
 296
 297 static int register_miscdev(void)
 298 {
 299         int err;
 300
 301         err = misc_register(&rng_miscdev);
 302         if (err)
 303                 goto out;
 304         err = device_create_file(rng_miscdev.this_device,
 305                                  &dev_attr_rng_current);
 306         if (err)
 307                 goto err_misc_dereg;
 308         err = device_create_file(rng_miscdev.this_device,
 309                                  &dev_attr_rng_available);
 310         if (err)
 311                 goto err_remove_current;
 312 out:
 313         return err;
 314
 315 err_remove_current:
 316         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
 317 err_misc_dereg:
 318         misc_deregister(&rng_miscdev);
 319         goto out;
 320 }
 321
 322 int hwrng_register(struct hwrng *rng)
 323 {
 324         int err = -EINVAL;
 325         struct hwrng *old_rng, *tmp;
 326
 327         if (rng->name == NULL ||
 328             (rng->data_read == NULL && rng->read == NULL))
 329                 goto out;
 330
 331         mutex_lock(&rng_mutex);
 332
 333         /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */
 334         err = -ENOMEM;
 335         if (!rng_buffer) {
 336                 rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL);
 337                 if (!rng_buffer)
 338                         goto out_unlock;
 339         }
 340
 341         /* Must not register two RNGs with the same name. */
 342         err = -EEXIST;
 343         list_for_each_entry(tmp, &rng_list, list) {
 344                 if (strcmp(tmp->name, rng->name) == 0)
 345                         goto out_unlock;
 346         }
 347
 348         old_rng = current_rng;
 349         if (!old_rng) {
 350                 err = hwrng_init(rng);
 351                 if (err)
 352                         goto out_unlock;
 353                 current_rng = rng;
 354         }
 355         err = 0;
 356         if (!old_rng) {
 357                 err = register_miscdev();
 358                 if (err) {
 359                         hwrng_cleanup(rng);
 360                         current_rng = NULL;
 361                         goto out_unlock;
 362                 }
 363         }
 364         INIT_LIST_HEAD(&rng->list);
 365         list_add_tail(&rng->list, &rng_list);
 366
 367         if (old_rng && !rng->init) {
 368                 /*
 369                  * Use a new device's input to add some randomness to
 370                  * the system.  If this rng device isn't going to be
 371                  * used right away, its init function hasn't been
 372                  * called yet; so only use the randomness from devices
 373                  * that don't need an init callback.
 374                  */
 375                 add_early_randomness(rng);
 376         }
 377
 378 out_unlock:
 379         mutex_unlock(&rng_mutex);
 380 out:
 381         return err;
 382 }
 383 EXPORT_SYMBOL_GPL(hwrng_register);
 384
 385 void hwrng_unregister(struct hwrng *rng)
 386 {
 387         int err;
 388
 389         mutex_lock(&rng_mutex);
 390
 391         list_del(&rng->list);
 392         if (current_rng == rng) {
 393                 hwrng_cleanup(rng);
 394                 if (list_empty(&rng_list)) {
 395                         current_rng = NULL;
 396                 } else {
 397                         current_rng = list_entry(rng_list.prev, struct hwrng, list);
 398                         err = hwrng_init(current_rng);
 399                         if (err)
 400                                 current_rng = NULL;
 401                 }
 402         }
 403         if (list_empty(&rng_list))
 404                 unregister_miscdev();
 405
 406         mutex_unlock(&rng_mutex);
 407 }
 408 EXPORT_SYMBOL_GPL(hwrng_unregister);
 409
 410 static void __exit hwrng_exit(void)
 411 {
 412         mutex_lock(&rng_mutex);
 413         BUG_ON(current_rng);
 414         kfree(rng_buffer);
 415         mutex_unlock(&rng_mutex);
 416 }
 417
 418 module_exit(hwrng_exit);
 419
 420 MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
 421 MODULE_LICENSE("GPL");