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 #include "qom/object.h" 32 33 typedef struct SpaprRngState SpaprRngState; 34 DECLARE_INSTANCE_CHECKER(SpaprRngState, SPAPR_RNG, 35 TYPE_SPAPR_RNG) 36 37 struct SpaprRngState { 38 /*< private >*/ 39 DeviceState ds; 40 RngBackend *backend; 41 bool use_kvm; 42 }; 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 */ 69 static target_ulong h_random(PowerPCCPU *cpu, SpaprMachineState *spapr, 70 target_ulong opcode, target_ulong *args) 71 { 72 SpaprRngState *rngstate; 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 85 while (hrdata.received < 8) { 86 rng_backend_request_entropy(rngstate->backend, 8 - hrdata.received, 87 random_recv, &hrdata); 88 qemu_mutex_unlock_iothread(); 89 qemu_sem_wait(&hrdata.sem); 90 qemu_mutex_lock_iothread(); 91 } 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 { 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 106 object_property_set_description(obj, "rng", 107 "ID of the random number generator backend"); 108 } 109 110 static 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 136 static 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 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); 149 device_class_set_props(dc, spapr_rng_properties); 150 dc->hotpluggable = false; 151 } 152 153 static 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 161 static void spapr_rng_register_type(void) 162 { 163 type_register_static(&spapr_rng_info); 164 } 165 type_init(spapr_rng_register_type) 166