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 "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