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