hw/ppc/spapr_rng.c

   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/sysemu.h"
  27 #include "sysemu/device_tree.h"
  28 #include "sysemu/rng.h"
  29 #include "hw/ppc/spapr.h"
  30 #include "kvm_ppc.h"
  31
  32 #define SPAPR_RNG(obj) \
  33     OBJECT_CHECK(SpaprRngState, (obj), TYPE_SPAPR_RNG)
  34
  35 struct SpaprRngState {
  36     /*< private >*/
  37     DeviceState ds;
  38     RngBackend *backend;
  39     bool use_kvm;
  40 };
  41 typedef struct SpaprRngState SpaprRngState;
  42
  43 struct HRandomData {
  44     QemuSemaphore sem;
  45     union {
  46         uint64_t v64;
  47         uint8_t v8[8];
  48     } val;
  49     int received;
  50 };
  51 typedef struct HRandomData HRandomData;
  52
  53 /* Callback function for the RngBackend */
  54 static 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 */
  68 static 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
  98 static 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
 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     dc->props = 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)