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