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(¤t_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(¤t_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; 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"); 652