root/drivers/char/hw_random/virtio-rng.c

DEFINITIONS

1. random_recv_done
2. register_buffer
3. virtio_read
4. virtio_cleanup
5. probe_common
6. remove_common
7. virtrng_probe
8. virtrng_remove
9. virtrng_scan
10. virtrng_freeze
11. virtrng_restore

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Randomness driver for virtio
   4  *  Copyright (C) 2007, 2008 Rusty Russell IBM Corporation
   5  */
   6 
   7 #include <linux/err.h>
   8 #include <linux/hw_random.h>
   9 #include <linux/scatterlist.h>
  10 #include <linux/spinlock.h>
  11 #include <linux/virtio.h>
  12 #include <linux/virtio_rng.h>
  13 #include <linux/module.h>
  14 
  15 static DEFINE_IDA(rng_index_ida);
  16 
  17 struct virtrng_info {
  18         struct hwrng hwrng;
  19         struct virtqueue *vq;
  20         struct completion have_data;
  21         char name[25];
  22         unsigned int data_avail;
  23         int index;
  24         bool busy;
  25         bool hwrng_register_done;
  26         bool hwrng_removed;
  27 };
  28 
  29 static void random_recv_done(struct virtqueue *vq)
  30 {
  31         struct virtrng_info *vi = vq->vdev->priv;
  32 
  33         /* We can get spurious callbacks, e.g. shared IRQs + virtio_pci. */
  34         if (!virtqueue_get_buf(vi->vq, &vi->data_avail))
  35                 return;
  36 
  37         complete(&vi->have_data);
  38 }
  39 
  40 /* The host will fill any buffer we give it with sweet, sweet randomness. */
  41 static void register_buffer(struct virtrng_info *vi, u8 *buf, size_t size)
  42 {
  43         struct scatterlist sg;
  44 
  45         sg_init_one(&sg, buf, size);
  46 
  47         /* There should always be room for one buffer. */
  48         virtqueue_add_inbuf(vi->vq, &sg, 1, buf, GFP_KERNEL);
  49 
  50         virtqueue_kick(vi->vq);
  51 }
  52 
  53 static int virtio_read(struct hwrng *rng, void *buf, size_t size, bool wait)
  54 {
  55         int ret;
  56         struct virtrng_info *vi = (struct virtrng_info *)rng->priv;
  57 
  58         if (vi->hwrng_removed)
  59                 return -ENODEV;
  60 
  61         if (!vi->busy) {
  62                 vi->busy = true;
  63                 reinit_completion(&vi->have_data);
  64                 register_buffer(vi, buf, size);
  65         }
  66 
  67         if (!wait)
  68                 return 0;
  69 
  70         ret = wait_for_completion_killable(&vi->have_data);
  71         if (ret < 0)
  72                 return ret;
  73 
  74         vi->busy = false;
  75 
  76         return vi->data_avail;
  77 }
  78 
  79 static void virtio_cleanup(struct hwrng *rng)
  80 {
  81         struct virtrng_info *vi = (struct virtrng_info *)rng->priv;
  82 
  83         if (vi->busy)
  84                 wait_for_completion(&vi->have_data);
  85 }
  86 
  87 static int probe_common(struct virtio_device *vdev)
  88 {
  89         int err, index;
  90         struct virtrng_info *vi = NULL;
  91 
  92         vi = kzalloc(sizeof(struct virtrng_info), GFP_KERNEL);
  93         if (!vi)
  94                 return -ENOMEM;
  95 
  96         vi->index = index = ida_simple_get(&rng_index_ida, 0, 0, GFP_KERNEL);
  97         if (index < 0) {
  98                 err = index;
  99                 goto err_ida;
 100         }
 101         sprintf(vi->name, "virtio_rng.%d", index);
 102         init_completion(&vi->have_data);
 103 
 104         vi->hwrng = (struct hwrng) {
 105                 .read = virtio_read,
 106                 .cleanup = virtio_cleanup,
 107                 .priv = (unsigned long)vi,
 108                 .name = vi->name,
 109                 .quality = 1000,
 110         };
 111         vdev->priv = vi;
 112 
 113         /* We expect a single virtqueue. */
 114         vi->vq = virtio_find_single_vq(vdev, random_recv_done, "input");
 115         if (IS_ERR(vi->vq)) {
 116                 err = PTR_ERR(vi->vq);
 117                 goto err_find;
 118         }
 119 
 120         return 0;
 121 
 122 err_find:
 123         ida_simple_remove(&rng_index_ida, index);
 124 err_ida:
 125         kfree(vi);
 126         return err;
 127 }
 128 
 129 static void remove_common(struct virtio_device *vdev)
 130 {
 131         struct virtrng_info *vi = vdev->priv;
 132 
 133         vi->hwrng_removed = true;
 134         vi->data_avail = 0;
 135         complete(&vi->have_data);
 136         vdev->config->reset(vdev);
 137         vi->busy = false;
 138         if (vi->hwrng_register_done)
 139                 hwrng_unregister(&vi->hwrng);
 140         vdev->config->del_vqs(vdev);
 141         ida_simple_remove(&rng_index_ida, vi->index);
 142         kfree(vi);
 143 }
 144 
 145 static int virtrng_probe(struct virtio_device *vdev)
 146 {
 147         return probe_common(vdev);
 148 }
 149 
 150 static void virtrng_remove(struct virtio_device *vdev)
 151 {
 152         remove_common(vdev);
 153 }
 154 
 155 static void virtrng_scan(struct virtio_device *vdev)
 156 {
 157         struct virtrng_info *vi = vdev->priv;
 158         int err;
 159 
 160         err = hwrng_register(&vi->hwrng);
 161         if (!err)
 162                 vi->hwrng_register_done = true;
 163 }
 164 
 165 #ifdef CONFIG_PM_SLEEP
 166 static int virtrng_freeze(struct virtio_device *vdev)
 167 {
 168         remove_common(vdev);
 169         return 0;
 170 }
 171 
 172 static int virtrng_restore(struct virtio_device *vdev)
 173 {
 174         int err;
 175 
 176         err = probe_common(vdev);
 177         if (!err) {
 178                 struct virtrng_info *vi = vdev->priv;
 179 
 180                 /*
 181                  * Set hwrng_removed to ensure that virtio_read()
 182                  * does not block waiting for data before the
 183                  * registration is complete.
 184                  */
 185                 vi->hwrng_removed = true;
 186                 err = hwrng_register(&vi->hwrng);
 187                 if (!err) {
 188                         vi->hwrng_register_done = true;
 189                         vi->hwrng_removed = false;
 190                 }
 191         }
 192 
 193         return err;
 194 }
 195 #endif
 196 
 197 static struct virtio_device_id id_table[] = {
 198         { VIRTIO_ID_RNG, VIRTIO_DEV_ANY_ID },
 199         { 0 },
 200 };
 201 
 202 static struct virtio_driver virtio_rng_driver = {
 203         .driver.name =  KBUILD_MODNAME,
 204         .driver.owner = THIS_MODULE,
 205         .id_table =     id_table,
 206         .probe =        virtrng_probe,
 207         .remove =       virtrng_remove,
 208         .scan =         virtrng_scan,
 209 #ifdef CONFIG_PM_SLEEP
 210         .freeze =       virtrng_freeze,
 211         .restore =      virtrng_restore,
 212 #endif
 213 };
 214 
 215 module_virtio_driver(virtio_rng_driver);
 216 MODULE_DEVICE_TABLE(virtio, id_table);
 217 MODULE_DESCRIPTION("Virtio random number driver");
 218 MODULE_LICENSE("GPL");