]>
Commit | Line | Data |
---|---|---|
16c915ba AS |
1 | /* |
2 | * A virtio device implementing a hardware random number generator. | |
3 | * | |
4 | * Copyright 2012 Red Hat, Inc. | |
5 | * Copyright 2012 Amit Shah <amit.shah@redhat.com> | |
6 | * | |
7 | * This work is licensed under the terms of the GNU GPL, version 2 or | |
8 | * (at your option) any later version. See the COPYING file in the | |
9 | * top-level directory. | |
10 | */ | |
11 | ||
1de7afc9 | 12 | #include "qemu/iov.h" |
83c9f4ca | 13 | #include "hw/qdev.h" |
b4a42f81 | 14 | #include "qapi/qmp/qerror.h" |
0d09e41a PB |
15 | #include "hw/virtio/virtio.h" |
16 | #include "hw/virtio/virtio-rng.h" | |
dccfcd0e | 17 | #include "sysemu/rng.h" |
16c915ba | 18 | |
16c915ba AS |
19 | static bool is_guest_ready(VirtIORNG *vrng) |
20 | { | |
21 | if (virtio_queue_ready(vrng->vq) | |
22 | && (vrng->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK)) { | |
23 | return true; | |
24 | } | |
25 | return false; | |
26 | } | |
27 | ||
e1f7b481 | 28 | static size_t get_request_size(VirtQueue *vq, unsigned quota) |
16c915ba | 29 | { |
14417039 | 30 | unsigned int in, out; |
16c915ba | 31 | |
e1f7b481 | 32 | virtqueue_get_avail_bytes(vq, &in, &out, quota, 0); |
14417039 | 33 | return in; |
16c915ba AS |
34 | } |
35 | ||
904d6f58 AL |
36 | static void virtio_rng_process(VirtIORNG *vrng); |
37 | ||
16c915ba AS |
38 | /* Send data from a char device over to the guest */ |
39 | static void chr_read(void *opaque, const void *buf, size_t size) | |
40 | { | |
41 | VirtIORNG *vrng = opaque; | |
14417039 | 42 | VirtQueueElement elem; |
16c915ba AS |
43 | size_t len; |
44 | int offset; | |
45 | ||
46 | if (!is_guest_ready(vrng)) { | |
47 | return; | |
48 | } | |
49 | ||
904d6f58 AL |
50 | vrng->quota_remaining -= size; |
51 | ||
16c915ba AS |
52 | offset = 0; |
53 | while (offset < size) { | |
14417039 | 54 | if (!virtqueue_pop(vrng->vq, &elem)) { |
16c915ba AS |
55 | break; |
56 | } | |
14417039 | 57 | len = iov_from_buf(elem.in_sg, elem.in_num, |
16c915ba AS |
58 | 0, buf + offset, size - offset); |
59 | offset += len; | |
60 | ||
14417039 | 61 | virtqueue_push(vrng->vq, &elem, len); |
16c915ba AS |
62 | } |
63 | virtio_notify(&vrng->vdev, vrng->vq); | |
16c915ba AS |
64 | } |
65 | ||
904d6f58 | 66 | static void virtio_rng_process(VirtIORNG *vrng) |
16c915ba | 67 | { |
14417039 | 68 | size_t size; |
e1f7b481 | 69 | unsigned quota; |
904d6f58 AL |
70 | |
71 | if (!is_guest_ready(vrng)) { | |
72 | return; | |
73 | } | |
16c915ba | 74 | |
e1f7b481 MT |
75 | if (vrng->quota_remaining < 0) { |
76 | quota = 0; | |
77 | } else { | |
78 | quota = MIN((uint64_t)vrng->quota_remaining, (uint64_t)UINT32_MAX); | |
79 | } | |
80 | size = get_request_size(vrng->vq, quota); | |
904d6f58 | 81 | size = MIN(vrng->quota_remaining, size); |
14417039 | 82 | if (size) { |
16c915ba AS |
83 | rng_backend_request_entropy(vrng->rng, size, chr_read, vrng); |
84 | } | |
85 | } | |
86 | ||
904d6f58 AL |
87 | static void handle_input(VirtIODevice *vdev, VirtQueue *vq) |
88 | { | |
89 | VirtIORNG *vrng = DO_UPCAST(VirtIORNG, vdev, vdev); | |
90 | virtio_rng_process(vrng); | |
91 | } | |
92 | ||
16c915ba AS |
93 | static uint32_t get_features(VirtIODevice *vdev, uint32_t f) |
94 | { | |
95 | return f; | |
96 | } | |
97 | ||
98 | static void virtio_rng_save(QEMUFile *f, void *opaque) | |
99 | { | |
100 | VirtIORNG *vrng = opaque; | |
101 | ||
102 | virtio_save(&vrng->vdev, f); | |
16c915ba AS |
103 | } |
104 | ||
105 | static int virtio_rng_load(QEMUFile *f, void *opaque, int version_id) | |
106 | { | |
107 | VirtIORNG *vrng = opaque; | |
108 | ||
109 | if (version_id != 1) { | |
110 | return -EINVAL; | |
111 | } | |
112 | virtio_load(&vrng->vdev, f); | |
113 | ||
904d6f58 | 114 | /* We may have an element ready but couldn't process it due to a quota |
42015c9a AS |
115 | * limit. Make sure to try again after live migration when the quota may |
116 | * have been reset. | |
117 | */ | |
904d6f58 AL |
118 | virtio_rng_process(vrng); |
119 | ||
16c915ba AS |
120 | return 0; |
121 | } | |
122 | ||
904d6f58 AL |
123 | static void check_rate_limit(void *opaque) |
124 | { | |
125 | VirtIORNG *s = opaque; | |
126 | ||
af1a8ad6 | 127 | s->quota_remaining = s->conf.max_bytes; |
904d6f58 AL |
128 | virtio_rng_process(s); |
129 | qemu_mod_timer(s->rate_limit_timer, | |
af1a8ad6 | 130 | qemu_get_clock_ms(vm_clock) + s->conf.period_ms); |
904d6f58 AL |
131 | } |
132 | ||
46a5a89d | 133 | static int virtio_rng_device_init(VirtIODevice *vdev) |
16c915ba | 134 | { |
46a5a89d FK |
135 | DeviceState *qdev = DEVICE(vdev); |
136 | VirtIORNG *vrng = VIRTIO_RNG(vdev); | |
16c915ba AS |
137 | Error *local_err = NULL; |
138 | ||
46a5a89d FK |
139 | if (vrng->conf.rng == NULL) { |
140 | vrng->conf.default_backend = RNG_RANDOM(object_new(TYPE_RNG_RANDOM)); | |
141 | ||
142 | object_property_add_child(OBJECT(qdev), | |
143 | "default-backend", | |
144 | OBJECT(vrng->conf.default_backend), | |
145 | NULL); | |
146 | ||
147 | object_property_set_link(OBJECT(qdev), | |
148 | OBJECT(vrng->conf.default_backend), | |
149 | "rng", NULL); | |
6eac8aec | 150 | } |
16c915ba | 151 | |
46a5a89d FK |
152 | virtio_init(vdev, "virtio-rng", VIRTIO_ID_RNG, 0); |
153 | ||
154 | vrng->rng = vrng->conf.rng; | |
16c915ba AS |
155 | if (vrng->rng == NULL) { |
156 | qerror_report(QERR_INVALID_PARAMETER_VALUE, "rng", "a valid object"); | |
46a5a89d | 157 | return -1; |
16c915ba AS |
158 | } |
159 | ||
160 | rng_backend_open(vrng->rng, &local_err); | |
161 | if (local_err) { | |
162 | qerror_report_err(local_err); | |
163 | error_free(local_err); | |
46a5a89d | 164 | return -1; |
16c915ba AS |
165 | } |
166 | ||
167 | vrng->vq = virtio_add_queue(vdev, 8, handle_input); | |
6eac8aec | 168 | |
16c915ba AS |
169 | vrng->vdev.get_features = get_features; |
170 | ||
af1a8ad6 FK |
171 | assert(vrng->conf.max_bytes <= INT64_MAX); |
172 | vrng->quota_remaining = vrng->conf.max_bytes; | |
904d6f58 | 173 | |
904d6f58 AL |
174 | vrng->rate_limit_timer = qemu_new_timer_ms(vm_clock, |
175 | check_rate_limit, vrng); | |
176 | ||
177 | qemu_mod_timer(vrng->rate_limit_timer, | |
af1a8ad6 | 178 | qemu_get_clock_ms(vm_clock) + vrng->conf.period_ms); |
904d6f58 | 179 | |
46a5a89d | 180 | register_savevm(qdev, "virtio-rng", -1, 1, virtio_rng_save, |
16c915ba AS |
181 | virtio_rng_load, vrng); |
182 | ||
6eac8aec FK |
183 | return 0; |
184 | } | |
185 | ||
186 | static int virtio_rng_device_exit(DeviceState *qdev) | |
187 | { | |
188 | VirtIORNG *vrng = VIRTIO_RNG(qdev); | |
189 | VirtIODevice *vdev = VIRTIO_DEVICE(qdev); | |
190 | ||
191 | qemu_del_timer(vrng->rate_limit_timer); | |
192 | qemu_free_timer(vrng->rate_limit_timer); | |
193 | unregister_savevm(qdev, "virtio-rng", vrng); | |
194 | virtio_common_cleanup(vdev); | |
195 | return 0; | |
196 | } | |
197 | ||
198 | static Property virtio_rng_properties[] = { | |
199 | DEFINE_VIRTIO_RNG_PROPERTIES(VirtIORNG, conf), | |
200 | DEFINE_PROP_END_OF_LIST(), | |
201 | }; | |
202 | ||
203 | static void virtio_rng_class_init(ObjectClass *klass, void *data) | |
204 | { | |
205 | DeviceClass *dc = DEVICE_CLASS(klass); | |
206 | VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); | |
207 | dc->exit = virtio_rng_device_exit; | |
208 | dc->props = virtio_rng_properties; | |
209 | vdc->init = virtio_rng_device_init; | |
210 | vdc->get_features = get_features; | |
211 | } | |
212 | ||
213 | static void virtio_rng_initfn(Object *obj) | |
214 | { | |
215 | VirtIORNG *vrng = VIRTIO_RNG(obj); | |
216 | ||
217 | object_property_add_link(obj, "rng", TYPE_RNG_BACKEND, | |
218 | (Object **)&vrng->conf.rng, NULL); | |
219 | } | |
220 | ||
221 | static const TypeInfo virtio_rng_info = { | |
222 | .name = TYPE_VIRTIO_RNG, | |
223 | .parent = TYPE_VIRTIO_DEVICE, | |
224 | .instance_size = sizeof(VirtIORNG), | |
225 | .instance_init = virtio_rng_initfn, | |
226 | .class_init = virtio_rng_class_init, | |
227 | }; | |
228 | ||
229 | static void virtio_register_types(void) | |
230 | { | |
231 | type_register_static(&virtio_rng_info); | |
232 | } | |
233 | ||
234 | type_init(virtio_register_types) |