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