cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

spapr_rng.c (4567B)

      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)