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