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

rocker_world.c (2140B)

      1/*
      2 * QEMU rocker switch emulation - switch worlds
      3 *
      4 * Copyright (c) 2014 Scott Feldman <sfeldma@gmail.com>
      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, or
      9 * (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
     17#include "qemu/osdep.h"
     18#include "qemu/iov.h"
     19
     20#include "rocker.h"
     21#include "rocker_world.h"
     22
     23struct world {
     24    Rocker *r;
     25    enum rocker_world_type type;
     26    WorldOps *ops;
     27};
     28
     29ssize_t world_ingress(World *world, uint32_t pport,
     30                      const struct iovec *iov, int iovcnt)
     31{
     32    if (world->ops->ig) {
     33        return world->ops->ig(world, pport, iov, iovcnt);
     34    }
     35
     36    return -1;
     37}
     38
     39int world_do_cmd(World *world, DescInfo *info,
     40                 char *buf, uint16_t cmd, RockerTlv *cmd_info_tlv)
     41{
     42    if (world->ops->cmd) {
     43        return world->ops->cmd(world, info, buf, cmd, cmd_info_tlv);
     44    }
     45
     46    return -ROCKER_ENOTSUP;
     47}
     48
     49World *world_alloc(Rocker *r, size_t sizeof_private,
     50                   enum rocker_world_type type, WorldOps *ops)
     51{
     52    World *w = g_malloc0(sizeof(World) + sizeof_private);
     53
     54    w->r = r;
     55    w->type = type;
     56    w->ops = ops;
     57    if (w->ops->init) {
     58        w->ops->init(w);
     59    }
     60
     61    return w;
     62}
     63
     64void world_free(World *world)
     65{
     66    if (world->ops->uninit) {
     67        world->ops->uninit(world);
     68    }
     69    g_free(world);
     70}
     71
     72void world_reset(World *world)
     73{
     74    if (world->ops->uninit) {
     75        world->ops->uninit(world);
     76    }
     77    if (world->ops->init) {
     78        world->ops->init(world);
     79    }
     80}
     81
     82void *world_private(World *world)
     83{
     84    return world + 1;
     85}
     86
     87Rocker *world_rocker(World *world)
     88{
     89    return world->r;
     90}
     91
     92enum rocker_world_type world_type(World *world)
     93{
     94    return world->type;
     95}
     96
     97const char *world_name(World *world)
     98{
     99    return world->ops->name;
    100}