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/kthread.h>
  42 #include <linux/delay.h>
  43 #include <linux/slab.h>
  44 #include <linux/random.h>
  45 #include <linux/err.h>
  46 #include <asm/uaccess.h>
  47
  48
  49 #define RNG_MODULE_NAME         "hw_random"
  50 #define PFX                     RNG_MODULE_NAME ": "
  51 #define RNG_MISCDEV_MINOR       183 /* official */
  52
  53
  54 static struct hwrng *current_rng;
  55 static struct task_struct *hwrng_fill;
  56 static LIST_HEAD(rng_list);
  57 /* Protects rng_list and current_rng */
  58 static DEFINE_MUTEX(rng_mutex);
  59 /* Protects rng read functions, data_avail, rng_buffer and rng_fillbuf */
  60 static DEFINE_MUTEX(reading_mutex);
  61 static int data_avail;
  62 static u8 *rng_buffer, *rng_fillbuf;
  63 static unsigned short current_quality;
  64 static unsigned short default_quality; /* = 0; default to "off" */
  65
  66 module_param(current_quality, ushort, 0644);
  67 MODULE_PARM_DESC(current_quality,
  68                  "current hwrng entropy estimation per mill");
  69 module_param(default_quality, ushort, 0644);
  70 MODULE_PARM_DESC(default_quality,
  71                  "default entropy content of hwrng per mill");
  72
  73 static void start_khwrngd(void);
  74
  75 static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
  76                                int wait);
  77
  78 static size_t rng_buffer_size(void)
  79 {
  80         return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES;
  81 }
  82
  83 static void add_early_randomness(struct hwrng *rng)
  84 {
  85         unsigned char bytes[16];
  86         int bytes_read;
  87
  88         mutex_lock(&reading_mutex);
  89         bytes_read = rng_get_data(rng, bytes, sizeof(bytes), 1);
  90         mutex_unlock(&reading_mutex);
  91         if (bytes_read > 0)
  92                 add_device_randomness(bytes, bytes_read);
  93 }
  94
  95 static inline void cleanup_rng(struct kref *kref)
  96 {
  97         struct hwrng *rng = container_of(kref, struct hwrng, ref);
  98
  99         if (rng->cleanup)
 100                 rng->cleanup(rng);
 101
 102         complete(&rng->cleanup_done);
 103 }
 104
 105 static void set_current_rng(struct hwrng *rng)
 106 {
 107         BUG_ON(!mutex_is_locked(&rng_mutex));
 108         kref_get(&rng->ref);
 109         current_rng = rng;
 110 }
 111
 112 static void drop_current_rng(void)
 113 {
 114         BUG_ON(!mutex_is_locked(&rng_mutex));
 115         if (!current_rng)
 116                 return;
 117
 118         /* decrease last reference for triggering the cleanup */
 119         kref_put(&current_rng->ref, cleanup_rng);
 120         current_rng = NULL;
 121 }
 122
 123 /* Returns ERR_PTR(), NULL or refcounted hwrng */
 124 static struct hwrng *get_current_rng(void)
 125 {
 126         struct hwrng *rng;
 127
 128         if (mutex_lock_interruptible(&rng_mutex))
 129                 return ERR_PTR(-ERESTARTSYS);
 130
 131         rng = current_rng;
 132         if (rng)
 133                 kref_get(&rng->ref);
 134
 135         mutex_unlock(&rng_mutex);
 136         return rng;
 137 }
 138
 139 static void put_rng(struct hwrng *rng)
 140 {
 141         /*
 142          * Hold rng_mutex here so we serialize in case they set_current_rng
 143          * on rng again immediately.
 144          */
 145         mutex_lock(&rng_mutex);
 146         if (rng)
 147                 kref_put(&rng->ref, cleanup_rng);
 148         mutex_unlock(&rng_mutex);
 149 }
 150
 151 static inline int hwrng_init(struct hwrng *rng)
 152 {
 153         if (rng->init) {
 154                 int ret;
 155
 156                 ret =  rng->init(rng);
 157                 if (ret)
 158                         return ret;
 159         }
 160         add_early_randomness(rng);
 161
 162         current_quality = rng->quality ? : default_quality;
 163         current_quality &= 1023;
 164
 165         if (current_quality == 0 && hwrng_fill)
 166                 kthread_stop(hwrng_fill);
 167         if (current_quality > 0 && !hwrng_fill)
 168                 start_khwrngd();
 169
 170         return 0;
 171 }
 172
 173 static int rng_dev_open(struct inode *inode, struct file *filp)
 174 {
 175         /* enforce read-only access to this chrdev */
 176         if ((filp->f_mode & FMODE_READ) == 0)
 177                 return -EINVAL;
 178         if (filp->f_mode & FMODE_WRITE)
 179                 return -EINVAL;
 180         return 0;
 181 }
 182
 183 static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
 184                         int wait) {
 185         int present;
 186
 187         BUG_ON(!mutex_is_locked(&reading_mutex));
 188         if (rng->read)
 189                 return rng->read(rng, (void *)buffer, size, wait);
 190
 191         if (rng->data_present)
 192                 present = rng->data_present(rng, wait);
 193         else
 194                 present = 1;
 195
 196         if (present)
 197                 return rng->data_read(rng, (u32 *)buffer);
 198
 199         return 0;
 200 }
 201
 202 static ssize_t rng_dev_read(struct file *filp, char __user *buf,
 203                             size_t size, loff_t *offp)
 204 {
 205         ssize_t ret = 0;
 206         int err = 0;
 207         int bytes_read, len;
 208         struct hwrng *rng;
 209
 210         while (size) {
 211                 rng = get_current_rng();
 212                 if (IS_ERR(rng)) {
 213                         err = PTR_ERR(rng);
 214                         goto out;
 215                 }
 216                 if (!rng) {
 217                         err = -ENODEV;
 218                         goto out;
 219                 }
 220
 221                 mutex_lock(&reading_mutex);
 222                 if (!data_avail) {
 223                         bytes_read = rng_get_data(rng, rng_buffer,
 224                                 rng_buffer_size(),
 225                                 !(filp->f_flags & O_NONBLOCK));
 226                         if (bytes_read < 0) {
 227                                 err = bytes_read;
 228                                 goto out_unlock_reading;
 229                         }
 230                         data_avail = bytes_read;
 231                 }
 232
 233                 if (!data_avail) {
 234                         if (filp->f_flags & O_NONBLOCK) {
 235                                 err = -EAGAIN;
 236                                 goto out_unlock_reading;
 237                         }
 238                 } else {
 239                         len = data_avail;
 240                         if (len > size)
 241                                 len = size;
 242
 243                         data_avail -= len;
 244
 245                         if (copy_to_user(buf + ret, rng_buffer + data_avail,
 246                                                                 len)) {
 247                                 err = -EFAULT;
 248                                 goto out_unlock_reading;
 249                         }
 250
 251                         size -= len;
 252                         ret += len;
 253                 }
 254
 255                 mutex_unlock(&reading_mutex);
 256                 put_rng(rng);
 257
 258                 if (need_resched())
 259                         schedule_timeout_interruptible(1);
 260
 261                 if (signal_pending(current)) {
 262                         err = -ERESTARTSYS;
 263                         goto out;
 264                 }
 265         }
 266 out:
 267         return ret ? : err;
 268
 269 out_unlock_reading:
 270         mutex_unlock(&reading_mutex);
 271         put_rng(rng);
 272         goto out;
 273 }
 274
 275
 276 static const struct file_operations rng_chrdev_ops = {
 277         .owner          = THIS_MODULE,
 278         .open           = rng_dev_open,
 279         .read           = rng_dev_read,
 280         .llseek         = noop_llseek,
 281 };
 282
 283 static struct miscdevice rng_miscdev = {
 284         .minor          = RNG_MISCDEV_MINOR,
 285         .name           = RNG_MODULE_NAME,
 286         .nodename       = "hwrng",
 287         .fops           = &rng_chrdev_ops,
 288 };
 289
 290
 291 static ssize_t hwrng_attr_current_store(struct device *dev,
 292                                         struct device_attribute *attr,
 293                                         const char *buf, size_t len)
 294 {
 295         int err;
 296         struct hwrng *rng;
 297
 298         err = mutex_lock_interruptible(&rng_mutex);
 299         if (err)
 300                 return -ERESTARTSYS;
 301         err = -ENODEV;
 302         list_for_each_entry(rng, &rng_list, list) {
 303                 if (strcmp(rng->name, buf) == 0) {
 304                         if (rng == current_rng) {
 305                                 err = 0;
 306                                 break;
 307                         }
 308                         err = hwrng_init(rng);
 309                         if (err)
 310                                 break;
 311                         drop_current_rng();
 312                         set_current_rng(rng);
 313                         err = 0;
 314                         break;
 315                 }
 316         }
 317         mutex_unlock(&rng_mutex);
 318
 319         return err ? : len;
 320 }
 321
 322 static ssize_t hwrng_attr_current_show(struct device *dev,
 323                                        struct device_attribute *attr,
 324                                        char *buf)
 325 {
 326         ssize_t ret;
 327         struct hwrng *rng;
 328
 329         rng = get_current_rng();
 330         if (IS_ERR(rng))
 331                 return PTR_ERR(rng);
 332
 333         ret = snprintf(buf, PAGE_SIZE, "%s\n", rng ? rng->name : "none");
 334         put_rng(rng);
 335
 336         return ret;
 337 }
 338
 339 static ssize_t hwrng_attr_available_show(struct device *dev,
 340                                          struct device_attribute *attr,
 341                                          char *buf)
 342 {
 343         int err;
 344         struct hwrng *rng;
 345
 346         err = mutex_lock_interruptible(&rng_mutex);
 347         if (err)
 348                 return -ERESTARTSYS;
 349         buf[0] = '\0';
 350         list_for_each_entry(rng, &rng_list, list) {
 351                 strlcat(buf, rng->name, PAGE_SIZE);
 352                 strlcat(buf, " ", PAGE_SIZE);
 353         }
 354         strlcat(buf, "\n", PAGE_SIZE);
 355         mutex_unlock(&rng_mutex);
 356
 357         return strlen(buf);
 358 }
 359
 360 static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
 361                    hwrng_attr_current_show,
 362                    hwrng_attr_current_store);
 363 static DEVICE_ATTR(rng_available, S_IRUGO,
 364                    hwrng_attr_available_show,
 365                    NULL);
 366
 367
 368 static void unregister_miscdev(void)
 369 {
 370         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_available);
 371         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
 372         misc_deregister(&rng_miscdev);
 373 }
 374
 375 static int register_miscdev(void)
 376 {
 377         int err;
 378
 379         err = misc_register(&rng_miscdev);
 380         if (err)
 381                 goto out;
 382         err = device_create_file(rng_miscdev.this_device,
 383                                  &dev_attr_rng_current);
 384         if (err)
 385                 goto err_misc_dereg;
 386         err = device_create_file(rng_miscdev.this_device,
 387                                  &dev_attr_rng_available);
 388         if (err)
 389                 goto err_remove_current;
 390 out:
 391         return err;
 392
 393 err_remove_current:
 394         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
 395 err_misc_dereg:
 396         misc_deregister(&rng_miscdev);
 397         goto out;
 398 }
 399
 400 static int hwrng_fillfn(void *unused)
 401 {
 402         long rc;
 403
 404         while (!kthread_should_stop()) {
 405                 struct hwrng *rng;
 406
 407                 rng = get_current_rng();
 408                 if (IS_ERR(rng) || !rng)
 409                         break;
 410                 mutex_lock(&reading_mutex);
 411                 rc = rng_get_data(rng, rng_fillbuf,
 412                                   rng_buffer_size(), 1);
 413                 mutex_unlock(&reading_mutex);
 414                 put_rng(rng);
 415                 if (rc <= 0) {
 416                         pr_warn("hwrng: no data available\n");
 417                         msleep_interruptible(10000);
 418                         continue;
 419                 }
 420                 /* Outside lock, sure, but y'know: randomness. */
 421                 add_hwgenerator_randomness((void *)rng_fillbuf, rc,
 422                                            rc * current_quality * 8 >> 10);
 423         }
 424         hwrng_fill = NULL;
 425         return 0;
 426 }
 427
 428 static void start_khwrngd(void)
 429 {
 430         hwrng_fill = kthread_run(hwrng_fillfn, NULL, "hwrng");
 431         if (hwrng_fill == ERR_PTR(-ENOMEM)) {
 432                 pr_err("hwrng_fill thread creation failed");
 433                 hwrng_fill = NULL;
 434         }
 435 }
 436
 437 int hwrng_register(struct hwrng *rng)
 438 {
 439         int err = -EINVAL;
 440         struct hwrng *old_rng, *tmp;
 441
 442         if (rng->name == NULL ||
 443             (rng->data_read == NULL && rng->read == NULL))
 444                 goto out;
 445
 446         mutex_lock(&rng_mutex);
 447
 448         /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */
 449         err = -ENOMEM;
 450         if (!rng_buffer) {
 451                 rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL);
 452                 if (!rng_buffer)
 453                         goto out_unlock;
 454         }
 455         if (!rng_fillbuf) {
 456                 rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL);
 457                 if (!rng_fillbuf) {
 458                         kfree(rng_buffer);
 459                         goto out_unlock;
 460                 }
 461         }
 462
 463         /* Must not register two RNGs with the same name. */
 464         err = -EEXIST;
 465         list_for_each_entry(tmp, &rng_list, list) {
 466                 if (strcmp(tmp->name, rng->name) == 0)
 467                         goto out_unlock;
 468         }
 469
 470         old_rng = current_rng;
 471         err = 0;
 472         if (!old_rng) {
 473                 err = hwrng_init(rng);
 474                 if (err)
 475                         goto out_unlock;
 476                 set_current_rng(rng);
 477
 478                 err = register_miscdev();
 479                 if (err) {
 480                         drop_current_rng();
 481                         goto out_unlock;
 482                 }
 483         }
 484         list_add_tail(&rng->list, &rng_list);
 485
 486         if (old_rng && !rng->init) {
 487                 /*
 488                  * Use a new device's input to add some randomness to
 489                  * the system.  If this rng device isn't going to be
 490                  * used right away, its init function hasn't been
 491                  * called yet; so only use the randomness from devices
 492                  * that don't need an init callback.
 493                  */
 494                 add_early_randomness(rng);
 495         }
 496
 497         init_completion(&rng->cleanup_done);
 498
 499 out_unlock:
 500         mutex_unlock(&rng_mutex);
 501 out:
 502         return err;
 503 }
 504 EXPORT_SYMBOL_GPL(hwrng_register);
 505
 506 void hwrng_unregister(struct hwrng *rng)
 507 {
 508         mutex_lock(&rng_mutex);
 509
 510         list_del(&rng->list);
 511         if (current_rng == rng) {
 512                 drop_current_rng();
 513                 if (!list_empty(&rng_list)) {
 514                         struct hwrng *tail;
 515
 516                         tail = list_entry(rng_list.prev, struct hwrng, list);
 517
 518                         if (hwrng_init(tail) == 0)
 519                                 set_current_rng(tail);
 520                 }
 521         }
 522
 523         if (list_empty(&rng_list)) {
 524                 mutex_unlock(&rng_mutex);
 525                 unregister_miscdev();
 526                 if (hwrng_fill)
 527                         kthread_stop(hwrng_fill);
 528         } else
 529                 mutex_unlock(&rng_mutex);
 530
 531         wait_for_completion(&rng->cleanup_done);
 532 }
 533 EXPORT_SYMBOL_GPL(hwrng_unregister);
 534
 535 static void __exit hwrng_exit(void)
 536 {
 537         mutex_lock(&rng_mutex);
 538         BUG_ON(current_rng);
 539         kfree(rng_buffer);
 540         kfree(rng_fillbuf);
 541         mutex_unlock(&rng_mutex);
 542 }
 543
 544 module_exit(hwrng_exit);
 545
 546 MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
 547 MODULE_LICENSE("GPL");