LXR qemu/hw/ppc/spapr

   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
  32OBJECT_DECLARE_SIMPLE_TYPE(SpaprRngState, SPAPR_RNG)
  33
  34struct SpaprRngState {
  35    /*< private >*/
  36    DeviceState ds;
  37    RngBackend *backend;
  38    bool use_kvm;
  39};
  40
  41struct HRandomData {
  42    QemuSemaphore sem;
  43    union {
  44        uint64_t v64;
  45        uint8_t v8[8];
  46    } val;
  47    int received;
  48};
  49typedef struct HRandomData HRandomData;
  50
  51/* Callback function for the RngBackend */
  52static 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 */
  66static 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        qemu_mutex_unlock_iothread();
  86        qemu_sem_wait(&hrdata.sem);
  87        qemu_mutex_lock_iothread();
  88    }
  89
  90    qemu_sem_destroy(&hrdata.sem);
  91    args[0] = hrdata.val.v64;
  92
  93    return H_SUCCESS;
  94}
  95
  96static 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
 107static 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
 133static 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
 140static 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
 150static 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
 158static void spapr_rng_register_type(void)
 159{
 160    type_register_static(&spapr_rng_info);
 161}
 162type_init(spapr_rng_register_type)
 163