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
20#include "qemu/osdep.h"
21#include "qapi/error.h"
22#include "cpu.h"
23#include "qemu/error-report.h"
24#include "qemu/main-loop.h"
25#include "qemu/module.h"
26#include "sysemu/device_tree.h"
27#include "sysemu/rng.h"
28#include "hw/ppc/spapr.h"
29#include "hw/qdev-properties.h"
30#include "kvm_ppc.h"
31
32#define SPAPR_RNG(obj) \
33 OBJECT_CHECK(SpaprRngState, (obj), TYPE_SPAPR_RNG)
34
35struct SpaprRngState {
36 /*< private >*/
37 DeviceState ds;
38 RngBackend *backend;
39 bool use_kvm;
40};
41typedef struct SpaprRngState SpaprRngState;
42
43struct HRandomData {
44 QemuSemaphore sem;
45 union {
46 uint64_t v64;
47 uint8_t v8[8];
48 } val;
49 int received;
50};
51typedef struct HRandomData HRandomData;
52
53/* Callback function for the RngBackend */
54static void random_recv(void *dest, const void *src, size_t size)
55{
56 HRandomData *hrdp = dest;
57
58 if (src && size > 0) {
59 assert(size + hrdp->received <= sizeof(hrdp->val.v8));
60 memcpy(&hrdp->val.v8[hrdp->received], src, size);
61 hrdp->received += size;
62 }
63
64 qemu_sem_post(&hrdp->sem);
65}
66
67/* Handler for the H_RANDOM hypercall */
68static target_ulong h_random(PowerPCCPU *cpu, SpaprMachineState *spapr,
69 target_ulong opcode, target_ulong *args)
70{
71 SpaprRngState *rngstate;
72 HRandomData hrdata;
73
74 rngstate = SPAPR_RNG(object_resolve_path_type("", TYPE_SPAPR_RNG, NULL));
75
76 if (!rngstate || !rngstate->backend) {
77 return H_HARDWARE;
78 }
79
80 qemu_sem_init(&hrdata.sem, 0);
81 hrdata.val.v64 = 0;
82 hrdata.received = 0;
83
84 while (hrdata.received < 8) {
85 rng_backend_request_entropy(rngstate->backend, 8 - hrdata.received,
86 random_recv, &hrdata);
87 qemu_mutex_unlock_iothread();
88 qemu_sem_wait(&hrdata.sem);
89 qemu_mutex_lock_iothread();
90 }
91
92 qemu_sem_destroy(&hrdata.sem);
93 args[0] = hrdata.val.v64;
94
95 return H_SUCCESS;
96}
97
98static void spapr_rng_instance_init(Object *obj)
99{
100 if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL) != NULL) {
101 error_report("spapr-rng can not be instantiated twice!");
102 return;
103 }
104
105 object_property_set_description(obj, "rng",
106 "ID of the random number generator backend",
107 NULL);
108}
109
110static void spapr_rng_realize(DeviceState *dev, Error **errp)
111{
112
113 SpaprRngState *rngstate = SPAPR_RNG(dev);
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
136static Property spapr_rng_properties[] = {
137 DEFINE_PROP_BOOL("use-kvm", SpaprRngState, use_kvm, false),
138 DEFINE_PROP_LINK("rng", SpaprRngState, backend, TYPE_RNG_BACKEND,
139 RngBackend *),
140 DEFINE_PROP_END_OF_LIST(),
141};
142
143static 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);
149 dc->props = spapr_rng_properties;
150 dc->hotpluggable = false;
151}
152
153static const TypeInfo spapr_rng_info = {
154 .name = TYPE_SPAPR_RNG,
155 .parent = TYPE_DEVICE,
156 .instance_size = sizeof(SpaprRngState),
157 .instance_init = spapr_rng_instance_init,
158 .class_init = spapr_rng_class_init,
159};
160
161static void spapr_rng_register_type(void)
162{
163 type_register_static(&spapr_rng_info);
164}
165type_init(spapr_rng_register_type)
166