qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

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 
     19 typedef struct HotplugHandlerClass HotplugHandlerClass;
     20 DECLARE_CLASS_CHECKERS(HotplugHandlerClass, HOTPLUG_HANDLER,
     21                        TYPE_HOTPLUG_HANDLER)
     22 #define HOTPLUG_HANDLER(obj) \
     23      INTERFACE_CHECK(HotplugHandler, (obj), TYPE_HOTPLUG_HANDLER)
     24 
     25 typedef 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  */
     33 typedef 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  */
     52 struct 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  */
     68 void 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  */
     77 void 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  */
     86 void 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  */
     94 void hotplug_handler_unplug(HotplugHandler *plug_handler,
     95                             DeviceState *plugged_dev,
     96                             Error **errp);
     97 #endif