root/drivers/char/hw_random/core.c

DEFINITIONS

1. rng_buffer_size
2. add_early_randomness
3. cleanup_rng
4. set_current_rng
5. drop_current_rng
6. get_current_rng
7. put_rng
8. hwrng_init
9. rng_dev_open
10. rng_get_data
11. rng_dev_read
12. enable_best_rng
13. hwrng_attr_current_store
14. hwrng_attr_current_show
15. hwrng_attr_available_show
16. hwrng_attr_selected_show
17. unregister_miscdev
18. register_miscdev
19. hwrng_fillfn
20. start_khwrngd
21. hwrng_register
22. hwrng_unregister
23. devm_hwrng_release
24. devm_hwrng_match
25. devm_hwrng_register
26. devm_hwrng_unregister
27. hwrng_modinit
28. hwrng_modexit

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