| Message ID | 1430976839-13944-18-git-send-email-david@gibson.dropbear.id.au |
|---|---|
| State | New |
| Headers | show |
On 07.05.15 07:33, David Gibson wrote: > From: Michael Roth <mdroth@linux.vnet.ibm.com> > > This device emulates a firmware abstraction used by pSeries guests to > manage hotplug/dynamic-reconfiguration of host-bridges, PCI devices, > memory, and CPUs. It is conceptually similar to an SHPC device, > complete with LED indicators to identify individual slots to physical > physical users and indicate when it is safe to remove a device. In > some cases it is also used to manage virtualized resources, such a > memory, CPUs, and physical-host bridges, which in the case of pSeries > guests are virtualized resources where the physical components are > managed by the host. > > Guests communicate with these DR Connectors using RTAS calls, > generally by addressing the unique DRC index associated with a > particular connector for a particular resource. For introspection > purposes we expose this state initially as QOM properties, and > in subsequent patches will introduce the RTAS calls that make use of > it. This constitutes to the 'guest' interface. > > On the QEMU side we provide an attach/detach interface to associate > or cleanup a DeviceState with a particular sPAPRDRConnector in > response to hotplug/unplug, respectively. This constitutes the > 'physical' interface to the DR Connector. > > Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com> > Reviewed-by: David Gibson <david@gibson.dropbear.id.au> > Signed-off-by: David Gibson <david@gibson.dropbear.id.au> > --- > hw/ppc/Makefile.objs | 2 +- > hw/ppc/spapr_drc.c | 588 +++++++++++++++++++++++++++++++++++++++++++++ > include/hw/ppc/spapr_drc.h | 199 +++++++++++++++ > 3 files changed, 788 insertions(+), 1 deletion(-) > create mode 100644 hw/ppc/spapr_drc.c > create mode 100644 include/hw/ppc/spapr_drc.h > > diff --git a/hw/ppc/Makefile.objs b/hw/ppc/Makefile.objs > index 437955d..c8ab06e 100644 > --- a/hw/ppc/Makefile.objs > +++ b/hw/ppc/Makefile.objs > @@ -3,7 +3,7 @@ obj-y += ppc.o ppc_booke.o > # IBM pSeries (sPAPR) > obj-$(CONFIG_PSERIES) += spapr.o spapr_vio.o spapr_events.o > obj-$(CONFIG_PSERIES) += spapr_hcall.o spapr_iommu.o spapr_rtas.o > -obj-$(CONFIG_PSERIES) += spapr_pci.o spapr_rtc.o > +obj-$(CONFIG_PSERIES) += spapr_pci.o spapr_rtc.o spapr_drc.o > ifeq ($(CONFIG_PCI)$(CONFIG_PSERIES)$(CONFIG_LINUX), yyy) > obj-y += spapr_pci_vfio.o > endif > diff --git a/hw/ppc/spapr_drc.c b/hw/ppc/spapr_drc.c > new file mode 100644 > index 0000000..047c6c7 > --- /dev/null > +++ b/hw/ppc/spapr_drc.c > @@ -0,0 +1,588 @@ > +/* > + * QEMU SPAPR Dynamic Reconfiguration Connector Implementation > + * > + * Copyright IBM Corp. 2014 > + * > + * Authors: > + * Michael Roth <mdroth@linux.vnet.ibm.com> > + * > + * This work is licensed under the terms of the GNU GPL, version 2 or later. > + * See the COPYING file in the top-level directory. > + */ > + > +#include "hw/ppc/spapr_drc.h" > +#include "qom/object.h" > +#include "hw/qdev.h" > +#include "qapi/visitor.h" > +#include "qemu/error-report.h" > + > +/* #define DEBUG_SPAPR_DRC */ > + > +#ifdef DEBUG_SPAPR_DRC > +#define DPRINTF(fmt, ...) \ > + do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) > +#define DPRINTFN(fmt, ...) \ > + do { DPRINTF(fmt, ## __VA_ARGS__); fprintf(stderr, "\n"); } while (0) > +#else > +#define DPRINTF(fmt, ...) \ > + do { } while (0) > +#define DPRINTFN(fmt, ...) \ > + do { } while (0) > +#endif > + > +#define DRC_CONTAINER_PATH "/dr-connector" > +#define DRC_INDEX_TYPE_SHIFT 28 > +#define DRC_INDEX_ID_MASK (~(~0 << DRC_INDEX_TYPE_SHIFT)) > + > +static sPAPRDRConnectorTypeShift get_type_shift(sPAPRDRConnectorType type) > +{ > + uint32_t shift = 0; > + > + /* make sure this isn't SPAPR_DR_CONNECTOR_TYPE_ANY, or some > + * other wonky value. > + */ > + g_assert(is_power_of_2(type)); > + > + while (type != (1 << shift)) { > + shift++; > + } > + return shift; > +} > + > +static uint32_t get_index(sPAPRDRConnector *drc) > +{ > + /* no set format for a drc index: it only needs to be globally > + * unique. this is how we encode the DRC type on bare-metal > + * however, so might as well do that here > + */ > + return (get_type_shift(drc->type) << DRC_INDEX_TYPE_SHIFT) | > + (drc->id & DRC_INDEX_ID_MASK); > +} > + > +static int set_isolation_state(sPAPRDRConnector *drc, > + sPAPRDRIsolationState state) > +{ > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > + > + DPRINTFN("drc: %x, set_isolation_state: %x", get_index(drc), state); > + > + drc->isolation_state = state; > + > + if (drc->isolation_state == SPAPR_DR_ISOLATION_STATE_ISOLATED) { > + /* if we're awaiting release, but still in an unconfigured state, > + * it's likely the guest is still in the process of configuring > + * the device and is transitioning the devices to an ISOLATED > + * state as a part of that process. so we only complete the > + * removal when this transition happens for a device in a > + * configured state, as suggested by the state diagram from > + * PAPR+ 2.7, 13.4 > + */ > + if (drc->awaiting_release) { > + if (drc->configured) { > + DPRINTFN("finalizing device removal"); > + drck->detach(drc, DEVICE(drc->dev), drc->detach_cb, > + drc->detach_cb_opaque, NULL); > + } else { > + DPRINTFN("deferring device removal on unconfigured device\n"); > + } > + } > + drc->configured = false; > + } > + > + return 0; > +} > + > +static int set_indicator_state(sPAPRDRConnector *drc, > + sPAPRDRIndicatorState state) > +{ > + DPRINTFN("drc: %x, set_indicator_state: %x", get_index(drc), state); > + drc->indicator_state = state; > + return 0; > +} > + > +static int set_allocation_state(sPAPRDRConnector *drc, > + sPAPRDRAllocationState state) > +{ > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > + > + DPRINTFN("drc: %x, set_allocation_state: %x", get_index(drc), state); > + > + if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI) { > + drc->allocation_state = state; > + if (drc->awaiting_release && > + drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) { > + DPRINTFN("finalizing device removal"); > + drck->detach(drc, DEVICE(drc->dev), drc->detach_cb, > + drc->detach_cb_opaque, NULL); > + } > + } > + return 0; > +} > + > +static uint32_t get_type(sPAPRDRConnector *drc) > +{ > + return drc->type; > +} > + > +static const char *get_name(sPAPRDRConnector *drc) > +{ > + return drc->name; > +} > + > +static const void *get_fdt(sPAPRDRConnector *drc, int *fdt_start_offset) > +{ > + if (fdt_start_offset) { > + *fdt_start_offset = drc->fdt_start_offset; > + } > + return drc->fdt; > +} > + > +static void set_configured(sPAPRDRConnector *drc) > +{ > + DPRINTFN("drc: %x, set_configured", get_index(drc)); > + > + if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_UNISOLATED) { > + /* guest should be not configuring an isolated device */ > + DPRINTFN("drc: %x, set_configured: skipping isolated device", > + get_index(drc)); > + return; > + } > + drc->configured = true; > +} > + > +/* > + * dr-entity-sense sensor value > + * returned via get-sensor-state RTAS calls > + * as expected by state diagram in PAPR+ 2.7, 13.4 > + * based on the current allocation/indicator/power states > + * for the DR connector. > + */ > +static sPAPRDREntitySense entity_sense(sPAPRDRConnector *drc) > +{ > + sPAPRDREntitySense state; > + > + if (drc->dev) { > + if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI && > + drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) { > + /* for logical DR, we return a state of UNUSABLE > + * iff the allocation state UNUSABLE. > + * Otherwise, report the state as USABLE/PRESENT, > + * as we would for PCI. > + */ > + state = SPAPR_DR_ENTITY_SENSE_UNUSABLE; > + } else { > + /* this assumes all PCI devices are assigned to > + * a 'live insertion' power domain, where QEMU > + * manages power state automatically as opposed > + * to the guest. present, non-PCI resources are > + * unaffected by power state. > + */ > + state = SPAPR_DR_ENTITY_SENSE_PRESENT; > + } > + } else { > + if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) { > + /* PCI devices, and only PCI devices, use EMPTY > + * in cases where we'd otherwise use UNUSABLE > + */ > + state = SPAPR_DR_ENTITY_SENSE_EMPTY; > + } else { > + state = SPAPR_DR_ENTITY_SENSE_UNUSABLE; > + } > + } > + > + DPRINTFN("drc: %x, entity_sense: %x", get_index(drc), state); > + return state; > +} > + > +static void prop_get_index(Object *obj, Visitor *v, void *opaque, > + const char *name, Error **errp) > +{ > + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > + uint32_t value = (uint32_t)drck->get_index(drc); > + visit_type_uint32(v, &value, name, errp); > +} > + > +static void prop_get_type(Object *obj, Visitor *v, void *opaque, > + const char *name, Error **errp) > +{ > + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > + uint32_t value = (uint32_t)drck->get_type(drc); > + visit_type_uint32(v, &value, name, errp); > +} > + > +static char *prop_get_name(Object *obj, Error **errp) > +{ > + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > + return g_strdup(drck->get_name(drc)); > +} > + > +static void prop_get_entity_sense(Object *obj, Visitor *v, void *opaque, > + const char *name, Error **errp) > +{ > + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > + uint32_t value = (uint32_t)drck->entity_sense(drc); > + visit_type_uint32(v, &value, name, errp); > +} > + > +static void prop_get_fdt(Object *obj, Visitor *v, void *opaque, > + const char *name, Error **errp) > +{ > + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); > + int fdt_offset_next, fdt_offset, fdt_depth; > + void *fdt; > + > + if (!drc->fdt) { > + return; > + } > + > + fdt = drc->fdt; > + fdt_offset = drc->fdt_start_offset; > + fdt_depth = 0; > + > + do { > + const char *name = NULL; > + const struct fdt_property *prop = NULL; > + int prop_len = 0, name_len = 0; > + uint32_t tag; > + > + tag = fdt_next_tag(fdt, fdt_offset, &fdt_offset_next); > + switch (tag) { > + case FDT_BEGIN_NODE: > + fdt_depth++; > + name = fdt_get_name(fdt, fdt_offset, &name_len); > + visit_start_struct(v, NULL, NULL, name, 0, NULL); > + break; > + case FDT_END_NODE: > + /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */ > + g_assert(fdt_depth > 0); > + visit_end_struct(v, NULL); > + fdt_depth--; > + break; > + case FDT_PROP: { > + int i; > + prop = fdt_get_property_by_offset(fdt, fdt_offset, &prop_len); Did this fdt function only get introduced recently? My test system has 1.3.0 installed which doesn't contain it apparently. Please add a configure check to verify it actually exists if it's really necessary. Alex
On Fri, May 08, 2015 at 12:39:20AM +0200, Alexander Graf wrote: > > > On 07.05.15 07:33, David Gibson wrote: > > From: Michael Roth <mdroth@linux.vnet.ibm.com> > > > > This device emulates a firmware abstraction used by pSeries guests to > > manage hotplug/dynamic-reconfiguration of host-bridges, PCI devices, > > memory, and CPUs. It is conceptually similar to an SHPC device, > > complete with LED indicators to identify individual slots to physical > > physical users and indicate when it is safe to remove a device. In > > some cases it is also used to manage virtualized resources, such a > > memory, CPUs, and physical-host bridges, which in the case of pSeries > > guests are virtualized resources where the physical components are > > managed by the host. > > > > Guests communicate with these DR Connectors using RTAS calls, > > generally by addressing the unique DRC index associated with a > > particular connector for a particular resource. For introspection > > purposes we expose this state initially as QOM properties, and > > in subsequent patches will introduce the RTAS calls that make use of > > it. This constitutes to the 'guest' interface. > > > > On the QEMU side we provide an attach/detach interface to associate > > or cleanup a DeviceState with a particular sPAPRDRConnector in > > response to hotplug/unplug, respectively. This constitutes the > > 'physical' interface to the DR Connector. > > > > Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com> > > Reviewed-by: David Gibson <david@gibson.dropbear.id.au> > > Signed-off-by: David Gibson <david@gibson.dropbear.id.au> > > --- > > hw/ppc/Makefile.objs | 2 +- > > hw/ppc/spapr_drc.c | 588 +++++++++++++++++++++++++++++++++++++++++++++ > > include/hw/ppc/spapr_drc.h | 199 +++++++++++++++ > > 3 files changed, 788 insertions(+), 1 deletion(-) > > create mode 100644 hw/ppc/spapr_drc.c > > create mode 100644 include/hw/ppc/spapr_drc.h > > > > diff --git a/hw/ppc/Makefile.objs b/hw/ppc/Makefile.objs > > index 437955d..c8ab06e 100644 > > --- a/hw/ppc/Makefile.objs > > +++ b/hw/ppc/Makefile.objs > > @@ -3,7 +3,7 @@ obj-y += ppc.o ppc_booke.o > > # IBM pSeries (sPAPR) > > obj-$(CONFIG_PSERIES) += spapr.o spapr_vio.o spapr_events.o > > obj-$(CONFIG_PSERIES) += spapr_hcall.o spapr_iommu.o spapr_rtas.o > > -obj-$(CONFIG_PSERIES) += spapr_pci.o spapr_rtc.o > > +obj-$(CONFIG_PSERIES) += spapr_pci.o spapr_rtc.o spapr_drc.o > > ifeq ($(CONFIG_PCI)$(CONFIG_PSERIES)$(CONFIG_LINUX), yyy) > > obj-y += spapr_pci_vfio.o > > endif > > diff --git a/hw/ppc/spapr_drc.c b/hw/ppc/spapr_drc.c > > new file mode 100644 > > index 0000000..047c6c7 > > --- /dev/null > > +++ b/hw/ppc/spapr_drc.c > > @@ -0,0 +1,588 @@ > > +/* > > + * QEMU SPAPR Dynamic Reconfiguration Connector Implementation > > + * > > + * Copyright IBM Corp. 2014 > > + * > > + * Authors: > > + * Michael Roth <mdroth@linux.vnet.ibm.com> > > + * > > + * This work is licensed under the terms of the GNU GPL, version 2 or later. > > + * See the COPYING file in the top-level directory. > > + */ > > + > > +#include "hw/ppc/spapr_drc.h" > > +#include "qom/object.h" > > +#include "hw/qdev.h" > > +#include "qapi/visitor.h" > > +#include "qemu/error-report.h" > > + > > +/* #define DEBUG_SPAPR_DRC */ > > + > > +#ifdef DEBUG_SPAPR_DRC > > +#define DPRINTF(fmt, ...) \ > > + do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) > > +#define DPRINTFN(fmt, ...) \ > > + do { DPRINTF(fmt, ## __VA_ARGS__); fprintf(stderr, "\n"); } while (0) > > +#else > > +#define DPRINTF(fmt, ...) \ > > + do { } while (0) > > +#define DPRINTFN(fmt, ...) \ > > + do { } while (0) > > +#endif > > + > > +#define DRC_CONTAINER_PATH "/dr-connector" > > +#define DRC_INDEX_TYPE_SHIFT 28 > > +#define DRC_INDEX_ID_MASK (~(~0 << DRC_INDEX_TYPE_SHIFT)) > > + > > +static sPAPRDRConnectorTypeShift get_type_shift(sPAPRDRConnectorType type) > > +{ > > + uint32_t shift = 0; > > + > > + /* make sure this isn't SPAPR_DR_CONNECTOR_TYPE_ANY, or some > > + * other wonky value. > > + */ > > + g_assert(is_power_of_2(type)); > > + > > + while (type != (1 << shift)) { > > + shift++; > > + } > > + return shift; > > +} > > + > > +static uint32_t get_index(sPAPRDRConnector *drc) > > +{ > > + /* no set format for a drc index: it only needs to be globally > > + * unique. this is how we encode the DRC type on bare-metal > > + * however, so might as well do that here > > + */ > > + return (get_type_shift(drc->type) << DRC_INDEX_TYPE_SHIFT) | > > + (drc->id & DRC_INDEX_ID_MASK); > > +} > > + > > +static int set_isolation_state(sPAPRDRConnector *drc, > > + sPAPRDRIsolationState state) > > +{ > > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > > + > > + DPRINTFN("drc: %x, set_isolation_state: %x", get_index(drc), state); > > + > > + drc->isolation_state = state; > > + > > + if (drc->isolation_state == SPAPR_DR_ISOLATION_STATE_ISOLATED) { > > + /* if we're awaiting release, but still in an unconfigured state, > > + * it's likely the guest is still in the process of configuring > > + * the device and is transitioning the devices to an ISOLATED > > + * state as a part of that process. so we only complete the > > + * removal when this transition happens for a device in a > > + * configured state, as suggested by the state diagram from > > + * PAPR+ 2.7, 13.4 > > + */ > > + if (drc->awaiting_release) { > > + if (drc->configured) { > > + DPRINTFN("finalizing device removal"); > > + drck->detach(drc, DEVICE(drc->dev), drc->detach_cb, > > + drc->detach_cb_opaque, NULL); > > + } else { > > + DPRINTFN("deferring device removal on unconfigured device\n"); > > + } > > + } > > + drc->configured = false; > > + } > > + > > + return 0; > > +} > > + > > +static int set_indicator_state(sPAPRDRConnector *drc, > > + sPAPRDRIndicatorState state) > > +{ > > + DPRINTFN("drc: %x, set_indicator_state: %x", get_index(drc), state); > > + drc->indicator_state = state; > > + return 0; > > +} > > + > > +static int set_allocation_state(sPAPRDRConnector *drc, > > + sPAPRDRAllocationState state) > > +{ > > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > > + > > + DPRINTFN("drc: %x, set_allocation_state: %x", get_index(drc), state); > > + > > + if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI) { > > + drc->allocation_state = state; > > + if (drc->awaiting_release && > > + drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) { > > + DPRINTFN("finalizing device removal"); > > + drck->detach(drc, DEVICE(drc->dev), drc->detach_cb, > > + drc->detach_cb_opaque, NULL); > > + } > > + } > > + return 0; > > +} > > + > > +static uint32_t get_type(sPAPRDRConnector *drc) > > +{ > > + return drc->type; > > +} > > + > > +static const char *get_name(sPAPRDRConnector *drc) > > +{ > > + return drc->name; > > +} > > + > > +static const void *get_fdt(sPAPRDRConnector *drc, int *fdt_start_offset) > > +{ > > + if (fdt_start_offset) { > > + *fdt_start_offset = drc->fdt_start_offset; > > + } > > + return drc->fdt; > > +} > > + > > +static void set_configured(sPAPRDRConnector *drc) > > +{ > > + DPRINTFN("drc: %x, set_configured", get_index(drc)); > > + > > + if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_UNISOLATED) { > > + /* guest should be not configuring an isolated device */ > > + DPRINTFN("drc: %x, set_configured: skipping isolated device", > > + get_index(drc)); > > + return; > > + } > > + drc->configured = true; > > +} > > + > > +/* > > + * dr-entity-sense sensor value > > + * returned via get-sensor-state RTAS calls > > + * as expected by state diagram in PAPR+ 2.7, 13.4 > > + * based on the current allocation/indicator/power states > > + * for the DR connector. > > + */ > > +static sPAPRDREntitySense entity_sense(sPAPRDRConnector *drc) > > +{ > > + sPAPRDREntitySense state; > > + > > + if (drc->dev) { > > + if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI && > > + drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) { > > + /* for logical DR, we return a state of UNUSABLE > > + * iff the allocation state UNUSABLE. > > + * Otherwise, report the state as USABLE/PRESENT, > > + * as we would for PCI. > > + */ > > + state = SPAPR_DR_ENTITY_SENSE_UNUSABLE; > > + } else { > > + /* this assumes all PCI devices are assigned to > > + * a 'live insertion' power domain, where QEMU > > + * manages power state automatically as opposed > > + * to the guest. present, non-PCI resources are > > + * unaffected by power state. > > + */ > > + state = SPAPR_DR_ENTITY_SENSE_PRESENT; > > + } > > + } else { > > + if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) { > > + /* PCI devices, and only PCI devices, use EMPTY > > + * in cases where we'd otherwise use UNUSABLE > > + */ > > + state = SPAPR_DR_ENTITY_SENSE_EMPTY; > > + } else { > > + state = SPAPR_DR_ENTITY_SENSE_UNUSABLE; > > + } > > + } > > + > > + DPRINTFN("drc: %x, entity_sense: %x", get_index(drc), state); > > + return state; > > +} > > + > > +static void prop_get_index(Object *obj, Visitor *v, void *opaque, > > + const char *name, Error **errp) > > +{ > > + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); > > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > > + uint32_t value = (uint32_t)drck->get_index(drc); > > + visit_type_uint32(v, &value, name, errp); > > +} > > + > > +static void prop_get_type(Object *obj, Visitor *v, void *opaque, > > + const char *name, Error **errp) > > +{ > > + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); > > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > > + uint32_t value = (uint32_t)drck->get_type(drc); > > + visit_type_uint32(v, &value, name, errp); > > +} > > + > > +static char *prop_get_name(Object *obj, Error **errp) > > +{ > > + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); > > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > > + return g_strdup(drck->get_name(drc)); > > +} > > + > > +static void prop_get_entity_sense(Object *obj, Visitor *v, void *opaque, > > + const char *name, Error **errp) > > +{ > > + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); > > + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); > > + uint32_t value = (uint32_t)drck->entity_sense(drc); > > + visit_type_uint32(v, &value, name, errp); > > +} > > + > > +static void prop_get_fdt(Object *obj, Visitor *v, void *opaque, > > + const char *name, Error **errp) > > +{ > > + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); > > + int fdt_offset_next, fdt_offset, fdt_depth; > > + void *fdt; > > + > > + if (!drc->fdt) { > > + return; > > + } > > + > > + fdt = drc->fdt; > > + fdt_offset = drc->fdt_start_offset; > > + fdt_depth = 0; > > + > > + do { > > + const char *name = NULL; > > + const struct fdt_property *prop = NULL; > > + int prop_len = 0, name_len = 0; > > + uint32_t tag; > > + > > + tag = fdt_next_tag(fdt, fdt_offset, &fdt_offset_next); > > + switch (tag) { > > + case FDT_BEGIN_NODE: > > + fdt_depth++; > > + name = fdt_get_name(fdt, fdt_offset, &name_len); > > + visit_start_struct(v, NULL, NULL, name, 0, NULL); > > + break; > > + case FDT_END_NODE: > > + /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */ > > + g_assert(fdt_depth > 0); > > + visit_end_struct(v, NULL); > > + fdt_depth--; > > + break; > > + case FDT_PROP: { > > + int i; > > + prop = fdt_get_property_by_offset(fdt, fdt_offset, &prop_len); > > Did this fdt function only get introduced recently? My test system has > 1.3.0 installed which doesn't contain it apparently. > > Please add a configure check to verify it actually exists if it's really > necessary. Erm.. that's odd. That function went in with commit 73dca9ae, which is included in dtc 1.3.0..
On 08.05.15 02:01, David Gibson wrote: > On Fri, May 08, 2015 at 12:39:20AM +0200, Alexander Graf wrote: >> >> >> On 07.05.15 07:33, David Gibson wrote: >>> From: Michael Roth <mdroth@linux.vnet.ibm.com> >>> >>> This device emulates a firmware abstraction used by pSeries guests to >>> manage hotplug/dynamic-reconfiguration of host-bridges, PCI devices, >>> memory, and CPUs. It is conceptually similar to an SHPC device, >>> complete with LED indicators to identify individual slots to physical >>> physical users and indicate when it is safe to remove a device. In >>> some cases it is also used to manage virtualized resources, such a >>> memory, CPUs, and physical-host bridges, which in the case of pSeries >>> guests are virtualized resources where the physical components are >>> managed by the host. >>> >>> Guests communicate with these DR Connectors using RTAS calls, >>> generally by addressing the unique DRC index associated with a >>> particular connector for a particular resource. For introspection >>> purposes we expose this state initially as QOM properties, and >>> in subsequent patches will introduce the RTAS calls that make use of >>> it. This constitutes to the 'guest' interface. >>> >>> On the QEMU side we provide an attach/detach interface to associate >>> or cleanup a DeviceState with a particular sPAPRDRConnector in >>> response to hotplug/unplug, respectively. This constitutes the >>> 'physical' interface to the DR Connector. >>> >>> Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com> >>> Reviewed-by: David Gibson <david@gibson.dropbear.id.au> >>> Signed-off-by: David Gibson <david@gibson.dropbear.id.au> >>> --- >>> hw/ppc/Makefile.objs | 2 +- >>> hw/ppc/spapr_drc.c | 588 +++++++++++++++++++++++++++++++++++++++++++++ >>> include/hw/ppc/spapr_drc.h | 199 +++++++++++++++ >>> 3 files changed, 788 insertions(+), 1 deletion(-) >>> create mode 100644 hw/ppc/spapr_drc.c >>> create mode 100644 include/hw/ppc/spapr_drc.h >>> >>> diff --git a/hw/ppc/Makefile.objs b/hw/ppc/Makefile.objs >>> index 437955d..c8ab06e 100644 >>> --- a/hw/ppc/Makefile.objs >>> +++ b/hw/ppc/Makefile.objs >>> @@ -3,7 +3,7 @@ obj-y += ppc.o ppc_booke.o >>> # IBM pSeries (sPAPR) >>> obj-$(CONFIG_PSERIES) += spapr.o spapr_vio.o spapr_events.o >>> obj-$(CONFIG_PSERIES) += spapr_hcall.o spapr_iommu.o spapr_rtas.o >>> -obj-$(CONFIG_PSERIES) += spapr_pci.o spapr_rtc.o >>> +obj-$(CONFIG_PSERIES) += spapr_pci.o spapr_rtc.o spapr_drc.o >>> ifeq ($(CONFIG_PCI)$(CONFIG_PSERIES)$(CONFIG_LINUX), yyy) >>> obj-y += spapr_pci_vfio.o >>> endif >>> diff --git a/hw/ppc/spapr_drc.c b/hw/ppc/spapr_drc.c >>> new file mode 100644 >>> index 0000000..047c6c7 >>> --- /dev/null >>> +++ b/hw/ppc/spapr_drc.c >>> @@ -0,0 +1,588 @@ >>> +/* >>> + * QEMU SPAPR Dynamic Reconfiguration Connector Implementation >>> + * >>> + * Copyright IBM Corp. 2014 >>> + * >>> + * Authors: >>> + * Michael Roth <mdroth@linux.vnet.ibm.com> >>> + * >>> + * This work is licensed under the terms of the GNU GPL, version 2 or later. >>> + * See the COPYING file in the top-level directory. >>> + */ >>> + >>> +#include "hw/ppc/spapr_drc.h" >>> +#include "qom/object.h" >>> +#include "hw/qdev.h" >>> +#include "qapi/visitor.h" >>> +#include "qemu/error-report.h" >>> + >>> +/* #define DEBUG_SPAPR_DRC */ >>> + >>> +#ifdef DEBUG_SPAPR_DRC >>> +#define DPRINTF(fmt, ...) \ >>> + do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) >>> +#define DPRINTFN(fmt, ...) \ >>> + do { DPRINTF(fmt, ## __VA_ARGS__); fprintf(stderr, "\n"); } while (0) >>> +#else >>> +#define DPRINTF(fmt, ...) \ >>> + do { } while (0) >>> +#define DPRINTFN(fmt, ...) \ >>> + do { } while (0) >>> +#endif >>> + >>> +#define DRC_CONTAINER_PATH "/dr-connector" >>> +#define DRC_INDEX_TYPE_SHIFT 28 >>> +#define DRC_INDEX_ID_MASK (~(~0 << DRC_INDEX_TYPE_SHIFT)) >>> + >>> +static sPAPRDRConnectorTypeShift get_type_shift(sPAPRDRConnectorType type) >>> +{ >>> + uint32_t shift = 0; >>> + >>> + /* make sure this isn't SPAPR_DR_CONNECTOR_TYPE_ANY, or some >>> + * other wonky value. >>> + */ >>> + g_assert(is_power_of_2(type)); >>> + >>> + while (type != (1 << shift)) { >>> + shift++; >>> + } >>> + return shift; >>> +} >>> + >>> +static uint32_t get_index(sPAPRDRConnector *drc) >>> +{ >>> + /* no set format for a drc index: it only needs to be globally >>> + * unique. this is how we encode the DRC type on bare-metal >>> + * however, so might as well do that here >>> + */ >>> + return (get_type_shift(drc->type) << DRC_INDEX_TYPE_SHIFT) | >>> + (drc->id & DRC_INDEX_ID_MASK); >>> +} >>> + >>> +static int set_isolation_state(sPAPRDRConnector *drc, >>> + sPAPRDRIsolationState state) >>> +{ >>> + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); >>> + >>> + DPRINTFN("drc: %x, set_isolation_state: %x", get_index(drc), state); >>> + >>> + drc->isolation_state = state; >>> + >>> + if (drc->isolation_state == SPAPR_DR_ISOLATION_STATE_ISOLATED) { >>> + /* if we're awaiting release, but still in an unconfigured state, >>> + * it's likely the guest is still in the process of configuring >>> + * the device and is transitioning the devices to an ISOLATED >>> + * state as a part of that process. so we only complete the >>> + * removal when this transition happens for a device in a >>> + * configured state, as suggested by the state diagram from >>> + * PAPR+ 2.7, 13.4 >>> + */ >>> + if (drc->awaiting_release) { >>> + if (drc->configured) { >>> + DPRINTFN("finalizing device removal"); >>> + drck->detach(drc, DEVICE(drc->dev), drc->detach_cb, >>> + drc->detach_cb_opaque, NULL); >>> + } else { >>> + DPRINTFN("deferring device removal on unconfigured device\n"); >>> + } >>> + } >>> + drc->configured = false; >>> + } >>> + >>> + return 0; >>> +} >>> + >>> +static int set_indicator_state(sPAPRDRConnector *drc, >>> + sPAPRDRIndicatorState state) >>> +{ >>> + DPRINTFN("drc: %x, set_indicator_state: %x", get_index(drc), state); >>> + drc->indicator_state = state; >>> + return 0; >>> +} >>> + >>> +static int set_allocation_state(sPAPRDRConnector *drc, >>> + sPAPRDRAllocationState state) >>> +{ >>> + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); >>> + >>> + DPRINTFN("drc: %x, set_allocation_state: %x", get_index(drc), state); >>> + >>> + if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI) { >>> + drc->allocation_state = state; >>> + if (drc->awaiting_release && >>> + drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) { >>> + DPRINTFN("finalizing device removal"); >>> + drck->detach(drc, DEVICE(drc->dev), drc->detach_cb, >>> + drc->detach_cb_opaque, NULL); >>> + } >>> + } >>> + return 0; >>> +} >>> + >>> +static uint32_t get_type(sPAPRDRConnector *drc) >>> +{ >>> + return drc->type; >>> +} >>> + >>> +static const char *get_name(sPAPRDRConnector *drc) >>> +{ >>> + return drc->name; >>> +} >>> + >>> +static const void *get_fdt(sPAPRDRConnector *drc, int *fdt_start_offset) >>> +{ >>> + if (fdt_start_offset) { >>> + *fdt_start_offset = drc->fdt_start_offset; >>> + } >>> + return drc->fdt; >>> +} >>> + >>> +static void set_configured(sPAPRDRConnector *drc) >>> +{ >>> + DPRINTFN("drc: %x, set_configured", get_index(drc)); >>> + >>> + if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_UNISOLATED) { >>> + /* guest should be not configuring an isolated device */ >>> + DPRINTFN("drc: %x, set_configured: skipping isolated device", >>> + get_index(drc)); >>> + return; >>> + } >>> + drc->configured = true; >>> +} >>> + >>> +/* >>> + * dr-entity-sense sensor value >>> + * returned via get-sensor-state RTAS calls >>> + * as expected by state diagram in PAPR+ 2.7, 13.4 >>> + * based on the current allocation/indicator/power states >>> + * for the DR connector. >>> + */ >>> +static sPAPRDREntitySense entity_sense(sPAPRDRConnector *drc) >>> +{ >>> + sPAPRDREntitySense state; >>> + >>> + if (drc->dev) { >>> + if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI && >>> + drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) { >>> + /* for logical DR, we return a state of UNUSABLE >>> + * iff the allocation state UNUSABLE. >>> + * Otherwise, report the state as USABLE/PRESENT, >>> + * as we would for PCI. >>> + */ >>> + state = SPAPR_DR_ENTITY_SENSE_UNUSABLE; >>> + } else { >>> + /* this assumes all PCI devices are assigned to >>> + * a 'live insertion' power domain, where QEMU >>> + * manages power state automatically as opposed >>> + * to the guest. present, non-PCI resources are >>> + * unaffected by power state. >>> + */ >>> + state = SPAPR_DR_ENTITY_SENSE_PRESENT; >>> + } >>> + } else { >>> + if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) { >>> + /* PCI devices, and only PCI devices, use EMPTY >>> + * in cases where we'd otherwise use UNUSABLE >>> + */ >>> + state = SPAPR_DR_ENTITY_SENSE_EMPTY; >>> + } else { >>> + state = SPAPR_DR_ENTITY_SENSE_UNUSABLE; >>> + } >>> + } >>> + >>> + DPRINTFN("drc: %x, entity_sense: %x", get_index(drc), state); >>> + return state; >>> +} >>> + >>> +static void prop_get_index(Object *obj, Visitor *v, void *opaque, >>> + const char *name, Error **errp) >>> +{ >>> + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); >>> + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); >>> + uint32_t value = (uint32_t)drck->get_index(drc); >>> + visit_type_uint32(v, &value, name, errp); >>> +} >>> + >>> +static void prop_get_type(Object *obj, Visitor *v, void *opaque, >>> + const char *name, Error **errp) >>> +{ >>> + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); >>> + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); >>> + uint32_t value = (uint32_t)drck->get_type(drc); >>> + visit_type_uint32(v, &value, name, errp); >>> +} >>> + >>> +static char *prop_get_name(Object *obj, Error **errp) >>> +{ >>> + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); >>> + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); >>> + return g_strdup(drck->get_name(drc)); >>> +} >>> + >>> +static void prop_get_entity_sense(Object *obj, Visitor *v, void *opaque, >>> + const char *name, Error **errp) >>> +{ >>> + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); >>> + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); >>> + uint32_t value = (uint32_t)drck->entity_sense(drc); >>> + visit_type_uint32(v, &value, name, errp); >>> +} >>> + >>> +static void prop_get_fdt(Object *obj, Visitor *v, void *opaque, >>> + const char *name, Error **errp) >>> +{ >>> + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); >>> + int fdt_offset_next, fdt_offset, fdt_depth; >>> + void *fdt; >>> + >>> + if (!drc->fdt) { >>> + return; >>> + } >>> + >>> + fdt = drc->fdt; >>> + fdt_offset = drc->fdt_start_offset; >>> + fdt_depth = 0; >>> + >>> + do { >>> + const char *name = NULL; >>> + const struct fdt_property *prop = NULL; >>> + int prop_len = 0, name_len = 0; >>> + uint32_t tag; >>> + >>> + tag = fdt_next_tag(fdt, fdt_offset, &fdt_offset_next); >>> + switch (tag) { >>> + case FDT_BEGIN_NODE: >>> + fdt_depth++; >>> + name = fdt_get_name(fdt, fdt_offset, &name_len); >>> + visit_start_struct(v, NULL, NULL, name, 0, NULL); >>> + break; >>> + case FDT_END_NODE: >>> + /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */ >>> + g_assert(fdt_depth > 0); >>> + visit_end_struct(v, NULL); >>> + fdt_depth--; >>> + break; >>> + case FDT_PROP: { >>> + int i; >>> + prop = fdt_get_property_by_offset(fdt, fdt_offset, &prop_len); >> >> Did this fdt function only get introduced recently? My test system has >> 1.3.0 installed which doesn't contain it apparently. >> >> Please add a configure check to verify it actually exists if it's really >> necessary. > > Erm.. that's odd. That function went in with commit 73dca9ae, which > is included in dtc 1.3.0.. This is indeed very odd. So this is the binary I have on my system: http://download.opensuse.org/ports/ppc/distribution/12.2/repo/oss/suse/ppc64/libfdt1-1.3.0-7.1.6.ppc64.rpm which got build from almost vanilla 1.3.0 sources: https://build.opensuse.org/package/show/openSUSE:12.3/dtc However, the symbols in the file seem to say it's libfdt 1.2 and I don't see the by_offset function exported. It is however present in the source, so I'm slightly confused. $ readelf -a libfdt-1.3.0.so | grep proper 000000016848 002a00000015 R_PPC64_JMP_SLOT 0000000000016290 fdt_get_property_namel + 0 0000000168f0 003f00000015 R_PPC64_JMP_SLOT 00000000000162a8 fdt_get_property + 0 20: 0000000000016440 112 FUNC GLOBAL DEFAULT 22 fdt_nop_property@@LIBFDT_1.2 42: 0000000000016290 228 FUNC GLOBAL DEFAULT 22 fdt_get_property_namelen@@LIBFDT_1.2 51: 0000000000016548 340 FUNC GLOBAL DEFAULT 22 fdt_property@@LIBFDT_1.2 63: 00000000000162a8 88 FUNC GLOBAL DEFAULT 22 fdt_get_property@@LIBFDT_1.2 However, on a newer system with dtc 1.4 I get the function exported, but all symbols still have a 1.2 version tag: $ readelf -a /usr/lib64/libfdt.so| grep property 000000205018 001d00000007 R_X86_64_JUMP_SLO 0000000000001f36 fdt_first_property_off + 0 000000205048 002a00000007 R_X86_64_JUMP_SLO 0000000000001fbf fdt_get_property_namel + 0 000000205098 004100000007 R_X86_64_JUMP_SLO 0000000000002068 fdt_get_property + 0 0000002050a0 002b00000007 R_X86_64_JUMP_SLO 0000000000001f6a fdt_get_property_by_of + 0 0000002050f8 003200000007 R_X86_64_JUMP_SLO 0000000000001f50 fdt_next_property_offs + 0 18: 000000000000270a 45 FUNC GLOBAL DEFAULT 13 fdt_nop_property@@LIBFDT_1.2 29: 0000000000001f36 26 FUNC GLOBAL DEFAULT 13 fdt_first_property_offset@@LIBFDT_1.2 42: 0000000000001fbf 169 FUNC GLOBAL DEFAULT 13 fdt_get_property_namelen@@LIBFDT_1.2 43: 0000000000001f6a 85 FUNC GLOBAL DEFAULT 13 fdt_get_property_by_offse@@LIBFDT_1.2 50: 0000000000001f50 26 FUNC GLOBAL DEFAULT 13 fdt_next_property_offset@@LIBFDT_1.2 53: 00000000000029b9 303 FUNC GLOBAL DEFAULT 13 fdt_property@@LIBFDT_1.2 65: 0000000000002068 31 FUNC GLOBAL DEFAULT 13 fdt_get_property@@LIBFDT_1.2 Either way, I think the commit actually fixing what we see is http://git.qemu.org/?p=dtc.git;a=commitdiff;h=c6fb1d239191daa3323fb6caeff56d48c4777793;hp=317a5d92bc357aba2c993ee78b4c089b7539fcc6 which exports the symbol. So please either find a way around using the function (which I'd prefer) or make sure that configure requires libfdt 1.4 onwards. Alex
diff --git a/hw/ppc/Makefile.objs b/hw/ppc/Makefile.objs index 437955d..c8ab06e 100644 --- a/hw/ppc/Makefile.objs +++ b/hw/ppc/Makefile.objs @@ -3,7 +3,7 @@ obj-y += ppc.o ppc_booke.o # IBM pSeries (sPAPR) obj-$(CONFIG_PSERIES) += spapr.o spapr_vio.o spapr_events.o obj-$(CONFIG_PSERIES) += spapr_hcall.o spapr_iommu.o spapr_rtas.o -obj-$(CONFIG_PSERIES) += spapr_pci.o spapr_rtc.o +obj-$(CONFIG_PSERIES) += spapr_pci.o spapr_rtc.o spapr_drc.o ifeq ($(CONFIG_PCI)$(CONFIG_PSERIES)$(CONFIG_LINUX), yyy) obj-y += spapr_pci_vfio.o endif diff --git a/hw/ppc/spapr_drc.c b/hw/ppc/spapr_drc.c new file mode 100644 index 0000000..047c6c7 --- /dev/null +++ b/hw/ppc/spapr_drc.c @@ -0,0 +1,588 @@ +/* + * QEMU SPAPR Dynamic Reconfiguration Connector Implementation + * + * Copyright IBM Corp. 2014 + * + * Authors: + * Michael Roth <mdroth@linux.vnet.ibm.com> + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#include "hw/ppc/spapr_drc.h" +#include "qom/object.h" +#include "hw/qdev.h" +#include "qapi/visitor.h" +#include "qemu/error-report.h" + +/* #define DEBUG_SPAPR_DRC */ + +#ifdef DEBUG_SPAPR_DRC +#define DPRINTF(fmt, ...) \ + do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) +#define DPRINTFN(fmt, ...) \ + do { DPRINTF(fmt, ## __VA_ARGS__); fprintf(stderr, "\n"); } while (0) +#else +#define DPRINTF(fmt, ...) \ + do { } while (0) +#define DPRINTFN(fmt, ...) \ + do { } while (0) +#endif + +#define DRC_CONTAINER_PATH "/dr-connector" +#define DRC_INDEX_TYPE_SHIFT 28 +#define DRC_INDEX_ID_MASK (~(~0 << DRC_INDEX_TYPE_SHIFT)) + +static sPAPRDRConnectorTypeShift get_type_shift(sPAPRDRConnectorType type) +{ + uint32_t shift = 0; + + /* make sure this isn't SPAPR_DR_CONNECTOR_TYPE_ANY, or some + * other wonky value. + */ + g_assert(is_power_of_2(type)); + + while (type != (1 << shift)) { + shift++; + } + return shift; +} + +static uint32_t get_index(sPAPRDRConnector *drc) +{ + /* no set format for a drc index: it only needs to be globally + * unique. this is how we encode the DRC type on bare-metal + * however, so might as well do that here + */ + return (get_type_shift(drc->type) << DRC_INDEX_TYPE_SHIFT) | + (drc->id & DRC_INDEX_ID_MASK); +} + +static int set_isolation_state(sPAPRDRConnector *drc, + sPAPRDRIsolationState state) +{ + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + + DPRINTFN("drc: %x, set_isolation_state: %x", get_index(drc), state); + + drc->isolation_state = state; + + if (drc->isolation_state == SPAPR_DR_ISOLATION_STATE_ISOLATED) { + /* if we're awaiting release, but still in an unconfigured state, + * it's likely the guest is still in the process of configuring + * the device and is transitioning the devices to an ISOLATED + * state as a part of that process. so we only complete the + * removal when this transition happens for a device in a + * configured state, as suggested by the state diagram from + * PAPR+ 2.7, 13.4 + */ + if (drc->awaiting_release) { + if (drc->configured) { + DPRINTFN("finalizing device removal"); + drck->detach(drc, DEVICE(drc->dev), drc->detach_cb, + drc->detach_cb_opaque, NULL); + } else { + DPRINTFN("deferring device removal on unconfigured device\n"); + } + } + drc->configured = false; + } + + return 0; +} + +static int set_indicator_state(sPAPRDRConnector *drc, + sPAPRDRIndicatorState state) +{ + DPRINTFN("drc: %x, set_indicator_state: %x", get_index(drc), state); + drc->indicator_state = state; + return 0; +} + +static int set_allocation_state(sPAPRDRConnector *drc, + sPAPRDRAllocationState state) +{ + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + + DPRINTFN("drc: %x, set_allocation_state: %x", get_index(drc), state); + + if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI) { + drc->allocation_state = state; + if (drc->awaiting_release && + drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) { + DPRINTFN("finalizing device removal"); + drck->detach(drc, DEVICE(drc->dev), drc->detach_cb, + drc->detach_cb_opaque, NULL); + } + } + return 0; +} + +static uint32_t get_type(sPAPRDRConnector *drc) +{ + return drc->type; +} + +static const char *get_name(sPAPRDRConnector *drc) +{ + return drc->name; +} + +static const void *get_fdt(sPAPRDRConnector *drc, int *fdt_start_offset) +{ + if (fdt_start_offset) { + *fdt_start_offset = drc->fdt_start_offset; + } + return drc->fdt; +} + +static void set_configured(sPAPRDRConnector *drc) +{ + DPRINTFN("drc: %x, set_configured", get_index(drc)); + + if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_UNISOLATED) { + /* guest should be not configuring an isolated device */ + DPRINTFN("drc: %x, set_configured: skipping isolated device", + get_index(drc)); + return; + } + drc->configured = true; +} + +/* + * dr-entity-sense sensor value + * returned via get-sensor-state RTAS calls + * as expected by state diagram in PAPR+ 2.7, 13.4 + * based on the current allocation/indicator/power states + * for the DR connector. + */ +static sPAPRDREntitySense entity_sense(sPAPRDRConnector *drc) +{ + sPAPRDREntitySense state; + + if (drc->dev) { + if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI && + drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_UNUSABLE) { + /* for logical DR, we return a state of UNUSABLE + * iff the allocation state UNUSABLE. + * Otherwise, report the state as USABLE/PRESENT, + * as we would for PCI. + */ + state = SPAPR_DR_ENTITY_SENSE_UNUSABLE; + } else { + /* this assumes all PCI devices are assigned to + * a 'live insertion' power domain, where QEMU + * manages power state automatically as opposed + * to the guest. present, non-PCI resources are + * unaffected by power state. + */ + state = SPAPR_DR_ENTITY_SENSE_PRESENT; + } + } else { + if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) { + /* PCI devices, and only PCI devices, use EMPTY + * in cases where we'd otherwise use UNUSABLE + */ + state = SPAPR_DR_ENTITY_SENSE_EMPTY; + } else { + state = SPAPR_DR_ENTITY_SENSE_UNUSABLE; + } + } + + DPRINTFN("drc: %x, entity_sense: %x", get_index(drc), state); + return state; +} + +static void prop_get_index(Object *obj, Visitor *v, void *opaque, + const char *name, Error **errp) +{ + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + uint32_t value = (uint32_t)drck->get_index(drc); + visit_type_uint32(v, &value, name, errp); +} + +static void prop_get_type(Object *obj, Visitor *v, void *opaque, + const char *name, Error **errp) +{ + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + uint32_t value = (uint32_t)drck->get_type(drc); + visit_type_uint32(v, &value, name, errp); +} + +static char *prop_get_name(Object *obj, Error **errp) +{ + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + return g_strdup(drck->get_name(drc)); +} + +static void prop_get_entity_sense(Object *obj, Visitor *v, void *opaque, + const char *name, Error **errp) +{ + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + uint32_t value = (uint32_t)drck->entity_sense(drc); + visit_type_uint32(v, &value, name, errp); +} + +static void prop_get_fdt(Object *obj, Visitor *v, void *opaque, + const char *name, Error **errp) +{ + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); + int fdt_offset_next, fdt_offset, fdt_depth; + void *fdt; + + if (!drc->fdt) { + return; + } + + fdt = drc->fdt; + fdt_offset = drc->fdt_start_offset; + fdt_depth = 0; + + do { + const char *name = NULL; + const struct fdt_property *prop = NULL; + int prop_len = 0, name_len = 0; + uint32_t tag; + + tag = fdt_next_tag(fdt, fdt_offset, &fdt_offset_next); + switch (tag) { + case FDT_BEGIN_NODE: + fdt_depth++; + name = fdt_get_name(fdt, fdt_offset, &name_len); + visit_start_struct(v, NULL, NULL, name, 0, NULL); + break; + case FDT_END_NODE: + /* shouldn't ever see an FDT_END_NODE before FDT_BEGIN_NODE */ + g_assert(fdt_depth > 0); + visit_end_struct(v, NULL); + fdt_depth--; + break; + case FDT_PROP: { + int i; + prop = fdt_get_property_by_offset(fdt, fdt_offset, &prop_len); + name = fdt_string(fdt, fdt32_to_cpu(prop->nameoff)); + visit_start_list(v, name, NULL); + for (i = 0; i < prop_len; i++) { + visit_type_uint8(v, (uint8_t *)&prop->data[i], NULL, NULL); + + } + visit_end_list(v, NULL); + break; + } + default: + error_setg(&error_abort, "device FDT in unexpected state: %d", tag); + } + fdt_offset = fdt_offset_next; + } while (fdt_depth != 0); +} + +static void attach(sPAPRDRConnector *drc, DeviceState *d, void *fdt, + int fdt_start_offset, bool coldplug, Error **errp) +{ + DPRINTFN("drc: %x, attach", get_index(drc)); + + if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) { + error_setg(errp, "an attached device is still awaiting release"); + return; + } + if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) { + g_assert(drc->allocation_state == SPAPR_DR_ALLOCATION_STATE_USABLE); + } + g_assert(fdt || coldplug); + + /* NOTE: setting initial isolation state to UNISOLATED means we can't + * detach unless guest has a userspace/kernel that moves this state + * back to ISOLATED in response to an unplug event, or this is done + * manually by the admin prior. if we force things while the guest + * may be accessing the device, we can easily crash the guest, so we + * we defer completion of removal in such cases to the reset() hook. + */ + if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) { + drc->isolation_state = SPAPR_DR_ISOLATION_STATE_UNISOLATED; + } + drc->indicator_state = SPAPR_DR_INDICATOR_STATE_ACTIVE; + + drc->dev = d; + drc->fdt = fdt; + drc->fdt_start_offset = fdt_start_offset; + drc->configured = false; + + object_property_add_link(OBJECT(drc), "device", + object_get_typename(OBJECT(drc->dev)), + (Object **)(&drc->dev), + NULL, 0, NULL); +} + +static void detach(sPAPRDRConnector *drc, DeviceState *d, + spapr_drc_detach_cb *detach_cb, + void *detach_cb_opaque, Error **errp) +{ + DPRINTFN("drc: %x, detach", get_index(drc)); + + drc->detach_cb = detach_cb; + drc->detach_cb_opaque = detach_cb_opaque; + + if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) { + DPRINTFN("awaiting transition to isolated state before removal"); + drc->awaiting_release = true; + return; + } + + if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI && + drc->allocation_state != SPAPR_DR_ALLOCATION_STATE_UNUSABLE) { + DPRINTFN("awaiting transition to unusable state before removal"); + drc->awaiting_release = true; + return; + } + + drc->indicator_state = SPAPR_DR_INDICATOR_STATE_INACTIVE; + + if (drc->detach_cb) { + drc->detach_cb(drc->dev, drc->detach_cb_opaque); + } + + drc->awaiting_release = false; + g_free(drc->fdt); + drc->fdt = NULL; + drc->fdt_start_offset = 0; + object_property_del(OBJECT(drc), "device", NULL); + drc->dev = NULL; + drc->detach_cb = NULL; + drc->detach_cb_opaque = NULL; +} + +static bool release_pending(sPAPRDRConnector *drc) +{ + return drc->awaiting_release; +} + +static void reset(DeviceState *d) +{ + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d); + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + + DPRINTFN("drc reset: %x", drck->get_index(drc)); + /* immediately upon reset we can safely assume DRCs whose devices + * are pending removal can be safely removed, and that they will + * subsequently be left in an ISOLATED state. move the DRC to this + * state in these cases (which will in turn complete any pending + * device removals) + */ + if (drc->awaiting_release) { + drck->set_isolation_state(drc, SPAPR_DR_ISOLATION_STATE_ISOLATED); + /* generally this should also finalize the removal, but if the device + * hasn't yet been configured we normally defer removal under the + * assumption that this transition is taking place as part of device + * configuration. so check if we're still waiting after this, and + * force removal if we are + */ + if (drc->awaiting_release) { + drck->detach(drc, DEVICE(drc->dev), drc->detach_cb, + drc->detach_cb_opaque, NULL); + } + + /* non-PCI devices may be awaiting a transition to UNUSABLE */ + if (drc->type != SPAPR_DR_CONNECTOR_TYPE_PCI && + drc->awaiting_release) { + drck->set_allocation_state(drc, SPAPR_DR_ALLOCATION_STATE_UNUSABLE); + } + } +} + +static void realize(DeviceState *d, Error **errp) +{ + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d); + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + Object *root_container; + char link_name[256]; + gchar *child_name; + Error *err = NULL; + + DPRINTFN("drc realize: %x", drck->get_index(drc)); + /* NOTE: we do this as part of realize/unrealize due to the fact + * that the guest will communicate with the DRC via RTAS calls + * referencing the global DRC index. By unlinking the DRC + * from DRC_CONTAINER_PATH/<drc_index> we effectively make it + * inaccessible by the guest, since lookups rely on this path + * existing in the composition tree + */ + root_container = container_get(object_get_root(), DRC_CONTAINER_PATH); + snprintf(link_name, sizeof(link_name), "%x", drck->get_index(drc)); + child_name = object_get_canonical_path_component(OBJECT(drc)); + DPRINTFN("drc child name: %s", child_name); + object_property_add_alias(root_container, link_name, + drc->owner, child_name, &err); + if (err) { + error_report("%s", error_get_pretty(err)); + error_free(err); + object_unref(OBJECT(drc)); + } + DPRINTFN("drc realize complete"); +} + +static void unrealize(DeviceState *d, Error **errp) +{ + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(d); + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); + Object *root_container; + char name[256]; + Error *err = NULL; + + DPRINTFN("drc unrealize: %x", drck->get_index(drc)); + root_container = container_get(object_get_root(), DRC_CONTAINER_PATH); + snprintf(name, sizeof(name), "%x", drck->get_index(drc)); + object_property_del(root_container, name, &err); + if (err) { + error_report("%s", error_get_pretty(err)); + error_free(err); + object_unref(OBJECT(drc)); + } +} + +sPAPRDRConnector *spapr_dr_connector_new(Object *owner, + sPAPRDRConnectorType type, + uint32_t id) +{ + sPAPRDRConnector *drc = + SPAPR_DR_CONNECTOR(object_new(TYPE_SPAPR_DR_CONNECTOR)); + + g_assert(type); + + drc->type = type; + drc->id = id; + drc->owner = owner; + object_property_add_child(owner, "dr-connector[*]", OBJECT(drc), NULL); + object_property_set_bool(OBJECT(drc), true, "realized", NULL); + + /* human-readable name for a DRC to encode into the DT + * description. this is mainly only used within a guest in place + * of the unique DRC index. + * + * in the case of VIO/PCI devices, it corresponds to a + * "location code" that maps a logical device/function (DRC index) + * to a physical (or virtual in the case of VIO) location in the + * system by chaining together the "location label" for each + * encapsulating component. + * + * since this is more to do with diagnosing physical hardware + * issues than guest compatibility, we choose location codes/DRC + * names that adhere to the documented format, but avoid encoding + * the entire topology information into the label/code, instead + * just using the location codes based on the labels for the + * endpoints (VIO/PCI adaptor connectors), which is basically + * just "C" followed by an integer ID. + * + * DRC names as documented by PAPR+ v2.7, 13.5.2.4 + * location codes as documented by PAPR+ v2.7, 12.3.1.5 + */ + switch (drc->type) { + case SPAPR_DR_CONNECTOR_TYPE_CPU: + drc->name = g_strdup_printf("CPU %d", id); + break; + case SPAPR_DR_CONNECTOR_TYPE_PHB: + drc->name = g_strdup_printf("PHB %d", id); + break; + case SPAPR_DR_CONNECTOR_TYPE_VIO: + case SPAPR_DR_CONNECTOR_TYPE_PCI: + drc->name = g_strdup_printf("C%d", id); + break; + case SPAPR_DR_CONNECTOR_TYPE_LMB: + drc->name = g_strdup_printf("LMB %d", id); + break; + default: + g_assert(false); + } + + /* PCI slot always start in a USABLE state, and stay there */ + if (drc->type == SPAPR_DR_CONNECTOR_TYPE_PCI) { + drc->allocation_state = SPAPR_DR_ALLOCATION_STATE_USABLE; + } + + return drc; +} + +static void spapr_dr_connector_instance_init(Object *obj) +{ + sPAPRDRConnector *drc = SPAPR_DR_CONNECTOR(obj); + + object_property_add_uint32_ptr(obj, "isolation-state", + &drc->isolation_state, NULL); + object_property_add_uint32_ptr(obj, "indicator-state", + &drc->indicator_state, NULL); + object_property_add_uint32_ptr(obj, "allocation-state", + &drc->allocation_state, NULL); + object_property_add_uint32_ptr(obj, "id", &drc->id, NULL); + object_property_add(obj, "index", "uint32", prop_get_index, + NULL, NULL, NULL, NULL); + object_property_add(obj, "connector_type", "uint32", prop_get_type, + NULL, NULL, NULL, NULL); + object_property_add_str(obj, "name", prop_get_name, NULL, NULL); + object_property_add(obj, "entity-sense", "uint32", prop_get_entity_sense, + NULL, NULL, NULL, NULL); + object_property_add(obj, "fdt", "struct", prop_get_fdt, + NULL, NULL, NULL, NULL); +} + +static void spapr_dr_connector_class_init(ObjectClass *k, void *data) +{ + DeviceClass *dk = DEVICE_CLASS(k); + sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_CLASS(k); + + dk->reset = reset; + dk->realize = realize; + dk->unrealize = unrealize; + drck->set_isolation_state = set_isolation_state; + drck->set_indicator_state = set_indicator_state; + drck->set_allocation_state = set_allocation_state; + drck->get_index = get_index; + drck->get_type = get_type; + drck->get_name = get_name; + drck->get_fdt = get_fdt; + drck->set_configured = set_configured; + drck->entity_sense = entity_sense; + drck->attach = attach; + drck->detach = detach; + drck->release_pending = release_pending; +} + +static const TypeInfo spapr_dr_connector_info = { + .name = TYPE_SPAPR_DR_CONNECTOR, + .parent = TYPE_DEVICE, + .instance_size = sizeof(sPAPRDRConnector), + .instance_init = spapr_dr_connector_instance_init, + .class_size = sizeof(sPAPRDRConnectorClass), + .class_init = spapr_dr_connector_class_init, +}; + +static void spapr_drc_register_types(void) +{ + type_register_static(&spapr_dr_connector_info); +} + +type_init(spapr_drc_register_types) + +/* helper functions for external users */ + +sPAPRDRConnector *spapr_dr_connector_by_index(uint32_t index) +{ + Object *obj; + char name[256]; + + snprintf(name, sizeof(name), "%s/%x", DRC_CONTAINER_PATH, index); + obj = object_resolve_path(name, NULL); + + return !obj ? NULL : SPAPR_DR_CONNECTOR(obj); +} + +sPAPRDRConnector *spapr_dr_connector_by_id(sPAPRDRConnectorType type, + uint32_t id) +{ + return spapr_dr_connector_by_index( + (get_type_shift(type) << DRC_INDEX_TYPE_SHIFT) | + (id & DRC_INDEX_ID_MASK)); +} diff --git a/include/hw/ppc/spapr_drc.h b/include/hw/ppc/spapr_drc.h new file mode 100644 index 0000000..34fdef9 --- /dev/null +++ b/include/hw/ppc/spapr_drc.h @@ -0,0 +1,199 @@ +/* + * QEMU SPAPR Dynamic Reconfiguration Connector Implementation + * + * Copyright IBM Corp. 2014 + * + * Authors: + * Michael Roth <mdroth@linux.vnet.ibm.com> + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ +#if !defined(__HW_SPAPR_DRC_H__) +#define __HW_SPAPR_DRC_H__ + +#include "qom/object.h" +#include "hw/qdev.h" +#include "libfdt.h" + +#define TYPE_SPAPR_DR_CONNECTOR "spapr-dr-connector" +#define SPAPR_DR_CONNECTOR_GET_CLASS(obj) \ + OBJECT_GET_CLASS(sPAPRDRConnectorClass, obj, TYPE_SPAPR_DR_CONNECTOR) +#define SPAPR_DR_CONNECTOR_CLASS(klass) \ + OBJECT_CLASS_CHECK(sPAPRDRConnectorClass, klass, \ + TYPE_SPAPR_DR_CONNECTOR) +#define SPAPR_DR_CONNECTOR(obj) OBJECT_CHECK(sPAPRDRConnector, (obj), \ + TYPE_SPAPR_DR_CONNECTOR) + +/* + * Various hotplug types managed by sPAPRDRConnector + * + * these are somewhat arbitrary, but to make things easier + * when generating DRC indexes later we've aligned the bit + * positions with the values used to assign DRC indexes on + * pSeries. we use those values as bit shifts to allow for + * the OR'ing of these values in various QEMU routines, but + * for values exposed to the guest (via DRC indexes for + * instance) we will use the shift amounts. + */ +typedef enum { + SPAPR_DR_CONNECTOR_TYPE_SHIFT_CPU = 1, + SPAPR_DR_CONNECTOR_TYPE_SHIFT_PHB = 2, + SPAPR_DR_CONNECTOR_TYPE_SHIFT_VIO = 3, + SPAPR_DR_CONNECTOR_TYPE_SHIFT_PCI = 4, + SPAPR_DR_CONNECTOR_TYPE_SHIFT_LMB = 8, +} sPAPRDRConnectorTypeShift; + +typedef enum { + SPAPR_DR_CONNECTOR_TYPE_ANY = ~0, + SPAPR_DR_CONNECTOR_TYPE_CPU = 1 << SPAPR_DR_CONNECTOR_TYPE_SHIFT_CPU, + SPAPR_DR_CONNECTOR_TYPE_PHB = 1 << SPAPR_DR_CONNECTOR_TYPE_SHIFT_PHB, + SPAPR_DR_CONNECTOR_TYPE_VIO = 1 << SPAPR_DR_CONNECTOR_TYPE_SHIFT_VIO, + SPAPR_DR_CONNECTOR_TYPE_PCI = 1 << SPAPR_DR_CONNECTOR_TYPE_SHIFT_PCI, + SPAPR_DR_CONNECTOR_TYPE_LMB = 1 << SPAPR_DR_CONNECTOR_TYPE_SHIFT_LMB, +} sPAPRDRConnectorType; + +/* + * set via set-indicator RTAS calls + * as documented by PAPR+ 2.7 13.5.3.4, Table 177 + * + * isolated: put device under firmware control + * unisolated: claim OS control of device (may or may not be in use) + */ +typedef enum { + SPAPR_DR_ISOLATION_STATE_ISOLATED = 0, + SPAPR_DR_ISOLATION_STATE_UNISOLATED = 1 +} sPAPRDRIsolationState; + +/* + * set via set-indicator RTAS calls + * as documented by PAPR+ 2.7 13.5.3.4, Table 177 + * + * unusable: mark device as unavailable to OS + * usable: mark device as available to OS + * exchange: (currently unused) + * recover: (currently unused) + */ +typedef enum { + SPAPR_DR_ALLOCATION_STATE_UNUSABLE = 0, + SPAPR_DR_ALLOCATION_STATE_USABLE = 1, + SPAPR_DR_ALLOCATION_STATE_EXCHANGE = 2, + SPAPR_DR_ALLOCATION_STATE_RECOVER = 3 +} sPAPRDRAllocationState; + +/* + * LED/visual indicator state + * + * set via set-indicator RTAS calls + * as documented by PAPR+ 2.7 13.5.3.4, Table 177, + * and PAPR+ 2.7 13.5.4.1, Table 180 + * + * inactive: hotpluggable entity inactive and safely removable + * active: hotpluggable entity in use and not safely removable + * identify: (currently unused) + * action: (currently unused) + */ +typedef enum { + SPAPR_DR_INDICATOR_STATE_INACTIVE = 0, + SPAPR_DR_INDICATOR_STATE_ACTIVE = 1, + SPAPR_DR_INDICATOR_STATE_IDENTIFY = 2, + SPAPR_DR_INDICATOR_STATE_ACTION = 3, +} sPAPRDRIndicatorState; + +/* + * returned via get-sensor-state RTAS calls + * as documented by PAPR+ 2.7 13.5.3.3, Table 175: + * + * empty: connector slot empty (e.g. empty hotpluggable PCI slot) + * present: connector slot populated and device available to OS + * unusable: device not currently available to OS + * exchange: (currently unused) + * recover: (currently unused) + */ +typedef enum { + SPAPR_DR_ENTITY_SENSE_EMPTY = 0, + SPAPR_DR_ENTITY_SENSE_PRESENT = 1, + SPAPR_DR_ENTITY_SENSE_UNUSABLE = 2, + SPAPR_DR_ENTITY_SENSE_EXCHANGE = 3, + SPAPR_DR_ENTITY_SENSE_RECOVER = 4, +} sPAPRDREntitySense; + +typedef enum { + SPAPR_DR_CC_RESPONSE_NEXT_SIB = 1, /* currently unused */ + SPAPR_DR_CC_RESPONSE_NEXT_CHILD = 2, + SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY = 3, + SPAPR_DR_CC_RESPONSE_PREV_PARENT = 4, + SPAPR_DR_CC_RESPONSE_SUCCESS = 0, + SPAPR_DR_CC_RESPONSE_ERROR = -1, + SPAPR_DR_CC_RESPONSE_CONTINUE = -2, +} sPAPRDRCCResponse; + +typedef void (spapr_drc_detach_cb)(DeviceState *d, void *opaque); + +typedef struct sPAPRDRConnector { + /*< private >*/ + DeviceState parent; + + sPAPRDRConnectorType type; + uint32_t id; + Object *owner; + const char *name; + + /* sensor/indicator states */ + uint32_t isolation_state; + uint32_t allocation_state; + uint32_t indicator_state; + + /* configure-connector state */ + void *fdt; + int fdt_start_offset; + bool configured; + + bool awaiting_release; + + /* device pointer, via link property */ + DeviceState *dev; + spapr_drc_detach_cb *detach_cb; + void *detach_cb_opaque; +} sPAPRDRConnector; + +typedef struct sPAPRDRConnectorClass { + /*< private >*/ + DeviceClass parent; + + /*< public >*/ + + /* accessors for guest-visible (generally via RTAS) DR state */ + int (*set_isolation_state)(sPAPRDRConnector *drc, + sPAPRDRIsolationState state); + int (*set_indicator_state)(sPAPRDRConnector *drc, + sPAPRDRIndicatorState state); + int (*set_allocation_state)(sPAPRDRConnector *drc, + sPAPRDRAllocationState state); + uint32_t (*get_index)(sPAPRDRConnector *drc); + uint32_t (*get_type)(sPAPRDRConnector *drc); + const char *(*get_name)(sPAPRDRConnector *drc); + + sPAPRDREntitySense (*entity_sense)(sPAPRDRConnector *drc); + + /* QEMU interfaces for managing FDT/configure-connector */ + const void *(*get_fdt)(sPAPRDRConnector *drc, int *fdt_start_offset); + void (*set_configured)(sPAPRDRConnector *drc); + + /* QEMU interfaces for managing hotplug operations */ + void (*attach)(sPAPRDRConnector *drc, DeviceState *d, void *fdt, + int fdt_start_offset, bool coldplug, Error **errp); + void (*detach)(sPAPRDRConnector *drc, DeviceState *d, + spapr_drc_detach_cb *detach_cb, + void *detach_cb_opaque, Error **errp); + bool (*release_pending)(sPAPRDRConnector *drc); +} sPAPRDRConnectorClass; + +sPAPRDRConnector *spapr_dr_connector_new(Object *owner, + sPAPRDRConnectorType type, + uint32_t id); +sPAPRDRConnector *spapr_dr_connector_by_index(uint32_t index); +sPAPRDRConnector *spapr_dr_connector_by_id(sPAPRDRConnectorType type, + uint32_t id); + +#endif /* __HW_SPAPR_DRC_H__ */