]>
Commit | Line | Data |
---|---|---|
4d9392be TH |
1 | /* |
2 | * QEMU sPAPR random number generator "device" for H_RANDOM hypercall | |
3 | * | |
4 | * Copyright 2015 Thomas Huth, Red Hat Inc. | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, | |
9 | * or (at your option) any later version. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, see <http://www.gnu.org/licenses/>. | |
18 | */ | |
19 | ||
0d75590d | 20 | #include "qemu/osdep.h" |
da34e65c | 21 | #include "qapi/error.h" |
4771d756 | 22 | #include "cpu.h" |
4d9392be | 23 | #include "qemu/error-report.h" |
db725815 | 24 | #include "qemu/main-loop.h" |
0b8fa32f | 25 | #include "qemu/module.h" |
4d9392be TH |
26 | #include "sysemu/device_tree.h" |
27 | #include "sysemu/rng.h" | |
28 | #include "hw/ppc/spapr.h" | |
a27bd6c7 | 29 | #include "hw/qdev-properties.h" |
4d9392be | 30 | #include "kvm_ppc.h" |
db1015e9 | 31 | #include "qom/object.h" |
4d9392be | 32 | |
db1015e9 | 33 | typedef struct SpaprRngState SpaprRngState; |
8110fa1d EH |
34 | DECLARE_INSTANCE_CHECKER(SpaprRngState, SPAPR_RNG, |
35 | TYPE_SPAPR_RNG) | |
4d9392be | 36 | |
ce2918cb | 37 | struct SpaprRngState { |
4d9392be TH |
38 | /*< private >*/ |
39 | DeviceState ds; | |
40 | RngBackend *backend; | |
41 | bool use_kvm; | |
42 | }; | |
4d9392be TH |
43 | |
44 | struct HRandomData { | |
45 | QemuSemaphore sem; | |
46 | union { | |
47 | uint64_t v64; | |
48 | uint8_t v8[8]; | |
49 | } val; | |
50 | int received; | |
51 | }; | |
52 | typedef struct HRandomData HRandomData; | |
53 | ||
54 | /* Callback function for the RngBackend */ | |
55 | static void random_recv(void *dest, const void *src, size_t size) | |
56 | { | |
57 | HRandomData *hrdp = dest; | |
58 | ||
59 | if (src && size > 0) { | |
60 | assert(size + hrdp->received <= sizeof(hrdp->val.v8)); | |
61 | memcpy(&hrdp->val.v8[hrdp->received], src, size); | |
62 | hrdp->received += size; | |
63 | } | |
64 | ||
65 | qemu_sem_post(&hrdp->sem); | |
66 | } | |
67 | ||
68 | /* Handler for the H_RANDOM hypercall */ | |
ce2918cb | 69 | static target_ulong h_random(PowerPCCPU *cpu, SpaprMachineState *spapr, |
4d9392be TH |
70 | target_ulong opcode, target_ulong *args) |
71 | { | |
ce2918cb | 72 | SpaprRngState *rngstate; |
4d9392be TH |
73 | HRandomData hrdata; |
74 | ||
75 | rngstate = SPAPR_RNG(object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)); | |
76 | ||
77 | if (!rngstate || !rngstate->backend) { | |
78 | return H_HARDWARE; | |
79 | } | |
80 | ||
81 | qemu_sem_init(&hrdata.sem, 0); | |
82 | hrdata.val.v64 = 0; | |
83 | hrdata.received = 0; | |
84 | ||
4d9392be TH |
85 | while (hrdata.received < 8) { |
86 | rng_backend_request_entropy(rngstate->backend, 8 - hrdata.received, | |
87 | random_recv, &hrdata); | |
f1a6cf3e | 88 | qemu_mutex_unlock_iothread(); |
4d9392be | 89 | qemu_sem_wait(&hrdata.sem); |
f1a6cf3e | 90 | qemu_mutex_lock_iothread(); |
4d9392be | 91 | } |
4d9392be TH |
92 | |
93 | qemu_sem_destroy(&hrdata.sem); | |
94 | args[0] = hrdata.val.v64; | |
95 | ||
96 | return H_SUCCESS; | |
97 | } | |
98 | ||
99 | static void spapr_rng_instance_init(Object *obj) | |
100 | { | |
4d9392be TH |
101 | if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL) != NULL) { |
102 | error_report("spapr-rng can not be instantiated twice!"); | |
103 | return; | |
104 | } | |
105 | ||
4d9392be | 106 | object_property_set_description(obj, "rng", |
7eecec7d | 107 | "ID of the random number generator backend"); |
4d9392be TH |
108 | } |
109 | ||
110 | static void spapr_rng_realize(DeviceState *dev, Error **errp) | |
111 | { | |
112 | ||
ce2918cb | 113 | SpaprRngState *rngstate = SPAPR_RNG(dev); |
4d9392be TH |
114 | |
115 | if (rngstate->use_kvm) { | |
116 | if (kvmppc_enable_hwrng() == 0) { | |
117 | return; | |
118 | } | |
119 | /* | |
120 | * If user specified both, use-kvm and a backend, we fall back to | |
121 | * the backend now. If not, provide an appropriate error message. | |
122 | */ | |
123 | if (!rngstate->backend) { | |
124 | error_setg(errp, "Could not initialize in-kernel H_RANDOM call!"); | |
125 | return; | |
126 | } | |
127 | } | |
128 | ||
129 | if (rngstate->backend) { | |
130 | spapr_register_hypercall(H_RANDOM, h_random); | |
131 | } else { | |
132 | error_setg(errp, "spapr-rng needs an RNG backend!"); | |
133 | } | |
134 | } | |
135 | ||
4d9392be | 136 | static Property spapr_rng_properties[] = { |
ce2918cb DG |
137 | DEFINE_PROP_BOOL("use-kvm", SpaprRngState, use_kvm, false), |
138 | DEFINE_PROP_LINK("rng", SpaprRngState, backend, TYPE_RNG_BACKEND, | |
68c761e1 | 139 | RngBackend *), |
4d9392be TH |
140 | DEFINE_PROP_END_OF_LIST(), |
141 | }; | |
142 | ||
143 | static void spapr_rng_class_init(ObjectClass *oc, void *data) | |
144 | { | |
145 | DeviceClass *dc = DEVICE_CLASS(oc); | |
146 | ||
147 | dc->realize = spapr_rng_realize; | |
148 | set_bit(DEVICE_CATEGORY_MISC, dc->categories); | |
4f67d30b | 149 | device_class_set_props(dc, spapr_rng_properties); |
3d0db3e7 | 150 | dc->hotpluggable = false; |
4d9392be TH |
151 | } |
152 | ||
153 | static const TypeInfo spapr_rng_info = { | |
154 | .name = TYPE_SPAPR_RNG, | |
155 | .parent = TYPE_DEVICE, | |
ce2918cb | 156 | .instance_size = sizeof(SpaprRngState), |
4d9392be TH |
157 | .instance_init = spapr_rng_instance_init, |
158 | .class_init = spapr_rng_class_init, | |
159 | }; | |
160 | ||
161 | static void spapr_rng_register_type(void) | |
162 | { | |
163 | type_register_static(&spapr_rng_info); | |
164 | } | |
165 | type_init(spapr_rng_register_type) |