drivers/char/hw_random/core.c

   1 /*
   2  * hw_random/core.c: HWRNG core API
   3  *
   4  * Copyright 2006 Michael Buesch <m@bues.ch>
   5  * Copyright 2005 (c) MontaVista Software, Inc.
   6  *
   7  * Please read Documentation/admin-guide/hw_random.rst for details on use.
   8  *
   9  * This software may be used and distributed according to the terms
  10  * of the GNU General Public License, incorporated herein by reference.
  11  */
  12
  13 #include <linux/delay.h>
  14 #include <linux/device.h>
  15 #include <linux/err.h>
  16 #include <linux/fs.h>
  17 #include <linux/hw_random.h>
  18 #include <linux/random.h>
  19 #include <linux/kernel.h>
  20 #include <linux/kthread.h>
  21 #include <linux/sched/signal.h>
  22 #include <linux/miscdevice.h>
  23 #include <linux/module.h>
  24 #include <linux/random.h>
  25 #include <linux/sched.h>
  26 #include <linux/slab.h>
  27 #include <linux/uaccess.h>
  28
  29 #define RNG_MODULE_NAME         "hw_random"
  30
  31 static struct hwrng *current_rng;
  32 /* the current rng has been explicitly chosen by user via sysfs */
  33 static int cur_rng_set_by_user;
  34 static struct task_struct *hwrng_fill;
  35 /* list of registered rngs, sorted decending by quality */
  36 static LIST_HEAD(rng_list);
  37 /* Protects rng_list and current_rng */
  38 static DEFINE_MUTEX(rng_mutex);
  39 /* Protects rng read functions, data_avail, rng_buffer and rng_fillbuf */
  40 static DEFINE_MUTEX(reading_mutex);
  41 static int data_avail;
  42 static u8 *rng_buffer, *rng_fillbuf;
  43 static unsigned short current_quality;
  44 static unsigned short default_quality; /* = 0; default to "off" */
  45
  46 module_param(current_quality, ushort, 0644);
  47 MODULE_PARM_DESC(current_quality,
  48                  "current hwrng entropy estimation per 1024 bits of input");
  49 module_param(default_quality, ushort, 0644);
  50 MODULE_PARM_DESC(default_quality,
  51                  "default entropy content of hwrng per 1024 bits of input");
  52
  53 static void drop_current_rng(void);
  54 static int hwrng_init(struct hwrng *rng);
  55 static void start_khwrngd(void);
  56
  57 static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
  58                                int wait);
  59
  60 static size_t rng_buffer_size(void)
  61 {
  62         return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES;
  63 }
  64
  65 static void add_early_randomness(struct hwrng *rng)
  66 {
  67         int bytes_read;
  68         size_t size = min_t(size_t, 16, rng_buffer_size());
  69
  70         mutex_lock(&reading_mutex);
  71         bytes_read = rng_get_data(rng, rng_buffer, size, 0);
  72         mutex_unlock(&reading_mutex);
  73         if (bytes_read > 0)
  74                 add_device_randomness(rng_buffer, bytes_read);
  75 }
  76
  77 static inline void cleanup_rng(struct kref *kref)
  78 {
  79         struct hwrng *rng = container_of(kref, struct hwrng, ref);
  80
  81         if (rng->cleanup)
  82                 rng->cleanup(rng);
  83
  84         complete(&rng->cleanup_done);
  85 }
  86
  87 static int set_current_rng(struct hwrng *rng)
  88 {
  89         int err;
  90
  91         BUG_ON(!mutex_is_locked(&rng_mutex));
  92
  93         err = hwrng_init(rng);
  94         if (err)
  95                 return err;
  96
  97         drop_current_rng();
  98         current_rng = rng;
  99
 100         return 0;
 101 }
 102
 103 static void drop_current_rng(void)
 104 {
 105         BUG_ON(!mutex_is_locked(&rng_mutex));
 106         if (!current_rng)
 107                 return;
 108
 109         /* decrease last reference for triggering the cleanup */
 110         kref_put(&current_rng->ref, cleanup_rng);
 111         current_rng = NULL;
 112 }
 113
 114 /* Returns ERR_PTR(), NULL or refcounted hwrng */
 115 static struct hwrng *get_current_rng_nolock(void)
 116 {
 117         if (current_rng)
 118                 kref_get(&current_rng->ref);
 119
 120         return current_rng;
 121 }
 122
 123 static struct hwrng *get_current_rng(void)
 124 {
 125         struct hwrng *rng;
 126
 127         if (mutex_lock_interruptible(&rng_mutex))
 128                 return ERR_PTR(-ERESTARTSYS);
 129
 130         rng = get_current_rng_nolock();
 131
 132         mutex_unlock(&rng_mutex);
 133         return rng;
 134 }
 135
 136 static void put_rng(struct hwrng *rng)
 137 {
 138         /*
 139          * Hold rng_mutex here so we serialize in case they set_current_rng
 140          * on rng again immediately.
 141          */
 142         mutex_lock(&rng_mutex);
 143         if (rng)
 144                 kref_put(&rng->ref, cleanup_rng);
 145         mutex_unlock(&rng_mutex);
 146 }
 147
 148 static int hwrng_init(struct hwrng *rng)
 149 {
 150         if (kref_get_unless_zero(&rng->ref))
 151                 goto skip_init;
 152
 153         if (rng->init) {
 154                 int ret;
 155
 156                 ret =  rng->init(rng);
 157                 if (ret)
 158                         return ret;
 159         }
 160
 161         kref_init(&rng->ref);
 162         reinit_completion(&rng->cleanup_done);
 163
 164 skip_init:
 165         current_quality = rng->quality ? : default_quality;
 166         if (current_quality > 1024)
 167                 current_quality = 1024;
 168
 169         if (current_quality == 0 && hwrng_fill)
 170                 kthread_stop(hwrng_fill);
 171         if (current_quality > 0 && !hwrng_fill)
 172                 start_khwrngd();
 173
 174         return 0;
 175 }
 176
 177 static int rng_dev_open(struct inode *inode, struct file *filp)
 178 {
 179         /* enforce read-only access to this chrdev */
 180         if ((filp->f_mode & FMODE_READ) == 0)
 181                 return -EINVAL;
 182         if (filp->f_mode & FMODE_WRITE)
 183                 return -EINVAL;
 184         return 0;
 185 }
 186
 187 static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
 188                         int wait) {
 189         int present;
 190
 191         BUG_ON(!mutex_is_locked(&reading_mutex));
 192         if (rng->read)
 193                 return rng->read(rng, (void *)buffer, size, wait);
 194
 195         if (rng->data_present)
 196                 present = rng->data_present(rng, wait);
 197         else
 198                 present = 1;
 199
 200         if (present)
 201                 return rng->data_read(rng, (u32 *)buffer);
 202
 203         return 0;
 204 }
 205
 206 static ssize_t rng_dev_read(struct file *filp, char __user *buf,
 207                             size_t size, loff_t *offp)
 208 {
 209         ssize_t ret = 0;
 210         int err = 0;
 211         int bytes_read, len;
 212         struct hwrng *rng;
 213
 214         while (size) {
 215                 rng = get_current_rng();
 216                 if (IS_ERR(rng)) {
 217                         err = PTR_ERR(rng);
 218                         goto out;
 219                 }
 220                 if (!rng) {
 221                         err = -ENODEV;
 222                         goto out;
 223                 }
 224
 225                 if (mutex_lock_interruptible(&reading_mutex)) {
 226                         err = -ERESTARTSYS;
 227                         goto out_put;
 228                 }
 229                 if (!data_avail) {
 230                         bytes_read = rng_get_data(rng, rng_buffer,
 231                                 rng_buffer_size(),
 232                                 !(filp->f_flags & O_NONBLOCK));
 233                         if (bytes_read < 0) {
 234                                 err = bytes_read;
 235                                 goto out_unlock_reading;
 236                         }
 237                         data_avail = bytes_read;
 238                 }
 239
 240                 if (!data_avail) {
 241                         if (filp->f_flags & O_NONBLOCK) {
 242                                 err = -EAGAIN;
 243                                 goto out_unlock_reading;
 244                         }
 245                 } else {
 246                         len = data_avail;
 247                         if (len > size)
 248                                 len = size;
 249
 250                         data_avail -= len;
 251
 252                         if (copy_to_user(buf + ret, rng_buffer + data_avail,
 253                                                                 len)) {
 254                                 err = -EFAULT;
 255                                 goto out_unlock_reading;
 256                         }
 257
 258                         size -= len;
 259                         ret += len;
 260                 }
 261
 262                 mutex_unlock(&reading_mutex);
 263                 put_rng(rng);
 264
 265                 if (need_resched())
 266                         schedule_timeout_interruptible(1);
 267
 268                 if (signal_pending(current)) {
 269                         err = -ERESTARTSYS;
 270                         goto out;
 271                 }
 272         }
 273 out:
 274         return ret ? : err;
 275
 276 out_unlock_reading:
 277         mutex_unlock(&reading_mutex);
 278 out_put:
 279         put_rng(rng);
 280         goto out;
 281 }
 282
 283 static const struct file_operations rng_chrdev_ops = {
 284         .owner          = THIS_MODULE,
 285         .open           = rng_dev_open,
 286         .read           = rng_dev_read,
 287         .llseek         = noop_llseek,
 288 };
 289
 290 static const struct attribute_group *rng_dev_groups[];
 291
 292 static struct miscdevice rng_miscdev = {
 293         .minor          = HWRNG_MINOR,
 294         .name           = RNG_MODULE_NAME,
 295         .nodename       = "hwrng",
 296         .fops           = &rng_chrdev_ops,
 297         .groups         = rng_dev_groups,
 298 };
 299
 300 static int enable_best_rng(void)
 301 {
 302         int ret = -ENODEV;
 303
 304         BUG_ON(!mutex_is_locked(&rng_mutex));
 305
 306         /* rng_list is sorted by quality, use the best (=first) one */
 307         if (!list_empty(&rng_list)) {
 308                 struct hwrng *new_rng;
 309
 310                 new_rng = list_entry(rng_list.next, struct hwrng, list);
 311                 ret = ((new_rng == current_rng) ? 0 : set_current_rng(new_rng));
 312                 if (!ret)
 313                         cur_rng_set_by_user = 0;
 314         } else {
 315                 drop_current_rng();
 316                 cur_rng_set_by_user = 0;
 317                 ret = 0;
 318         }
 319
 320         return ret;
 321 }
 322
 323 static ssize_t hwrng_attr_current_store(struct device *dev,
 324                                         struct device_attribute *attr,
 325                                         const char *buf, size_t len)
 326 {
 327         int err = -ENODEV;
 328         struct hwrng *rng, *old_rng, *new_rng;
 329
 330         err = mutex_lock_interruptible(&rng_mutex);
 331         if (err)
 332                 return -ERESTARTSYS;
 333
 334         old_rng = current_rng;
 335         if (sysfs_streq(buf, "")) {
 336                 err = enable_best_rng();
 337         } else {
 338                 list_for_each_entry(rng, &rng_list, list) {
 339                         if (sysfs_streq(rng->name, buf)) {
 340                                 cur_rng_set_by_user = 1;
 341                                 err = set_current_rng(rng);
 342                                 break;
 343                         }
 344                 }
 345         }
 346         new_rng = get_current_rng_nolock();
 347         mutex_unlock(&rng_mutex);
 348
 349         if (new_rng) {
 350                 if (new_rng != old_rng)
 351                         add_early_randomness(new_rng);
 352                 put_rng(new_rng);
 353         }
 354
 355         return err ? : len;
 356 }
 357
 358 static ssize_t hwrng_attr_current_show(struct device *dev,
 359                                        struct device_attribute *attr,
 360                                        char *buf)
 361 {
 362         ssize_t ret;
 363         struct hwrng *rng;
 364
 365         rng = get_current_rng();
 366         if (IS_ERR(rng))
 367                 return PTR_ERR(rng);
 368
 369         ret = snprintf(buf, PAGE_SIZE, "%s\n", rng ? rng->name : "none");
 370         put_rng(rng);
 371
 372         return ret;
 373 }
 374
 375 static ssize_t hwrng_attr_available_show(struct device *dev,
 376                                          struct device_attribute *attr,
 377                                          char *buf)
 378 {
 379         int err;
 380         struct hwrng *rng;
 381
 382         err = mutex_lock_interruptible(&rng_mutex);
 383         if (err)
 384                 return -ERESTARTSYS;
 385         buf[0] = '\0';
 386         list_for_each_entry(rng, &rng_list, list) {
 387                 strlcat(buf, rng->name, PAGE_SIZE);
 388                 strlcat(buf, " ", PAGE_SIZE);
 389         }
 390         strlcat(buf, "\n", PAGE_SIZE);
 391         mutex_unlock(&rng_mutex);
 392
 393         return strlen(buf);
 394 }
 395
 396 static ssize_t hwrng_attr_selected_show(struct device *dev,
 397                                         struct device_attribute *attr,
 398                                         char *buf)
 399 {
 400         return snprintf(buf, PAGE_SIZE, "%d\n", cur_rng_set_by_user);
 401 }
 402
 403 static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
 404                    hwrng_attr_current_show,
 405                    hwrng_attr_current_store);
 406 static DEVICE_ATTR(rng_available, S_IRUGO,
 407                    hwrng_attr_available_show,
 408                    NULL);
 409 static DEVICE_ATTR(rng_selected, S_IRUGO,
 410                    hwrng_attr_selected_show,
 411                    NULL);
 412
 413 static struct attribute *rng_dev_attrs[] = {
 414         &dev_attr_rng_current.attr,
 415         &dev_attr_rng_available.attr,
 416         &dev_attr_rng_selected.attr,
 417         NULL
 418 };
 419
 420 ATTRIBUTE_GROUPS(rng_dev);
 421
 422 static void __exit unregister_miscdev(void)
 423 {
 424         misc_deregister(&rng_miscdev);
 425 }
 426
 427 static int __init register_miscdev(void)
 428 {
 429         return misc_register(&rng_miscdev);
 430 }
 431
 432 static int hwrng_fillfn(void *unused)
 433 {
 434         long rc;
 435
 436         while (!kthread_should_stop()) {
 437                 struct hwrng *rng;
 438
 439                 rng = get_current_rng();
 440                 if (IS_ERR(rng) || !rng)
 441                         break;
 442                 mutex_lock(&reading_mutex);
 443                 rc = rng_get_data(rng, rng_fillbuf,
 444                                   rng_buffer_size(), 1);
 445                 mutex_unlock(&reading_mutex);
 446                 put_rng(rng);
 447                 if (rc <= 0) {
 448                         pr_warn("hwrng: no data available\n");
 449                         msleep_interruptible(10000);
 450                         continue;
 451                 }
 452                 /* Outside lock, sure, but y'know: randomness. */
 453                 add_hwgenerator_randomness((void *)rng_fillbuf, rc,
 454                                            rc * current_quality * 8 >> 10);
 455         }
 456         hwrng_fill = NULL;
 457         return 0;
 458 }
 459
 460 static void start_khwrngd(void)
 461 {
 462         hwrng_fill = kthread_run(hwrng_fillfn, NULL, "hwrng");
 463         if (IS_ERR(hwrng_fill)) {
 464                 pr_err("hwrng_fill thread creation failed\n");
 465                 hwrng_fill = NULL;
 466         }
 467 }
 468
 469 int hwrng_register(struct hwrng *rng)
 470 {
 471         int err = -EINVAL;
 472         struct hwrng *tmp;
 473         struct list_head *rng_list_ptr;
 474         bool is_new_current = false;
 475
 476         if (!rng->name || (!rng->data_read && !rng->read))
 477                 goto out;
 478
 479         mutex_lock(&rng_mutex);
 480
 481         /* Must not register two RNGs with the same name. */
 482         err = -EEXIST;
 483         list_for_each_entry(tmp, &rng_list, list) {
 484                 if (strcmp(tmp->name, rng->name) == 0)
 485                         goto out_unlock;
 486         }
 487
 488         init_completion(&rng->cleanup_done);
 489         complete(&rng->cleanup_done);
 490
 491         /* rng_list is sorted by decreasing quality */
 492         list_for_each(rng_list_ptr, &rng_list) {
 493                 tmp = list_entry(rng_list_ptr, struct hwrng, list);
 494                 if (tmp->quality < rng->quality)
 495                         break;
 496         }
 497         list_add_tail(&rng->list, rng_list_ptr);
 498
 499         if (!current_rng ||
 500             (!cur_rng_set_by_user && rng->quality > current_rng->quality)) {
 501                 /*
 502                  * Set new rng as current as the new rng source
 503                  * provides better entropy quality and was not
 504                  * chosen by userspace.
 505                  */
 506                 err = set_current_rng(rng);
 507                 if (err)
 508                         goto out_unlock;
 509                 /* to use current_rng in add_early_randomness() we need
 510                  * to take a ref
 511                  */
 512                 is_new_current = true;
 513                 kref_get(&rng->ref);
 514         }
 515         mutex_unlock(&rng_mutex);
 516         if (is_new_current || !rng->init) {
 517                 /*
 518                  * Use a new device's input to add some randomness to
 519                  * the system.  If this rng device isn't going to be
 520                  * used right away, its init function hasn't been
 521                  * called yet by set_current_rng(); so only use the
 522                  * randomness from devices that don't need an init callback
 523                  */
 524                 add_early_randomness(rng);
 525         }
 526         if (is_new_current)
 527                 put_rng(rng);
 528         return 0;
 529 out_unlock:
 530         mutex_unlock(&rng_mutex);
 531 out:
 532         return err;
 533 }
 534 EXPORT_SYMBOL_GPL(hwrng_register);
 535
 536 void hwrng_unregister(struct hwrng *rng)
 537 {
 538         struct hwrng *old_rng, *new_rng;
 539         int err;
 540
 541         mutex_lock(&rng_mutex);
 542
 543         old_rng = current_rng;
 544         list_del(&rng->list);
 545         if (current_rng == rng) {
 546                 err = enable_best_rng();
 547                 if (err) {
 548                         drop_current_rng();
 549                         cur_rng_set_by_user = 0;
 550                 }
 551         }
 552
 553         new_rng = get_current_rng_nolock();
 554         if (list_empty(&rng_list)) {
 555                 mutex_unlock(&rng_mutex);
 556                 if (hwrng_fill)
 557                         kthread_stop(hwrng_fill);
 558         } else
 559                 mutex_unlock(&rng_mutex);
 560
 561         if (new_rng) {
 562                 if (old_rng != new_rng)
 563                         add_early_randomness(new_rng);
 564                 put_rng(new_rng);
 565         }
 566
 567         wait_for_completion(&rng->cleanup_done);
 568 }
 569 EXPORT_SYMBOL_GPL(hwrng_unregister);
 570
 571 static void devm_hwrng_release(struct device *dev, void *res)
 572 {
 573         hwrng_unregister(*(struct hwrng **)res);
 574 }
 575
 576 static int devm_hwrng_match(struct device *dev, void *res, void *data)
 577 {
 578         struct hwrng **r = res;
 579
 580         if (WARN_ON(!r || !*r))
 581                 return 0;
 582
 583         return *r == data;
 584 }
 585
 586 int devm_hwrng_register(struct device *dev, struct hwrng *rng)
 587 {
 588         struct hwrng **ptr;
 589         int error;
 590
 591         ptr = devres_alloc(devm_hwrng_release, sizeof(*ptr), GFP_KERNEL);
 592         if (!ptr)
 593                 return -ENOMEM;
 594
 595         error = hwrng_register(rng);
 596         if (error) {
 597                 devres_free(ptr);
 598                 return error;
 599         }
 600
 601         *ptr = rng;
 602         devres_add(dev, ptr);
 603         return 0;
 604 }
 605 EXPORT_SYMBOL_GPL(devm_hwrng_register);
 606
 607 void devm_hwrng_unregister(struct device *dev, struct hwrng *rng)
 608 {
 609         devres_release(dev, devm_hwrng_release, devm_hwrng_match, rng);
 610 }
 611 EXPORT_SYMBOL_GPL(devm_hwrng_unregister);
 612
 613 static int __init hwrng_modinit(void)
 614 {
 615         int ret;
 616
 617         /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */
 618         rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL);
 619         if (!rng_buffer)
 620                 return -ENOMEM;
 621
 622         rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL);
 623         if (!rng_fillbuf) {
 624                 kfree(rng_buffer);
 625                 return -ENOMEM;
 626         }
 627
 628         ret = register_miscdev();
 629         if (ret) {
 630                 kfree(rng_fillbuf);
 631                 kfree(rng_buffer);
 632         }
 633
 634         return ret;
 635 }
 636
 637 static void __exit hwrng_modexit(void)
 638 {
 639         mutex_lock(&rng_mutex);
 640         BUG_ON(current_rng);
 641         kfree(rng_buffer);
 642         kfree(rng_fillbuf);
 643         mutex_unlock(&rng_mutex);
 644
 645         unregister_miscdev();
 646 }
 647
 648 module_init(hwrng_modinit);
 649 module_exit(hwrng_modexit);
 650
 651 MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
 652 MODULE_LICENSE("GPL");