drivers/char/hw_random/core.c

   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 DECLARE_WAIT_QUEUE_HEAD(rng_done);
  64 static unsigned short current_quality;
  65 static unsigned short default_quality; /* = 0; default to "off" */
  66
  67 module_param(current_quality, ushort, 0644);
  68 MODULE_PARM_DESC(current_quality,
  69                  "current hwrng entropy estimation per mill");
  70 module_param(default_quality, ushort, 0644);
  71 MODULE_PARM_DESC(default_quality,
  72                  "default entropy content of hwrng per mill");
  73
  74 static void start_khwrngd(void);
  75
  76 static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
  77                                int wait);
  78
  79 static size_t rng_buffer_size(void)
  80 {
  81         return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES;
  82 }
  83
  84 static void add_early_randomness(struct hwrng *rng)
  85 {
  86         unsigned char bytes[16];
  87         int bytes_read;
  88
  89         mutex_lock(&reading_mutex);
  90         bytes_read = rng_get_data(rng, bytes, sizeof(bytes), 1);
  91         mutex_unlock(&reading_mutex);
  92         if (bytes_read > 0)
  93                 add_device_randomness(bytes, bytes_read);
  94 }
  95
  96 static inline void cleanup_rng(struct kref *kref)
  97 {
  98         struct hwrng *rng = container_of(kref, struct hwrng, ref);
  99
 100         if (rng->cleanup)
 101                 rng->cleanup(rng);
 102
 103         /* cleanup_done should be updated after cleanup finishes */
 104         smp_wmb();
 105         rng->cleanup_done = true;
 106         wake_up_all(&rng_done);
 107 }
 108
 109 static void set_current_rng(struct hwrng *rng)
 110 {
 111         BUG_ON(!mutex_is_locked(&rng_mutex));
 112         kref_get(&rng->ref);
 113         current_rng = rng;
 114 }
 115
 116 static void drop_current_rng(void)
 117 {
 118         BUG_ON(!mutex_is_locked(&rng_mutex));
 119         if (!current_rng)
 120                 return;
 121
 122         /* decrease last reference for triggering the cleanup */
 123         kref_put(&current_rng->ref, cleanup_rng);
 124         current_rng = NULL;
 125 }
 126
 127 /* Returns ERR_PTR(), NULL or refcounted hwrng */
 128 static struct hwrng *get_current_rng(void)
 129 {
 130         struct hwrng *rng;
 131
 132         if (mutex_lock_interruptible(&rng_mutex))
 133                 return ERR_PTR(-ERESTARTSYS);
 134
 135         rng = current_rng;
 136         if (rng)
 137                 kref_get(&rng->ref);
 138
 139         mutex_unlock(&rng_mutex);
 140         return rng;
 141 }
 142
 143 static void put_rng(struct hwrng *rng)
 144 {
 145         /*
 146          * Hold rng_mutex here so we serialize in case they set_current_rng
 147          * on rng again immediately.
 148          */
 149         mutex_lock(&rng_mutex);
 150         if (rng)
 151                 kref_put(&rng->ref, cleanup_rng);
 152         mutex_unlock(&rng_mutex);
 153 }
 154
 155 static inline int hwrng_init(struct hwrng *rng)
 156 {
 157         if (rng->init) {
 158                 int ret;
 159
 160                 ret =  rng->init(rng);
 161                 if (ret)
 162                         return ret;
 163         }
 164         add_early_randomness(rng);
 165
 166         current_quality = rng->quality ? : default_quality;
 167         current_quality &= 1023;
 168
 169         if (current_quality == 0 && hwrng_fill)
 170                 kthread_stop(hwrng_fill);
 171         if (current_quality > 0 && !hwrng_fill)
 172                 start_khwrngd();
 173
 174         return 0;
 175 }
 176
 177 static int rng_dev_open(struct inode *inode, struct file *filp)
 178 {
 179         /* enforce read-only access to this chrdev */
 180         if ((filp->f_mode & FMODE_READ) == 0)
 181                 return -EINVAL;
 182         if (filp->f_mode & FMODE_WRITE)
 183                 return -EINVAL;
 184         return 0;
 185 }
 186
 187 static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
 188                         int wait) {
 189         int present;
 190
 191         BUG_ON(!mutex_is_locked(&reading_mutex));
 192         if (rng->read)
 193                 return rng->read(rng, (void *)buffer, size, wait);
 194
 195         if (rng->data_present)
 196                 present = rng->data_present(rng, wait);
 197         else
 198                 present = 1;
 199
 200         if (present)
 201                 return rng->data_read(rng, (u32 *)buffer);
 202
 203         return 0;
 204 }
 205
 206 static ssize_t rng_dev_read(struct file *filp, char __user *buf,
 207                             size_t size, loff_t *offp)
 208 {
 209         ssize_t ret = 0;
 210         int err = 0;
 211         int bytes_read, len;
 212         struct hwrng *rng;
 213
 214         while (size) {
 215                 rng = get_current_rng();
 216                 if (IS_ERR(rng)) {
 217                         err = PTR_ERR(rng);
 218                         goto out;
 219                 }
 220                 if (!rng) {
 221                         err = -ENODEV;
 222                         goto out;
 223                 }
 224
 225                 mutex_lock(&reading_mutex);
 226                 if (!data_avail) {
 227                         bytes_read = rng_get_data(rng, rng_buffer,
 228                                 rng_buffer_size(),
 229                                 !(filp->f_flags & O_NONBLOCK));
 230                         if (bytes_read < 0) {
 231                                 err = bytes_read;
 232                                 goto out_unlock_reading;
 233                         }
 234                         data_avail = bytes_read;
 235                 }
 236
 237                 if (!data_avail) {
 238                         if (filp->f_flags & O_NONBLOCK) {
 239                                 err = -EAGAIN;
 240                                 goto out_unlock_reading;
 241                         }
 242                 } else {
 243                         len = data_avail;
 244                         if (len > size)
 245                                 len = size;
 246
 247                         data_avail -= len;
 248
 249                         if (copy_to_user(buf + ret, rng_buffer + data_avail,
 250                                                                 len)) {
 251                                 err = -EFAULT;
 252                                 goto out_unlock_reading;
 253                         }
 254
 255                         size -= len;
 256                         ret += len;
 257                 }
 258
 259                 mutex_unlock(&reading_mutex);
 260                 put_rng(rng);
 261
 262                 if (need_resched())
 263                         schedule_timeout_interruptible(1);
 264
 265                 if (signal_pending(current)) {
 266                         err = -ERESTARTSYS;
 267                         goto out;
 268                 }
 269         }
 270 out:
 271         return ret ? : err;
 272
 273 out_unlock_reading:
 274         mutex_unlock(&reading_mutex);
 275         put_rng(rng);
 276         goto out;
 277 }
 278
 279
 280 static const struct file_operations rng_chrdev_ops = {
 281         .owner          = THIS_MODULE,
 282         .open           = rng_dev_open,
 283         .read           = rng_dev_read,
 284         .llseek         = noop_llseek,
 285 };
 286
 287 static struct miscdevice rng_miscdev = {
 288         .minor          = RNG_MISCDEV_MINOR,
 289         .name           = RNG_MODULE_NAME,
 290         .nodename       = "hwrng",
 291         .fops           = &rng_chrdev_ops,
 292 };
 293
 294
 295 static ssize_t hwrng_attr_current_store(struct device *dev,
 296                                         struct device_attribute *attr,
 297                                         const char *buf, size_t len)
 298 {
 299         int err;
 300         struct hwrng *rng;
 301
 302         err = mutex_lock_interruptible(&rng_mutex);
 303         if (err)
 304                 return -ERESTARTSYS;
 305         err = -ENODEV;
 306         list_for_each_entry(rng, &rng_list, list) {
 307                 if (strcmp(rng->name, buf) == 0) {
 308                         if (rng == current_rng) {
 309                                 err = 0;
 310                                 break;
 311                         }
 312                         err = hwrng_init(rng);
 313                         if (err)
 314                                 break;
 315                         drop_current_rng();
 316                         set_current_rng(rng);
 317                         err = 0;
 318                         break;
 319                 }
 320         }
 321         mutex_unlock(&rng_mutex);
 322
 323         return err ? : len;
 324 }
 325
 326 static ssize_t hwrng_attr_current_show(struct device *dev,
 327                                        struct device_attribute *attr,
 328                                        char *buf)
 329 {
 330         ssize_t ret;
 331         struct hwrng *rng;
 332
 333         rng = get_current_rng();
 334         if (IS_ERR(rng))
 335                 return PTR_ERR(rng);
 336
 337         ret = snprintf(buf, PAGE_SIZE, "%s\n", rng ? rng->name : "none");
 338         put_rng(rng);
 339
 340         return ret;
 341 }
 342
 343 static ssize_t hwrng_attr_available_show(struct device *dev,
 344                                          struct device_attribute *attr,
 345                                          char *buf)
 346 {
 347         int err;
 348         struct hwrng *rng;
 349
 350         err = mutex_lock_interruptible(&rng_mutex);
 351         if (err)
 352                 return -ERESTARTSYS;
 353         buf[0] = '\0';
 354         list_for_each_entry(rng, &rng_list, list) {
 355                 strlcat(buf, rng->name, PAGE_SIZE);
 356                 strlcat(buf, " ", PAGE_SIZE);
 357         }
 358         strlcat(buf, "\n", PAGE_SIZE);
 359         mutex_unlock(&rng_mutex);
 360
 361         return strlen(buf);
 362 }
 363
 364 static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
 365                    hwrng_attr_current_show,
 366                    hwrng_attr_current_store);
 367 static DEVICE_ATTR(rng_available, S_IRUGO,
 368                    hwrng_attr_available_show,
 369                    NULL);
 370
 371
 372 static void unregister_miscdev(void)
 373 {
 374         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_available);
 375         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
 376         misc_deregister(&rng_miscdev);
 377 }
 378
 379 static int register_miscdev(void)
 380 {
 381         int err;
 382
 383         err = misc_register(&rng_miscdev);
 384         if (err)
 385                 goto out;
 386         err = device_create_file(rng_miscdev.this_device,
 387                                  &dev_attr_rng_current);
 388         if (err)
 389                 goto err_misc_dereg;
 390         err = device_create_file(rng_miscdev.this_device,
 391                                  &dev_attr_rng_available);
 392         if (err)
 393                 goto err_remove_current;
 394 out:
 395         return err;
 396
 397 err_remove_current:
 398         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
 399 err_misc_dereg:
 400         misc_deregister(&rng_miscdev);
 401         goto out;
 402 }
 403
 404 static int hwrng_fillfn(void *unused)
 405 {
 406         long rc;
 407
 408         while (!kthread_should_stop()) {
 409                 struct hwrng *rng;
 410
 411                 rng = get_current_rng();
 412                 if (IS_ERR(rng) || !rng)
 413                         break;
 414                 mutex_lock(&reading_mutex);
 415                 rc = rng_get_data(rng, rng_fillbuf,
 416                                   rng_buffer_size(), 1);
 417                 mutex_unlock(&reading_mutex);
 418                 put_rng(rng);
 419                 if (rc <= 0) {
 420                         pr_warn("hwrng: no data available\n");
 421                         msleep_interruptible(10000);
 422                         continue;
 423                 }
 424                 /* Outside lock, sure, but y'know: randomness. */
 425                 add_hwgenerator_randomness((void *)rng_fillbuf, rc,
 426                                            rc * current_quality * 8 >> 10);
 427         }
 428         hwrng_fill = NULL;
 429         return 0;
 430 }
 431
 432 static void start_khwrngd(void)
 433 {
 434         hwrng_fill = kthread_run(hwrng_fillfn, NULL, "hwrng");
 435         if (hwrng_fill == ERR_PTR(-ENOMEM)) {
 436                 pr_err("hwrng_fill thread creation failed");
 437                 hwrng_fill = NULL;
 438         }
 439 }
 440
 441 int hwrng_register(struct hwrng *rng)
 442 {
 443         int err = -EINVAL;
 444         struct hwrng *old_rng, *tmp;
 445
 446         if (rng->name == NULL ||
 447             (rng->data_read == NULL && rng->read == NULL))
 448                 goto out;
 449
 450         mutex_lock(&rng_mutex);
 451
 452         /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */
 453         err = -ENOMEM;
 454         if (!rng_buffer) {
 455                 rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL);
 456                 if (!rng_buffer)
 457                         goto out_unlock;
 458         }
 459         if (!rng_fillbuf) {
 460                 rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL);
 461                 if (!rng_fillbuf) {
 462                         kfree(rng_buffer);
 463                         goto out_unlock;
 464                 }
 465         }
 466
 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         old_rng = current_rng;
 475         err = 0;
 476         if (!old_rng) {
 477                 err = hwrng_init(rng);
 478                 if (err)
 479                         goto out_unlock;
 480                 set_current_rng(rng);
 481
 482                 err = register_miscdev();
 483                 if (err) {
 484                         drop_current_rng();
 485                         goto out_unlock;
 486                 }
 487         }
 488         INIT_LIST_HEAD(&rng->list);
 489         list_add_tail(&rng->list, &rng_list);
 490
 491         if (old_rng && !rng->init) {
 492                 /*
 493                  * Use a new device's input to add some randomness to
 494                  * the system.  If this rng device isn't going to be
 495                  * used right away, its init function hasn't been
 496                  * called yet; so only use the randomness from devices
 497                  * that don't need an init callback.
 498                  */
 499                 add_early_randomness(rng);
 500         }
 501
 502         rng->cleanup_done = false;
 503
 504 out_unlock:
 505         mutex_unlock(&rng_mutex);
 506 out:
 507         return err;
 508 }
 509 EXPORT_SYMBOL_GPL(hwrng_register);
 510
 511 void hwrng_unregister(struct hwrng *rng)
 512 {
 513         mutex_lock(&rng_mutex);
 514
 515         list_del(&rng->list);
 516         if (current_rng == rng) {
 517                 drop_current_rng();
 518                 if (!list_empty(&rng_list)) {
 519                         struct hwrng *tail;
 520
 521                         tail = list_entry(rng_list.prev, struct hwrng, list);
 522
 523                         if (hwrng_init(tail) == 0)
 524                                 set_current_rng(tail);
 525                 }
 526         }
 527
 528         if (list_empty(&rng_list)) {
 529                 mutex_unlock(&rng_mutex);
 530                 unregister_miscdev();
 531                 if (hwrng_fill)
 532                         kthread_stop(hwrng_fill);
 533         } else
 534                 mutex_unlock(&rng_mutex);
 535
 536         /* Just in case rng is reading right now, wait. */
 537         wait_event(rng_done, rng->cleanup_done &&
 538                    atomic_read(&rng->ref.refcount) == 0);
 539 }
 540 EXPORT_SYMBOL_GPL(hwrng_unregister);
 541
 542 static void __exit hwrng_exit(void)
 543 {
 544         mutex_lock(&rng_mutex);
 545         BUG_ON(current_rng);
 546         kfree(rng_buffer);
 547         kfree(rng_fillbuf);
 548         mutex_unlock(&rng_mutex);
 549 }
 550
 551 module_exit(hwrng_exit);
 552
 553 MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
 554 MODULE_LICENSE("GPL");