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

hotplug.h (2893B)

      1/*
      2 * Hotplug handler interface.
      3 *
      4 * Copyright (c) 2014 Red Hat Inc.
      5 *
      6 * Authors:
      7 *  Igor Mammedov <imammedo@redhat.com>,
      8 *
      9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
     10 * See the COPYING file in the top-level directory.
     11 */
     12#ifndef HOTPLUG_H
     13#define HOTPLUG_H
     14
     15#include "qom/object.h"
     16
     17#define TYPE_HOTPLUG_HANDLER "hotplug-handler"
     18
     19typedef struct HotplugHandlerClass HotplugHandlerClass;
     20DECLARE_CLASS_CHECKERS(HotplugHandlerClass, HOTPLUG_HANDLER,
     21                       TYPE_HOTPLUG_HANDLER)
     22#define HOTPLUG_HANDLER(obj) \
     23     INTERFACE_CHECK(HotplugHandler, (obj), TYPE_HOTPLUG_HANDLER)
     24
     25typedef struct HotplugHandler HotplugHandler;
     26
     27/**
     28 * hotplug_fn:
     29 * @plug_handler: a device performing plug/uplug action
     30 * @plugged_dev: a device that has been (un)plugged
     31 * @errp: returns an error if this function fails
     32 */
     33typedef void (*hotplug_fn)(HotplugHandler *plug_handler,
     34                           DeviceState *plugged_dev, Error **errp);
     35
     36/**
     37 * HotplugDeviceClass:
     38 *
     39 * Interface to be implemented by a device performing
     40 * hardware (un)plug functions.
     41 *
     42 * @parent: Opaque parent interface.
     43 * @pre_plug: pre plug callback called at start of device.realize(true)
     44 * @plug: plug callback called at end of device.realize(true).
     45 * @unplug_request: unplug request callback.
     46 *                  Used as a means to initiate device unplug for devices that
     47 *                  require asynchronous unplug handling.
     48 * @unplug: unplug callback.
     49 *          Used for device removal with devices that implement
     50 *          asynchronous and synchronous (surprise) removal.
     51 */
     52struct HotplugHandlerClass {
     53    /* <private> */
     54    InterfaceClass parent;
     55
     56    /* <public> */
     57    hotplug_fn pre_plug;
     58    hotplug_fn plug;
     59    hotplug_fn unplug_request;
     60    hotplug_fn unplug;
     61};
     62
     63/**
     64 * hotplug_handler_plug:
     65 *
     66 * Call #HotplugHandlerClass.plug callback of @plug_handler.
     67 */
     68void hotplug_handler_plug(HotplugHandler *plug_handler,
     69                          DeviceState *plugged_dev,
     70                          Error **errp);
     71
     72/**
     73 * hotplug_handler_pre_plug:
     74 *
     75 * Call #HotplugHandlerClass.pre_plug callback of @plug_handler.
     76 */
     77void hotplug_handler_pre_plug(HotplugHandler *plug_handler,
     78                              DeviceState *plugged_dev,
     79                              Error **errp);
     80
     81/**
     82 * hotplug_handler_unplug_request:
     83 *
     84 * Calls #HotplugHandlerClass.unplug_request callback of @plug_handler.
     85 */
     86void hotplug_handler_unplug_request(HotplugHandler *plug_handler,
     87                                    DeviceState *plugged_dev,
     88                                    Error **errp);
     89/**
     90 * hotplug_handler_unplug:
     91 *
     92 * Calls #HotplugHandlerClass.unplug callback of @plug_handler.
     93 */
     94void hotplug_handler_unplug(HotplugHandler *plug_handler,
     95                            DeviceState *plugged_dev,
     96                            Error **errp);
     97#endif