include/hw/xen/xen-bus.h

   1 /*
   2  * Copyright (c) 2018  Citrix Systems Inc.
   3  *
   4  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   5  * See the COPYING file in the top-level directory.
   6  */
   7
   8 #ifndef HW_XEN_BUS_H
   9 #define HW_XEN_BUS_H
  10
  11 #include "hw/xen/xen_common.h"
  12 #include "hw/sysbus.h"
  13 #include "qemu/notify.h"
  14
  15 typedef void (*XenWatchHandler)(void *opaque);
  16
  17 typedef struct XenWatch XenWatch;
  18
  19 typedef struct XenDevice {
  20     DeviceState qdev;
  21     domid_t frontend_id;
  22     char *name;
  23     char *backend_path, *frontend_path;
  24     enum xenbus_state backend_state, frontend_state;
  25     Notifier exit;
  26     XenWatch *backend_state_watch, *frontend_state_watch;
  27     bool backend_online;
  28     XenWatch *backend_online_watch;
  29     xengnttab_handle *xgth;
  30     bool feature_grant_copy;
  31     xenevtchn_handle *xeh;
  32     NotifierList event_notifiers;
  33 } XenDevice;
  34
  35 typedef char *(*XenDeviceGetName)(XenDevice *xendev, Error **errp);
  36 typedef void (*XenDeviceRealize)(XenDevice *xendev, Error **errp);
  37 typedef void (*XenDeviceFrontendChanged)(XenDevice *xendev,
  38                                          enum xenbus_state frontend_state,
  39                                          Error **errp);
  40 typedef void (*XenDeviceUnrealize)(XenDevice *xendev, Error **errp);
  41
  42 typedef struct XenDeviceClass {
  43     /*< private >*/
  44     DeviceClass parent_class;
  45     /*< public >*/
  46     const char *backend;
  47     const char *device;
  48     XenDeviceGetName get_name;
  49     XenDeviceRealize realize;
  50     XenDeviceFrontendChanged frontend_changed;
  51     XenDeviceUnrealize unrealize;
  52 } XenDeviceClass;
  53
  54 #define TYPE_XEN_DEVICE "xen-device"
  55 #define XEN_DEVICE(obj) \
  56      OBJECT_CHECK(XenDevice, (obj), TYPE_XEN_DEVICE)
  57 #define XEN_DEVICE_CLASS(class) \
  58      OBJECT_CLASS_CHECK(XenDeviceClass, (class), TYPE_XEN_DEVICE)
  59 #define XEN_DEVICE_GET_CLASS(obj) \
  60      OBJECT_GET_CLASS(XenDeviceClass, (obj), TYPE_XEN_DEVICE)
  61
  62 typedef struct XenBus {
  63     BusState qbus;
  64     domid_t backend_id;
  65     struct xs_handle *xsh;
  66     NotifierList watch_notifiers;
  67 } XenBus;
  68
  69 typedef struct XenBusClass {
  70     /*< private >*/
  71     BusClass parent_class;
  72 } XenBusClass;
  73
  74 #define TYPE_XEN_BUS "xen-bus"
  75 #define XEN_BUS(obj) \
  76     OBJECT_CHECK(XenBus, (obj), TYPE_XEN_BUS)
  77 #define XEN_BUS_CLASS(class) \
  78     OBJECT_CLASS_CHECK(XenBusClass, (class), TYPE_XEN_BUS)
  79 #define XEN_BUS_GET_CLASS(obj) \
  80     OBJECT_GET_CLASS(XenBusClass, (obj), TYPE_XEN_BUS)
  81
  82 void xen_bus_init(void);
  83
  84 void xen_device_backend_set_state(XenDevice *xendev,
  85                                   enum xenbus_state state);
  86 enum xenbus_state xen_device_backend_get_state(XenDevice *xendev);
  87
  88 void xen_device_backend_printf(XenDevice *xendev, const char *key,
  89                                const char *fmt, ...)
  90     GCC_FMT_ATTR(3, 4);
  91 void xen_device_frontend_printf(XenDevice *xendev, const char *key,
  92                                 const char *fmt, ...)
  93     GCC_FMT_ATTR(3, 4);
  94
  95 int xen_device_frontend_scanf(XenDevice *xendev, const char *key,
  96                               const char *fmt, ...);
  97
  98 void xen_device_set_max_grant_refs(XenDevice *xendev, unsigned int nr_refs,
  99                                    Error **errp);
 100 void *xen_device_map_grant_refs(XenDevice *xendev, uint32_t *refs,
 101                                 unsigned int nr_refs, int prot,
 102                                 Error **errp);
 103 void xen_device_unmap_grant_refs(XenDevice *xendev, void *map,
 104                                  unsigned int nr_refs, Error **errp);
 105
 106 typedef struct XenDeviceGrantCopySegment {
 107     union {
 108         void *virt;
 109         struct {
 110             uint32_t ref;
 111             off_t offset;
 112         } foreign;
 113     } source, dest;
 114     size_t len;
 115 } XenDeviceGrantCopySegment;
 116
 117 void xen_device_copy_grant_refs(XenDevice *xendev, bool to_domain,
 118                                 XenDeviceGrantCopySegment segs[],
 119                                 unsigned int nr_segs, Error **errp);
 120
 121 typedef struct XenEventChannel XenEventChannel;
 122
 123 typedef void (*XenEventHandler)(void *opaque);
 124
 125 XenEventChannel *xen_device_bind_event_channel(XenDevice *xendev,
 126                                                unsigned int port,
 127                                                XenEventHandler handler,
 128                                                void *opaque, Error **errp);
 129 void xen_device_notify_event_channel(XenDevice *xendev,
 130                                      XenEventChannel *channel,
 131                                      Error **errp);
 132 void xen_device_unbind_event_channel(XenDevice *xendev,
 133                                      XenEventChannel *channel,
 134                                      Error **errp);
 135
 136 #endif /* HW_XEN_BUS_H */