tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
28static struct virtqueue *vq;
29static unsigned int data_avail;
30static DECLARE_COMPLETION(have_data);
31static bool busy;
32
33static void random_recv_done(struct virtqueue *vq)
34{
35 /* We can get spurious callbacks, e.g. shared IRQs + virtio_pci. */
36 if (!virtqueue_get_buf(vq, &data_avail))
37 return;
38
39 complete(&have_data);
40}
41
42/* The host will fill any buffer we give it with sweet, sweet randomness. */
43static void register_buffer(u8 *buf, size_t size)
44{
45 struct scatterlist sg;
46
47 sg_init_one(&sg, buf, size);
48
49 /* There should always be room for one buffer. */
50 if (virtqueue_add_buf(vq, &sg, 0, 1, buf, GFP_KERNEL) < 0)
51 BUG();
52
53 virtqueue_kick(vq);
54}
55
56static int virtio_read(struct hwrng *rng, void *buf, size_t size, bool wait)
57{
58 int ret;
59
60 if (!busy) {
61 busy = true;
62 init_completion(&have_data);
63 register_buffer(buf, size);
64 }
65
66 if (!wait)
67 return 0;
68
69 ret = wait_for_completion_killable(&have_data);
70 if (ret < 0)
71 return ret;
72
73 busy = false;
74
75 return data_avail;
76}
77
78static void virtio_cleanup(struct hwrng *rng)
79{
80 if (busy)
81 wait_for_completion(&have_data);
82}
83
84
85static struct hwrng virtio_hwrng = {
86 .name = "virtio",
87 .cleanup = virtio_cleanup,
88 .read = virtio_read,
89};
90
91static int probe_common(struct virtio_device *vdev)
92{
93 int err;
94
95 /* We expect a single virtqueue. */
96 vq = virtio_find_single_vq(vdev, random_recv_done, "input");
97 if (IS_ERR(vq))
98 return PTR_ERR(vq);
99
100 err = hwrng_register(&virtio_hwrng);
101 if (err) {
102 vdev->config->del_vqs(vdev);
103 return err;
104 }
105
106 return 0;
107}
108
109static void remove_common(struct virtio_device *vdev)
110{
111 vdev->config->reset(vdev);
112 busy = false;
113 hwrng_unregister(&virtio_hwrng);
114 vdev->config->del_vqs(vdev);
115}
116
117static int virtrng_probe(struct virtio_device *vdev)
118{
119 return probe_common(vdev);
120}
121
122static void virtrng_remove(struct virtio_device *vdev)
123{
124 remove_common(vdev);
125}
126
127#ifdef CONFIG_PM
128static int virtrng_freeze(struct virtio_device *vdev)
129{
130 remove_common(vdev);
131 return 0;
132}
133
134static int virtrng_restore(struct virtio_device *vdev)
135{
136 return probe_common(vdev);
137}
138#endif
139
140static struct virtio_device_id id_table[] = {
141 { VIRTIO_ID_RNG, VIRTIO_DEV_ANY_ID },
142 { 0 },
143};
144
145static struct virtio_driver virtio_rng_driver = {
146 .driver.name = KBUILD_MODNAME,
147 .driver.owner = THIS_MODULE,
148 .id_table = id_table,
149 .probe = virtrng_probe,
150 .remove = virtrng_remove,
151#ifdef CONFIG_PM
152 .freeze = virtrng_freeze,
153 .restore = virtrng_restore,
154#endif
155};
156
157static int __init init(void)
158{
159 return register_virtio_driver(&virtio_rng_driver);
160}
161
162static void __exit fini(void)
163{
164 unregister_virtio_driver(&virtio_rng_driver);
165}
166module_init(init);
167module_exit(fini);
168
169MODULE_DEVICE_TABLE(virtio, id_table);
170MODULE_DESCRIPTION("Virtio random number driver");
171MODULE_LICENSE("GPL");