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 rng_current_store(struct device *dev, 323 struct device_attribute *attr, 324 const char *buf, size_t len) 325 { 326 int err; 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 rng_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 rng_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 rng_selected_show(struct device *dev, 396 struct device_attribute *attr, 397 char *buf) 398 { 399 return sysfs_emit(buf, "%d\n", cur_rng_set_by_user); 400 } 401 402 static DEVICE_ATTR_RW(rng_current); 403 static DEVICE_ATTR_RO(rng_available); 404 static DEVICE_ATTR_RO(rng_selected); 405 406 static struct attribute *rng_dev_attrs[] = { 407 &dev_attr_rng_current.attr, 408 &dev_attr_rng_available.attr, 409 &dev_attr_rng_selected.attr, 410 NULL 411 }; 412 413 ATTRIBUTE_GROUPS(rng_dev); 414 415 static void __exit unregister_miscdev(void) 416 { 417 misc_deregister(&rng_miscdev); 418 } 419 420 static int __init register_miscdev(void) 421 { 422 return misc_register(&rng_miscdev); 423 } 424 425 static int hwrng_fillfn(void *unused) 426 { 427 long rc; 428 429 while (!kthread_should_stop()) { 430 struct hwrng *rng; 431 432 rng = get_current_rng(); 433 if (IS_ERR(rng) || !rng) 434 break; 435 mutex_lock(&reading_mutex); 436 rc = rng_get_data(rng, rng_fillbuf, 437 rng_buffer_size(), 1); 438 mutex_unlock(&reading_mutex); 439 put_rng(rng); 440 if (rc <= 0) { 441 pr_warn("hwrng: no data available\n"); 442 msleep_interruptible(10000); 443 continue; 444 } 445 /* Outside lock, sure, but y'know: randomness. */ 446 add_hwgenerator_randomness((void *)rng_fillbuf, rc, 447 rc * current_quality * 8 >> 10); 448 } 449 hwrng_fill = NULL; 450 return 0; 451 } 452 453 static void start_khwrngd(void) 454 { 455 hwrng_fill = kthread_run(hwrng_fillfn, NULL, "hwrng"); 456 if (IS_ERR(hwrng_fill)) { 457 pr_err("hwrng_fill thread creation failed\n"); 458 hwrng_fill = NULL; 459 } 460 } 461 462 int hwrng_register(struct hwrng *rng) 463 { 464 int err = -EINVAL; 465 struct hwrng *tmp; 466 struct list_head *rng_list_ptr; 467 bool is_new_current = false; 468 469 if (!rng->name || (!rng->data_read && !rng->read)) 470 goto out; 471 472 mutex_lock(&rng_mutex); 473 474 /* Must not register two RNGs with the same name. */ 475 err = -EEXIST; 476 list_for_each_entry(tmp, &rng_list, list) { 477 if (strcmp(tmp->name, rng->name) == 0) 478 goto out_unlock; 479 } 480 481 init_completion(&rng->cleanup_done); 482 complete(&rng->cleanup_done); 483 484 /* rng_list is sorted by decreasing quality */ 485 list_for_each(rng_list_ptr, &rng_list) { 486 tmp = list_entry(rng_list_ptr, struct hwrng, list); 487 if (tmp->quality < rng->quality) 488 break; 489 } 490 list_add_tail(&rng->list, rng_list_ptr); 491 492 if (!current_rng || 493 (!cur_rng_set_by_user && rng->quality > current_rng->quality)) { 494 /* 495 * Set new rng as current as the new rng source 496 * provides better entropy quality and was not 497 * chosen by userspace. 498 */ 499 err = set_current_rng(rng); 500 if (err) 501 goto out_unlock; 502 /* to use current_rng in add_early_randomness() we need 503 * to take a ref 504 */ 505 is_new_current = true; 506 kref_get(&rng->ref); 507 } 508 mutex_unlock(&rng_mutex); 509 if (is_new_current || !rng->init) { 510 /* 511 * Use a new device's input to add some randomness to 512 * the system. If this rng device isn't going to be 513 * used right away, its init function hasn't been 514 * called yet by set_current_rng(); so only use the 515 * randomness from devices that don't need an init callback 516 */ 517 add_early_randomness(rng); 518 } 519 if (is_new_current) 520 put_rng(rng); 521 return 0; 522 out_unlock: 523 mutex_unlock(&rng_mutex); 524 out: 525 return err; 526 } 527 EXPORT_SYMBOL_GPL(hwrng_register); 528 529 void hwrng_unregister(struct hwrng *rng) 530 { 531 struct hwrng *old_rng, *new_rng; 532 int err; 533 534 mutex_lock(&rng_mutex); 535 536 old_rng = current_rng; 537 list_del(&rng->list); 538 if (current_rng == rng) { 539 err = enable_best_rng(); 540 if (err) { 541 drop_current_rng(); 542 cur_rng_set_by_user = 0; 543 } 544 } 545 546 new_rng = get_current_rng_nolock(); 547 if (list_empty(&rng_list)) { 548 mutex_unlock(&rng_mutex); 549 if (hwrng_fill) 550 kthread_stop(hwrng_fill); 551 } else 552 mutex_unlock(&rng_mutex); 553 554 if (new_rng) { 555 if (old_rng != new_rng) 556 add_early_randomness(new_rng); 557 put_rng(new_rng); 558 } 559 560 wait_for_completion(&rng->cleanup_done); 561 } 562 EXPORT_SYMBOL_GPL(hwrng_unregister); 563 564 static void devm_hwrng_release(struct device *dev, void *res) 565 { 566 hwrng_unregister(*(struct hwrng **)res); 567 } 568 569 static int devm_hwrng_match(struct device *dev, void *res, void *data) 570 { 571 struct hwrng **r = res; 572 573 if (WARN_ON(!r || !*r)) 574 return 0; 575 576 return *r == data; 577 } 578 579 int devm_hwrng_register(struct device *dev, struct hwrng *rng) 580 { 581 struct hwrng **ptr; 582 int error; 583 584 ptr = devres_alloc(devm_hwrng_release, sizeof(*ptr), GFP_KERNEL); 585 if (!ptr) 586 return -ENOMEM; 587 588 error = hwrng_register(rng); 589 if (error) { 590 devres_free(ptr); 591 return error; 592 } 593 594 *ptr = rng; 595 devres_add(dev, ptr); 596 return 0; 597 } 598 EXPORT_SYMBOL_GPL(devm_hwrng_register); 599 600 void devm_hwrng_unregister(struct device *dev, struct hwrng *rng) 601 { 602 devres_release(dev, devm_hwrng_release, devm_hwrng_match, rng); 603 } 604 EXPORT_SYMBOL_GPL(devm_hwrng_unregister); 605 606 static int __init hwrng_modinit(void) 607 { 608 int ret; 609 610 /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */ 611 rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL); 612 if (!rng_buffer) 613 return -ENOMEM; 614 615 rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL); 616 if (!rng_fillbuf) { 617 kfree(rng_buffer); 618 return -ENOMEM; 619 } 620 621 ret = register_miscdev(); 622 if (ret) { 623 kfree(rng_fillbuf); 624 kfree(rng_buffer); 625 } 626 627 return ret; 628 } 629 630 static void __exit hwrng_modexit(void) 631 { 632 mutex_lock(&rng_mutex); 633 BUG_ON(current_rng); 634 kfree(rng_buffer); 635 kfree(rng_fillbuf); 636 mutex_unlock(&rng_mutex); 637 638 unregister_miscdev(); 639 } 640 641 module_init(hwrng_modinit); 642 module_exit(hwrng_modexit); 643 644 MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver"); 645 MODULE_LICENSE("GPL"); 646