]>
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 | |
8063396b | 33 | OBJECT_DECLARE_SIMPLE_TYPE(SpaprRngState, SPAPR_RNG) |
4d9392be | 34 | |
ce2918cb | 35 | struct SpaprRngState { |
4d9392be TH |
36 | /*< private >*/ |
37 | DeviceState ds; | |
38 | RngBackend *backend; | |
39 | bool use_kvm; | |
40 | }; | |
4d9392be TH |
41 | |
42 | struct HRandomData { | |
43 | QemuSemaphore sem; | |
44 | union { | |
45 | uint64_t v64; | |
46 | uint8_t v8[8]; | |
47 | } val; | |
48 | int received; | |
49 | }; | |
50 | typedef struct HRandomData HRandomData; | |
51 | ||
52 | /* Callback function for the RngBackend */ | |
53 | static void random_recv(void *dest, const void *src, size_t size) | |
54 | { | |
55 | HRandomData *hrdp = dest; | |
56 | ||
57 | if (src && size > 0) { | |
58 | assert(size + hrdp->received <= sizeof(hrdp->val.v8)); | |
59 | memcpy(&hrdp->val.v8[hrdp->received], src, size); | |
60 | hrdp->received += size; | |
61 | } | |
62 | ||
63 | qemu_sem_post(&hrdp->sem); | |
64 | } | |
65 | ||
66 | /* Handler for the H_RANDOM hypercall */ | |
ce2918cb | 67 | static target_ulong h_random(PowerPCCPU *cpu, SpaprMachineState *spapr, |
4d9392be TH |
68 | target_ulong opcode, target_ulong *args) |
69 | { | |
ce2918cb | 70 | SpaprRngState *rngstate; |
4d9392be TH |
71 | HRandomData hrdata; |
72 | ||
73 | rngstate = SPAPR_RNG(object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)); | |
74 | ||
75 | if (!rngstate || !rngstate->backend) { | |
76 | return H_HARDWARE; | |
77 | } | |
78 | ||
79 | qemu_sem_init(&hrdata.sem, 0); | |
80 | hrdata.val.v64 = 0; | |
81 | hrdata.received = 0; | |
82 | ||
4d9392be TH |
83 | while (hrdata.received < 8) { |
84 | rng_backend_request_entropy(rngstate->backend, 8 - hrdata.received, | |
85 | random_recv, &hrdata); | |
f1a6cf3e | 86 | qemu_mutex_unlock_iothread(); |
4d9392be | 87 | qemu_sem_wait(&hrdata.sem); |
f1a6cf3e | 88 | qemu_mutex_lock_iothread(); |
4d9392be | 89 | } |
4d9392be TH |
90 | |
91 | qemu_sem_destroy(&hrdata.sem); | |
92 | args[0] = hrdata.val.v64; | |
93 | ||
94 | return H_SUCCESS; | |
95 | } | |
96 | ||
97 | static void spapr_rng_instance_init(Object *obj) | |
98 | { | |
4d9392be TH |
99 | if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL) != NULL) { |
100 | error_report("spapr-rng can not be instantiated twice!"); | |
101 | return; | |
102 | } | |
103 | ||
4d9392be | 104 | object_property_set_description(obj, "rng", |
7eecec7d | 105 | "ID of the random number generator backend"); |
4d9392be TH |
106 | } |
107 | ||
108 | static void spapr_rng_realize(DeviceState *dev, Error **errp) | |
109 | { | |
110 | ||
ce2918cb | 111 | SpaprRngState *rngstate = SPAPR_RNG(dev); |
4d9392be TH |
112 | |
113 | if (rngstate->use_kvm) { | |
114 | if (kvmppc_enable_hwrng() == 0) { | |
115 | return; | |
116 | } | |
117 | /* | |
118 | * If user specified both, use-kvm and a backend, we fall back to | |
119 | * the backend now. If not, provide an appropriate error message. | |
120 | */ | |
121 | if (!rngstate->backend) { | |
122 | error_setg(errp, "Could not initialize in-kernel H_RANDOM call!"); | |
123 | return; | |
124 | } | |
125 | } | |
126 | ||
127 | if (rngstate->backend) { | |
128 | spapr_register_hypercall(H_RANDOM, h_random); | |
129 | } else { | |
130 | error_setg(errp, "spapr-rng needs an RNG backend!"); | |
131 | } | |
132 | } | |
133 | ||
4d9392be | 134 | static Property spapr_rng_properties[] = { |
ce2918cb DG |
135 | DEFINE_PROP_BOOL("use-kvm", SpaprRngState, use_kvm, false), |
136 | DEFINE_PROP_LINK("rng", SpaprRngState, backend, TYPE_RNG_BACKEND, | |
68c761e1 | 137 | RngBackend *), |
4d9392be TH |
138 | DEFINE_PROP_END_OF_LIST(), |
139 | }; | |
140 | ||
141 | static void spapr_rng_class_init(ObjectClass *oc, void *data) | |
142 | { | |
143 | DeviceClass *dc = DEVICE_CLASS(oc); | |
144 | ||
145 | dc->realize = spapr_rng_realize; | |
146 | set_bit(DEVICE_CATEGORY_MISC, dc->categories); | |
4f67d30b | 147 | device_class_set_props(dc, spapr_rng_properties); |
3d0db3e7 | 148 | dc->hotpluggable = false; |
4d9392be TH |
149 | } |
150 | ||
151 | static const TypeInfo spapr_rng_info = { | |
152 | .name = TYPE_SPAPR_RNG, | |
153 | .parent = TYPE_DEVICE, | |
ce2918cb | 154 | .instance_size = sizeof(SpaprRngState), |
4d9392be TH |
155 | .instance_init = spapr_rng_instance_init, |
156 | .class_init = spapr_rng_class_init, | |
157 | }; | |
158 | ||
159 | static void spapr_rng_register_type(void) | |
160 | { | |
161 | type_register_static(&spapr_rng_info); | |
162 | } | |
163 | type_init(spapr_rng_register_type) |