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"); 219