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