From: Klaus Jensen <k.jen...@samsung.com> Add a basic user creatable object that models an NVMe NVM subsystem.
Signed-off-by: Klaus Jensen <k.jen...@samsung.com> --- hw/nvme/ctrl.c | 26 +++++++--- hw/nvme/ns.c | 5 +- hw/nvme/nvme.h | 30 ++++++++---- hw/nvme/subsys.c | 121 +++++++++++++++++++++++++++++++++++++++-------- qapi/qom.json | 17 +++++++ 5 files changed, 162 insertions(+), 37 deletions(-) diff --git a/hw/nvme/ctrl.c b/hw/nvme/ctrl.c index ec63338b5bfc..563a8f8ad1df 100644 --- a/hw/nvme/ctrl.c +++ b/hw/nvme/ctrl.c @@ -6526,7 +6526,7 @@ static int nvme_init_subsys(NvmeState *n, Error **errp) return 0; } - cntlid = nvme_subsys_register_ctrl(n, errp); + cntlid = nvme_subsys_register_ctrl(n->subsys, n, errp); if (cntlid < 0) { return -1; } @@ -6557,6 +6557,12 @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp) return; } + if (!n->subsys) { + error_setg(errp, "device '%s' requires the 'subsys' parameter", + TYPE_NVME_DEVICE); + return; + } + nvme_init_state(n); if (nvme_init_pci(n, pci_dev, errp)) { return; @@ -6574,10 +6580,14 @@ static void nvme_legacy_realize(PCIDevice *pci_dev, Error **errp) NvmeState *n = NVME_STATE(pci_dev); NvmeCtrlLegacyDevice *ctrl = NVME_DEVICE_LEGACY(n); - if (ctrl->namespace.blkconf.blk && n->subsys) { - error_setg(errp, "subsystem support is unavailable with legacy " - "namespace ('drive' property)"); - return; + if (ctrl->subsys_dev) { + if (ctrl->namespace.blkconf.blk) { + error_setg(errp, "subsystem support is unavailable with legacy " + "namespace ('drive' property)"); + return; + } + + n->subsys = &ctrl->subsys_dev->subsys; } if (nvme_check_constraints(n, errp)) { @@ -6647,8 +6657,6 @@ static void nvme_exit(PCIDevice *pci_dev) static Property nvme_state_props[] = { DEFINE_PROP_LINK("pmrdev", NvmeState, pmr.dev, TYPE_MEMORY_BACKEND, HostMemoryBackend *), - DEFINE_PROP_LINK("subsys", NvmeState, subsys, TYPE_NVME_SUBSYS, - NvmeSubsystem *), DEFINE_PROP_STRING("serial", NvmeState, params.serial), DEFINE_PROP_UINT8("aerl", NvmeState, params.aerl, 3), DEFINE_PROP_UINT8("mdts", NvmeState, params.mdts, 7), @@ -6657,6 +6665,8 @@ static Property nvme_state_props[] = { }; static Property nvme_props[] = { + DEFINE_PROP_LINK("subsys", NvmeState, subsys, TYPE_NVME_SUBSYSTEM, + NvmeSubsystem *), DEFINE_PROP_UINT32("cmb-size-mb", NvmeState, params.cmb_size_mb, 0), DEFINE_PROP_UINT32("max-aen-retention", NvmeState, params.aer_max_queued, 64), DEFINE_PROP_UINT32("max-ioqpairs", NvmeState, params.max_ioqpairs, 64), @@ -6674,6 +6684,8 @@ static Property nvme_props[] = { static Property nvme_legacy_props[] = { DEFINE_BLOCK_PROPERTIES(NvmeCtrlLegacyDevice, namespace.blkconf), + DEFINE_PROP_LINK("subsys", NvmeCtrlLegacyDevice, subsys_dev, + TYPE_NVME_SUBSYS_DEVICE, NvmeSubsystemDevice *), DEFINE_PROP_UINT32("cmb_size_mb", NvmeState, params.cmb_size_mb, 0), DEFINE_PROP_UINT32("num_queues", NvmeState, params.num_queues, 0), DEFINE_PROP_UINT32("aer_max_queued", NvmeState, params.aer_max_queued, 64), diff --git a/hw/nvme/ns.c b/hw/nvme/ns.c index bdd41a3d1fc3..3d643554644c 100644 --- a/hw/nvme/ns.c +++ b/hw/nvme/ns.c @@ -493,7 +493,8 @@ static void nvme_nsdev_realize(DeviceState *dev, Error **errp) NvmeNamespaceDevice *nsdev = NVME_NAMESPACE_DEVICE(dev); NvmeNamespace *ns = &nsdev->ns; BusState *s = qdev_get_parent_bus(dev); - NvmeState *n = NVME_STATE(s->parent); + NvmeCtrlLegacyDevice *ctrl = NVME_DEVICE_LEGACY(s->parent); + NvmeState *n = NVME_STATE(ctrl); NvmeSubsystem *subsys = n->subsys; uint32_t nsid = nsdev->params.nsid; int i; @@ -515,7 +516,7 @@ static void nvme_nsdev_realize(DeviceState *dev, Error **errp) * If this namespace belongs to a subsystem (through a link on the * controller device), reparent the device. */ - if (!qdev_set_parent_bus(dev, &subsys->bus.parent_bus, errp)) { + if (!qdev_set_parent_bus(dev, &ctrl->subsys_dev->bus.parent_bus, errp)) { return; } } diff --git a/hw/nvme/nvme.h b/hw/nvme/nvme.h index 629a8ccab9f8..1ae185139132 100644 --- a/hw/nvme/nvme.h +++ b/hw/nvme/nvme.h @@ -48,24 +48,36 @@ typedef struct NvmeBus { BusState parent_bus; } NvmeBus; -#define TYPE_NVME_SUBSYS "nvme-subsys" -#define NVME_SUBSYS(obj) \ - OBJECT_CHECK(NvmeSubsystem, (obj), TYPE_NVME_SUBSYS) +#define TYPE_NVME_SUBSYSTEM "x-nvme-subsystem" +OBJECT_DECLARE_SIMPLE_TYPE(NvmeSubsystem, NVME_SUBSYSTEM) typedef struct NvmeSubsystem { - DeviceState parent_obj; - NvmeBus bus; - uint8_t subnqn[256]; + Object parent_obj; + + QemuUUID uuid; + uint8_t subnqn[256]; NvmeState *ctrls[NVME_MAX_CONTROLLERS]; NvmeNamespace *namespaces[NVME_MAX_NAMESPACES + 1]; +} NvmeSubsystem; + +#define TYPE_NVME_SUBSYS_DEVICE "nvme-subsys" +#define NVME_SUBSYS_DEVICE(obj) \ + OBJECT_CHECK(NvmeSubsystemDevice, (obj), TYPE_NVME_SUBSYS_DEVICE) + +typedef struct NvmeSubsystemDevice { + DeviceState parent_obj; + NvmeBus bus; + + NvmeSubsystem subsys; struct { char *nqn; } params; -} NvmeSubsystem; +} NvmeSubsystemDevice; -int nvme_subsys_register_ctrl(NvmeState *n, Error **errp); +int nvme_subsys_register_ctrl(NvmeSubsystem *subsys, NvmeState *n, + Error **errp); void nvme_subsys_unregister_ctrl(NvmeSubsystem *subsys, NvmeState *n); static inline NvmeState *nvme_subsys_ctrl(NvmeSubsystem *subsys, @@ -469,6 +481,8 @@ typedef struct NvmeCtrlLegacyDevice { /* for use with legacy single namespace (-device nvme,drive=...) setups */ NvmeNamespaceDevice namespace; + + NvmeSubsystemDevice *subsys_dev; } NvmeCtrlLegacyDevice; static inline NvmeNamespace *nvme_ns(NvmeState *n, uint32_t nsid) diff --git a/hw/nvme/subsys.c b/hw/nvme/subsys.c index 2442ae83b744..26e8e087e986 100644 --- a/hw/nvme/subsys.c +++ b/hw/nvme/subsys.c @@ -8,12 +8,12 @@ #include "qemu/osdep.h" #include "qapi/error.h" +#include "qom/object_interfaces.h" #include "nvme.h" -int nvme_subsys_register_ctrl(NvmeState *n, Error **errp) +int nvme_subsys_register_ctrl(NvmeSubsystem *subsys, NvmeState *n, Error **errp) { - NvmeSubsystem *subsys = n->subsys; int cntlid; for (cntlid = 0; cntlid < ARRAY_SIZE(subsys->ctrls); cntlid++) { @@ -37,53 +37,134 @@ void nvme_subsys_unregister_ctrl(NvmeSubsystem *subsys, NvmeState *n) subsys->ctrls[n->cntlid] = NULL; } -static void nvme_subsys_setup(NvmeSubsystem *subsys) +static char *get_subnqn(Object *obj, Error **errp) { - const char *nqn = subsys->params.nqn ? - subsys->params.nqn : subsys->parent_obj.id; + NvmeSubsystem *subsys = NVME_SUBSYSTEM(obj); + return g_strdup((char *)subsys->subnqn); +} + +static void set_subnqn(Object *obj, const char *str, Error **errp) +{ + NvmeSubsystem *subsys = NVME_SUBSYSTEM(obj); + snprintf((char *)subsys->subnqn, sizeof(subsys->subnqn), "%s", str); +} + +static char *get_uuid(Object *obj, Error **errp) +{ + NvmeSubsystem *subsys = NVME_SUBSYSTEM(obj); + char buf[UUID_FMT_LEN + 1]; + + qemu_uuid_unparse(&subsys->uuid, buf); + + return g_strdup(buf); +} + +static void set_uuid(Object *obj, const char *str, Error **errp) +{ + NvmeSubsystem *subsys = NVME_SUBSYSTEM(obj); + + if (!strcmp(str, "auto")) { + qemu_uuid_generate(&subsys->uuid); + } else if (qemu_uuid_parse(str, &subsys->uuid) < 0) { + error_setg(errp, "invalid uuid"); + return; + } +} + +static void subsys_complete(UserCreatable *uc, Error **errp) +{ + NvmeSubsystem *subsys = NVME_SUBSYSTEM(uc); + + if (qemu_uuid_is_null(&subsys->uuid)) { + qemu_uuid_generate(&subsys->uuid); + } + + if (strcmp((char *)subsys->subnqn, "")) { + char buf[UUID_FMT_LEN + 1]; + + qemu_uuid_unparse(&subsys->uuid, buf); + + snprintf((char *)subsys->subnqn, sizeof(subsys->subnqn), + "nqn.2021-08.org.qemu:uuid:%s", buf); + } +} + +static void subsys_class_init(ObjectClass *oc, void *data) +{ + UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc); + ucc->complete = subsys_complete; + + object_class_property_add_str(oc, "subnqn", get_subnqn, set_subnqn); + object_class_property_set_description(oc, "subnqn", "the NVM Subsystem " + "NVMe Qualified Name; " + "(default: nqn.2021-08.org.qemu:uuid:<UUID>)"); + + object_class_property_add_str(oc, "uuid", get_uuid, set_uuid); + object_class_property_set_description(oc, "subnqn", "NVM Subsystem UUID " + "(\"auto\" for random value; " + "default: auto)"); +} + +static const TypeInfo subsys_info = { + .name = TYPE_NVME_SUBSYSTEM, + .parent = TYPE_OBJECT, + .class_init = subsys_class_init, + .instance_size = sizeof(NvmeSubsystem), + .interfaces = (InterfaceInfo[]) { + { TYPE_USER_CREATABLE }, + { }, + } +}; + +static void subsys_dev_setup(NvmeSubsystemDevice *dev) +{ + NvmeSubsystem *subsys = &dev->subsys; + const char *nqn = dev->params.nqn ? + dev->params.nqn : dev->parent_obj.id; snprintf((char *)subsys->subnqn, sizeof(subsys->subnqn), "nqn.2019-08.org.qemu:%s", nqn); } -static void nvme_subsys_realize(DeviceState *dev, Error **errp) +static void subsys_dev_realize(DeviceState *dev, Error **errp) { - NvmeSubsystem *subsys = NVME_SUBSYS(dev); + NvmeSubsystemDevice *subsys = NVME_SUBSYS_DEVICE(dev); qbus_create_inplace(&subsys->bus, sizeof(NvmeBus), TYPE_NVME_BUS, dev, dev->id); - nvme_subsys_setup(subsys); + subsys_dev_setup(subsys); } -static Property nvme_subsystem_props[] = { - DEFINE_PROP_STRING("nqn", NvmeSubsystem, params.nqn), +static Property subsys_dev_props[] = { + DEFINE_PROP_STRING("nqn", NvmeSubsystemDevice, params.nqn), DEFINE_PROP_END_OF_LIST(), }; -static void nvme_subsys_class_init(ObjectClass *oc, void *data) +static void subsys_dev_class_init(ObjectClass *oc, void *data) { DeviceClass *dc = DEVICE_CLASS(oc); set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); - dc->realize = nvme_subsys_realize; + dc->realize = subsys_dev_realize; dc->desc = "Virtual NVMe subsystem"; dc->hotpluggable = false; - device_class_set_props(dc, nvme_subsystem_props); + device_class_set_props(dc, subsys_dev_props); } -static const TypeInfo nvme_subsys_info = { - .name = TYPE_NVME_SUBSYS, +static const TypeInfo subsys_dev_info = { + .name = TYPE_NVME_SUBSYS_DEVICE, .parent = TYPE_DEVICE, - .class_init = nvme_subsys_class_init, - .instance_size = sizeof(NvmeSubsystem), + .class_init = subsys_dev_class_init, + .instance_size = sizeof(NvmeSubsystemDevice), }; -static void nvme_subsys_register_types(void) +static void register_types(void) { - type_register_static(&nvme_subsys_info); + type_register_static(&subsys_info); + type_register_static(&subsys_dev_info); } -type_init(nvme_subsys_register_types) +type_init(register_types) diff --git a/qapi/qom.json b/qapi/qom.json index 6d5f4a88e644..8d7c968fbd88 100644 --- a/qapi/qom.json +++ b/qapi/qom.json @@ -647,6 +647,21 @@ '*hugetlbsize': 'size', '*seal': 'bool' } } +## +# @NvmeSubsystemProperties: +# +# Properties for nvme-subsys objects. +# +# @subnqn: the NVM Subsystem NVMe Qualified Name +# +# @uuid: the UUID of the subsystem. Used as default in subnqn. +# +# Since: 6.1 +## +{ 'struct': 'NvmeSubsystemProperties', + 'data': { 'subnqn': 'str', + '*uuid': 'str' } } + ## # @PrManagerHelperProperties: # @@ -797,6 +812,7 @@ { 'name': 'memory-backend-memfd', 'if': 'defined(CONFIG_LINUX)' }, 'memory-backend-ram', + 'x-nvme-subsystem', 'pef-guest', 'pr-manager-helper', 'qtest', @@ -855,6 +871,7 @@ 'memory-backend-memfd': { 'type': 'MemoryBackendMemfdProperties', 'if': 'defined(CONFIG_LINUX)' }, 'memory-backend-ram': 'MemoryBackendProperties', + 'x-nvme-subsystem': 'NvmeSubsystemProperties', 'pr-manager-helper': 'PrManagerHelperProperties', 'qtest': 'QtestProperties', 'rng-builtin': 'RngProperties', -- 2.33.0