linux/drivers/char/hw_random/core.c
<<
>>
Prefs
   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
  54static struct hwrng *current_rng;
  55static struct task_struct *hwrng_fill;
  56static LIST_HEAD(rng_list);
  57/* Protects rng_list and current_rng */
  58static DEFINE_MUTEX(rng_mutex);
  59/* Protects rng read functions, data_avail, rng_buffer and rng_fillbuf */
  60static DEFINE_MUTEX(reading_mutex);
  61static int data_avail;
  62static u8 *rng_buffer, *rng_fillbuf;
  63static unsigned short current_quality;
  64static unsigned short default_quality; /* = 0; default to "off" */
  65
  66module_param(current_quality, ushort, 0644);
  67MODULE_PARM_DESC(current_quality,
  68                 "current hwrng entropy estimation per mill");
  69module_param(default_quality, ushort, 0644);
  70MODULE_PARM_DESC(default_quality,
  71                 "default entropy content of hwrng per mill");
  72
  73static void drop_current_rng(void);
  74static int hwrng_init(struct hwrng *rng);
  75static void start_khwrngd(void);
  76
  77static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
  78                               int wait);
  79
  80static size_t rng_buffer_size(void)
  81{
  82        return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES;
  83}
  84
  85static void add_early_randomness(struct hwrng *rng)
  86{
  87        int bytes_read;
  88        size_t size = min_t(size_t, 16, rng_buffer_size());
  89
  90        mutex_lock(&reading_mutex);
  91        bytes_read = rng_get_data(rng, rng_buffer, size, 1);
  92        mutex_unlock(&reading_mutex);
  93        if (bytes_read > 0)
  94                add_device_randomness(rng_buffer, bytes_read);
  95}
  96
  97static 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
 107static 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
 123static 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(&current_rng->ref, cleanup_rng);
 131        current_rng = NULL;
 132}
 133
 134/* Returns ERR_PTR(), NULL or refcounted hwrng */
 135static 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
 150static 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
 162static 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
 178skip_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
 193static 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
 203static 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
 222static 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        }
 289out:
 290        return ret ? : err;
 291
 292out_unlock_reading:
 293        mutex_unlock(&reading_mutex);
 294out_put:
 295        put_rng(rng);
 296        goto out;
 297}
 298
 299
 300static 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
 307static const struct attribute_group *rng_dev_groups[];
 308
 309static 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
 318static 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
 342static 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
 359static 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
 380static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
 381                   hwrng_attr_current_show,
 382                   hwrng_attr_current_store);
 383static DEVICE_ATTR(rng_available, S_IRUGO,
 384                   hwrng_attr_available_show,
 385                   NULL);
 386
 387static struct attribute *rng_dev_attrs[] = {
 388        &dev_attr_rng_current.attr,
 389        &dev_attr_rng_available.attr,
 390        NULL
 391};
 392
 393ATTRIBUTE_GROUPS(rng_dev);
 394
 395static void __exit unregister_miscdev(void)
 396{
 397        misc_deregister(&rng_miscdev);
 398}
 399
 400static int __init register_miscdev(void)
 401{
 402        return misc_register(&rng_miscdev);
 403}
 404
 405static 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
 433static 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
 442int 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        /* Must not register two RNGs with the same name. */
 453        err = -EEXIST;
 454        list_for_each_entry(tmp, &rng_list, list) {
 455                if (strcmp(tmp->name, rng->name) == 0)
 456                        goto out_unlock;
 457        }
 458
 459        init_completion(&rng->cleanup_done);
 460        complete(&rng->cleanup_done);
 461
 462        old_rng = current_rng;
 463        err = 0;
 464        if (!old_rng) {
 465                err = set_current_rng(rng);
 466                if (err)
 467                        goto out_unlock;
 468        }
 469        list_add_tail(&rng->list, &rng_list);
 470
 471        if (old_rng && !rng->init) {
 472                /*
 473                 * Use a new device's input to add some randomness to
 474                 * the system.  If this rng device isn't going to be
 475                 * used right away, its init function hasn't been
 476                 * called yet; so only use the randomness from devices
 477                 * that don't need an init callback.
 478                 */
 479                add_early_randomness(rng);
 480        }
 481
 482out_unlock:
 483        mutex_unlock(&rng_mutex);
 484out:
 485        return err;
 486}
 487EXPORT_SYMBOL_GPL(hwrng_register);
 488
 489void hwrng_unregister(struct hwrng *rng)
 490{
 491        mutex_lock(&rng_mutex);
 492
 493        list_del(&rng->list);
 494        if (current_rng == rng) {
 495                drop_current_rng();
 496                if (!list_empty(&rng_list)) {
 497                        struct hwrng *tail;
 498
 499                        tail = list_entry(rng_list.prev, struct hwrng, list);
 500
 501                        set_current_rng(tail);
 502                }
 503        }
 504
 505        if (list_empty(&rng_list)) {
 506                mutex_unlock(&rng_mutex);
 507                if (hwrng_fill)
 508                        kthread_stop(hwrng_fill);
 509        } else
 510                mutex_unlock(&rng_mutex);
 511
 512        wait_for_completion(&rng->cleanup_done);
 513}
 514EXPORT_SYMBOL_GPL(hwrng_unregister);
 515
 516static void devm_hwrng_release(struct device *dev, void *res)
 517{
 518        hwrng_unregister(*(struct hwrng **)res);
 519}
 520
 521static int devm_hwrng_match(struct device *dev, void *res, void *data)
 522{
 523        struct hwrng **r = res;
 524
 525        if (WARN_ON(!r || !*r))
 526                return 0;
 527
 528        return *r == data;
 529}
 530
 531int devm_hwrng_register(struct device *dev, struct hwrng *rng)
 532{
 533        struct hwrng **ptr;
 534        int error;
 535
 536        ptr = devres_alloc(devm_hwrng_release, sizeof(*ptr), GFP_KERNEL);
 537        if (!ptr)
 538                return -ENOMEM;
 539
 540        error = hwrng_register(rng);
 541        if (error) {
 542                devres_free(ptr);
 543                return error;
 544        }
 545
 546        *ptr = rng;
 547        devres_add(dev, ptr);
 548        return 0;
 549}
 550EXPORT_SYMBOL_GPL(devm_hwrng_register);
 551
 552void devm_hwrng_unregister(struct device *dev, struct hwrng *rng)
 553{
 554        devres_release(dev, devm_hwrng_release, devm_hwrng_match, rng);
 555}
 556EXPORT_SYMBOL_GPL(devm_hwrng_unregister);
 557
 558static int __init hwrng_modinit(void)
 559{
 560        int ret = -ENOMEM;
 561
 562        /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */
 563        rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL);
 564        if (!rng_buffer)
 565                return -ENOMEM;
 566
 567        rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL);
 568        if (!rng_fillbuf) {
 569                kfree(rng_buffer);
 570                return -ENOMEM;
 571        }
 572
 573        ret = register_miscdev();
 574        if (ret) {
 575                kfree(rng_fillbuf);
 576                kfree(rng_buffer);
 577        }
 578
 579        return ret;
 580}
 581
 582static void __exit hwrng_modexit(void)
 583{
 584        mutex_lock(&rng_mutex);
 585        BUG_ON(current_rng);
 586        kfree(rng_buffer);
 587        kfree(rng_fillbuf);
 588        mutex_unlock(&rng_mutex);
 589
 590        unregister_miscdev();
 591}
 592
 593module_init(hwrng_modinit);
 594module_exit(hwrng_modexit);
 595
 596MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
 597MODULE_LICENSE("GPL");
 598