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