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