Hyper-V 2012+ uses a new "v2" version of Msvm_* WMI classes so we will store that info in hypervPrivate so that it is easily accessbile in the driver API callbacks and handled accordingly. --- src/hyperv/hyperv_private.h | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/hyperv/hyperv_private.h b/src/hyperv/hyperv_private.h index 574bb5f..4e70699 100644 --- a/src/hyperv/hyperv_private.h +++ b/src/hyperv/hyperv_private.h @@ -28,11 +28,17 @@ # include "hyperv_util.h" # include "openwsman.h" -typedef struct _hypervPrivate hypervPrivate; +typedef enum _hypervWmiVersion hypervWmiVersion; +enum _hypervWmiVersion { + HYPERV_WMI_VERSION_V1, + HYPERV_WMI_VERSION_V2, +}; +typedef struct _hypervPrivate hypervPrivate; struct _hypervPrivate { hypervParsedUri *parsedUri; WsManClient *client; + hypervWmiVersion wmiVersion; }; #endif /* __HYPERV_PRIVATE_H__ */ -- 2.9.3

Currently named as hypervObjecUnified to keep code compilable/functional until all bits are in place. This struct is a result of unserializing WMI request response. Therefore, it needs to be able to deal with different "versions" of the same WMI class. To accomplish this, the "data" member was turned in to a union which: * has a "common" member that contains only WMI class fields that are safe to access and are present in all "versions". This is ensured by the code generator that takes care of proper struct memory alignment between "common", "v1", "v2" etc members. This memeber is to be used by the driver code wherever the API implementation can be shared for all supported hyper-v versions. * the "v1" and "v2" member can be used by the driver code to handle version specific cases. Example: Msvm_ComputerSystem *vm = NULL; ... hypervGetVirtualMachineList(priv, wqlQuery, *vm); ... /* safe for "v1" and "v2" */ char *vmName = vm->data.common->Name; /* or if one really needs special handling for "v2" */ if (priv->wmiVersion == HYPERV_WMI_VERSION_V2) { char *foo = vm->data.v2->SomeV2OnlyField; } In other words, driver should not concern itself with existence of "v1" or "v2" of WMI class unless absolutely necessary. --- src/hyperv/hyperv_wmi.h | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/hyperv/hyperv_wmi.h b/src/hyperv/hyperv_wmi.h index ce1fe05..5fc36e8 100644 --- a/src/hyperv/hyperv_wmi.h +++ b/src/hyperv/hyperv_wmi.h @@ -41,6 +41,25 @@ int hypervVerifyResponse(WsManClient *client, WsXmlDocH response, /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Object */ +typedef struct _hypervObjectUnified hypervObjectUnified; +struct _hypervObjectUnified { + /* Unserialized data from wsman response. The member called "common" has + * properties that are the same type and name for all "versions" of given + * WMI class. This means that calling code does not have to make any + * conditional checks based on which version was returned as long as it + * only needs to read common values. The alignment of structs is ensured + * by the generator. + */ + union { + XML_TYPE_PTR common; + XML_TYPE_PTR v1; + XML_TYPE_PTR v2; + } data; + /* The info used to make wsman request */ + hypervWmiClassInfoPtr info; + + hypervObjectUnified *next; +}; struct _hypervObject { XmlSerializerInfo *serializerInfo; -- 2.9.3

This enables this function to handle "v1" and "v2" WMI requests. Since this commit and the ones that follow should be squashed on previous one: * rename hypervObjectUnified -> hypervObject as we've already broken compilation here so there's no point in keeping those in parallel anymore. * do not mark hypervGetWmiClassInfo as unused --- src/hyperv/hyperv_wmi.c | 40 ++++++++++++++++++---------------------- src/hyperv/hyperv_wmi.h | 17 ++++------------- 2 files changed, 22 insertions(+), 35 deletions(-) diff --git a/src/hyperv/hyperv_wmi.c b/src/hyperv/hyperv_wmi.c index bc391e3..40de8d6 100644 --- a/src/hyperv/hyperv_wmi.c +++ b/src/hyperv/hyperv_wmi.c @@ -45,7 +45,7 @@ #define VIR_FROM_THIS VIR_FROM_HYPERV -static int ATTRIBUTE_UNUSED +static int hypervGetWmiClassInfo(hypervPrivate *priv, hypervWmiClassInfoListPtr list, hypervWmiClassInfoPtr *info) { @@ -143,14 +143,13 @@ hypervVerifyResponse(WsManClient *client, WsXmlDocH response, /* This function guarantees that query is freed, even on failure */ int -hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, const char *root, - XmlSerializerInfo *serializerInfo, const char *resourceUri, - const char *className, hypervObject **list) +hypervEnumAndPull(hypervPrivate *priv, hypervWqlQueryPtr wqlQuery, + hypervObject **list) { int result = -1; WsSerializerContextH serializerContext; client_opt_t *options = NULL; - char *query_string = NULL; + hypervWmiClassInfoPtr wmiInfo = NULL; filter_t *filter = NULL; WsXmlDocH response = NULL; char *enumContext = NULL; @@ -160,18 +159,14 @@ hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, const char *root, XML_TYPE_PTR data = NULL; hypervObject *object; - if (virBufferCheckError(query) < 0) { - virBufferFreeAndReset(query); - return -1; - } - query_string = virBufferContentAndReset(query); - if (list == NULL || *list != NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Invalid argument")); - VIR_FREE(query_string); return -1; } + if (hypervGetWmiClassInfo(priv, wqlQuery->info, &wmiInfo) < 0) + return -1; + serializerContext = wsmc_get_serialization_context(priv->client); options = wsmc_options_init(); @@ -182,7 +177,7 @@ hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, const char *root, goto cleanup; } - filter = filter_create_simple(WSM_WQL_FILTER_DIALECT, query_string); + filter = filter_create_simple(WSM_WQL_FILTER_DIALECT, wqlQuery->query); if (filter == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", @@ -190,7 +185,8 @@ hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, const char *root, goto cleanup; } - response = wsmc_action_enumerate(priv->client, root, options, filter); + response = wsmc_action_enumerate(priv->client, wmiInfo->rootUri, options, + filter); if (hypervVerifyResponse(priv->client, response, "enumeration") < 0) goto cleanup; @@ -201,7 +197,7 @@ hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, const char *root, response = NULL; while (enumContext != NULL && *enumContext != '\0') { - response = wsmc_action_pull(priv->client, resourceUri, options, + response = wsmc_action_pull(priv->client, wmiInfo->resourceUri, options, filter, enumContext); if (hypervVerifyResponse(priv->client, response, "pull") < 0) @@ -231,11 +227,12 @@ hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, const char *root, goto cleanup; } - if (ws_xml_get_child(node, 0, resourceUri, className) == NULL) + if (ws_xml_get_child(node, 0, wmiInfo->resourceUri, + wmiInfo->name) == NULL) break; - data = ws_deserialize(serializerContext, node, serializerInfo, - className, resourceUri, NULL, 0, 0); + data = ws_deserialize(serializerContext, node, wmiInfo->serializerInfo, + wmiInfo->name, wmiInfo->resourceUri, NULL, 0, 0); if (data == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", @@ -246,8 +243,8 @@ hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, const char *root, if (VIR_ALLOC(object) < 0) goto cleanup; - object->serializerInfo = serializerInfo; - object->data = data; + object->info = wmiInfo; + object->data.common = data; data = NULL; @@ -283,13 +280,12 @@ hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, const char *root, /* FIXME: ws_serializer_free_mem is broken in openwsman <= 2.2.6, * see hypervFreeObject for a detailed explanation. */ if (ws_serializer_free_mem(serializerContext, data, - serializerInfo) < 0) { + wmiInfo->serializerInfo) < 0) { VIR_ERROR(_("Could not free deserialized data")); } #endif } - VIR_FREE(query_string); ws_xml_destroy_doc(response); VIR_FREE(enumContext); hypervFreeObject(priv, head); diff --git a/src/hyperv/hyperv_wmi.h b/src/hyperv/hyperv_wmi.h index 12b94af..8ce32a9 100644 --- a/src/hyperv/hyperv_wmi.h +++ b/src/hyperv/hyperv_wmi.h @@ -32,7 +32,6 @@ # define HYPERV_WQL_QUERY_INITIALIZER {NULL, NULL} -typedef struct _hypervObject hypervObject; int hypervVerifyResponse(WsManClient *client, WsXmlDocH response, const char *detail); @@ -42,8 +41,8 @@ int hypervVerifyResponse(WsManClient *client, WsXmlDocH response, /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Object */ -typedef struct _hypervObjectUnified hypervObjectUnified; -struct _hypervObjectUnified { +typedef struct _hypervObject hypervObject; +struct _hypervObject { /* Unserialized data from wsman response. The member called "common" has * properties that are the same type and name for all "versions" of given * WMI class. This means that calling code does not have to make any @@ -59,7 +58,7 @@ struct _hypervObjectUnified { /* The info used to make wsman request */ hypervWmiClassInfoPtr info; - hypervObjectUnified *next; + hypervObject *next; }; typedef struct _hypervWqlQuery hypervWqlQuery; @@ -69,15 +68,7 @@ struct _hypervWqlQuery { hypervWmiClassInfoListPtr info; }; -struct _hypervObject { - XmlSerializerInfo *serializerInfo; - XML_TYPE_PTR data; - hypervObject *next; -}; - -int hypervEnumAndPull(hypervPrivate *priv, virBufferPtr query, - const char *root, XmlSerializerInfo *serializerInfo, - const char *resourceUri, const char *className, +int hypervEnumAndPull(hypervPrivate *priv, hypervWqlQueryPtr wqlQuery, hypervObject **list); void hypervFreeObject(hypervPrivate *priv, hypervObject *object); -- 2.9.3

This patch updates the code generator that outputs C headers and code for WMI classes. It has been updated to handle multiple versions (or namespaces) of the same class which were introduced with Hyperv 2012+ --- src/hyperv/hyperv_wmi_generator.py | 385 +++++++++++++++++++++++++++---------- 1 file changed, 288 insertions(+), 97 deletions(-) diff --git a/src/hyperv/hyperv_wmi_generator.py b/src/hyperv/hyperv_wmi_generator.py index 8c62882..f2c9cde 100755 --- a/src/hyperv/hyperv_wmi_generator.py +++ b/src/hyperv/hyperv_wmi_generator.py @@ -24,130 +24,310 @@ import sys import os import os.path +separator = "/*" + ("*" * 50) + "*\n" +wmi_version_separator = "/" +wmi_classes_by_name = {} + +class WmiClass: + """Represents WMI class and provides methods to generate C code. + + This class holds one or more instances of WmiClassVersion because with the + Windows 2012 release, Microsoft introduced "v2" version of Msvm_* family of + classes that need different URI for making wsman requests and also have + some additional/changed properties (though many of the properies are the + same as in "v1". Therefore, this class makes sure that C code is generated + for each of them while avoiding name conflics, identifies common members, + and defined *_WmiInfo structs holding info about each version so the driver + code can make the right choices based on which Hyper-v host it's connected + to. + """ + + def __init__(self, name, versions = []): + self.name = name + self.versions = versions + self.common = None -separator = "/* " + ("* " * 37) + "*\n" + def prepare(self): + """Prepares the class for code generation + Makes sure that "versioned" classes are sorted by version, identfies + common properies and ensures that they are aligned by name and + type in each version + """ + # sort vesioned classes by version in case input file did not have them + # in order + self.versions = sorted(self.versions, key=lambda cls: cls.version) + # if there's more than one verion make sure first one has name suffixed + # because we'll generate "common" memeber and will be the "base" name + if len(self.versions) > 1: + first = self.versions[0] + if first.version == None: + first.version = "v1" + first.name = "%s_%s" % (first.name, first.version) -class Class: - def __init__(self, name, properties): - self.name = name - self.properties = properties + # finally, identify common members in all versions and make sure they + # are in the same order - to ensure C struc member alignment + self._align_property_members() - def generate_header(self): + def generate_classes_header(self): + """Generate C header code and return it as string + + Declares: + <class_name>_Data - used as one of hypervObject->data members + <class_name>_TypeInfo - used as wsman XmlSerializerInfo + <class_name> - "inherits" hypervObject struct + """ + name_upper = self.name.upper() header = separator header += " * %s\n" % self.name header += " */\n" header += "\n" - header += "int hypervGet%sList(hypervPrivate *priv, virBufferPtr query, %s **list);\n" \ - % (self.name.replace("_", ""), self.name) - header += "\n" + header += "#define %s_CLASSNAME \\\n" % name_upper + header += " \"%s\"\n" % self.name header += "\n" + header += "#define %s_WQL_SELECT \\\n" % name_upper + header += " \"SELECT * FROM %s \"\n" % self.name header += "\n" + header += "extern hypervWmiClassInfoListPtr %s_WmiInfo;\n\n" % self.name + + header += self._declare_data_structs() + header += self._declare_hypervObject_struct() return header + def generate_classes_source(self): + """Returns a C code string defining wsman data structs + + Defines: + <class_name>_Data structs + <class_name>_WmiInfo - list holding metadata (e.g. request URIs) for + each known version of WMI class. + """ + + source = separator + source += " * %s\n" % self.name + source += " */\n" + + for cls in self.versions: + source += "SER_START_ITEMS(%s_Data)\n" % cls.name + + for property in cls.properties: + source += property.generate_classes_source(cls.name) + + source += "SER_END_ITEMS(%s_Data);\n\n" % cls.name + + + source += self._define_WmiInfo_struct() + source += "\n\n" + + return source + + def generate_classes_typedef(self): - typedef = "typedef struct _%s_Data %s_Data;\n" % (self.name, self.name) - typedef += "typedef struct _%s %s;\n" % (self.name, self.name) + """Returns C string for typdefs""" + + typedef = "typedef struct _%s %s;\n" % (self.name, self.name) + + if self.common is not None: + typedef += "typedef struct _%s_Data %s_Data;\n" % (self.name, self.name) + + for cls in self.versions: + typedef += "typedef struct _%s_Data %s_Data;\n" % (cls.name, cls.name) return typedef - def generate_classes_header(self): - name_upper = self.name.upper() - header = separator - header += " * %s\n" % self.name - header += " */\n" - header += "\n" - header += "#define %s_RESOURCE_URI \\\n" % name_upper + def _declare_data_structs(self): + """Returns string C code declaring data structs. - if self.name.startswith("Win32_") or self.name.startswith("CIM_"): - header += " \"http://schemas.microsoft.com/wbem/wsman/1/wmi/root/cimv2/%s\"\n" % self.name - else: - header += " \"http://schemas.microsoft.com/wbem/wsman/1/wmi/root/virtualization/%s\"\n" % self.name + The *_Data structs are members of hypervObject data union. Each one has + corresponding *_TypeInfo that is used for wsman unserialization of + response XML into the *_Data structs. If there's a "common" member, it + won't have corresponding *_TypeInfo becuase this is a special case only + used to provide a common "view" of v1, v2 etc members + """ - header += "\n" - header += "#define %s_CLASSNAME \\\n" % name_upper - header += " \"%s\"\n" % self.name - header += "\n" - header += "#define %s_WQL_SELECT \\\n" % name_upper - header += " \"select * from %s \"\n" % self.name - header += "\n" - header += "struct _%s_Data {\n" % self.name + header = "" + if self.common is not None: + header += "struct _%s_Data {\n" % self.name + for property in self.common: + header += property.generate_classes_header() + header += "};\n\n" - for property in self.properties: - header += property.generate_classes_header() + # Declare actual data struct for each versions + for cls in self.versions: + header += "#define %s_RESOURCE_URI \\\n" % cls.name.upper() + header += " \"%s\"\n" % cls.uri_info.resourceUri + header += "\n" + header += "struct _%s_Data {\n" % cls.name + for property in cls.properties: + header += property.generate_classes_header() + header += "};\n\n" + header += "SER_DECLARE_TYPE(%s_Data);\n" % cls.name - header += "};\n" - header += "\n" - header += "SER_DECLARE_TYPE(%s_Data);\n" % self.name - header += "\n" + return header + + + def _declare_hypervObject_struct(self): + """Return string for C code declaring hypervObject instance""" + + header = "\n/* must match hypervObject */\n" header += "struct _%s {\n" % self.name - header += " XmlSerializerInfo *serializerInfo;\n" - header += " %s_Data *data;\n" % self.name + header += " union {\n" + + # if there's common use it as "common" else first and only version is + # the "common" member + if self.common is not None: + header += " %s_Data *common;\n" % self.name + else: + header += " %s_Data *common;\n" % self.versions[0].name + + for cls in self.versions: + header += " %s_Data *%s;\n" % (cls.name, cls.version) + + header += " } data;\n" + header += " hypervWmiClassInfoPtr info;\n" header += " %s *next;\n" % self.name header += "};\n" - header += "\n" - header += "\n" - header += "\n" + + header += "\n\n\n" return header - def generate_source(self): - name_upper = self.name.upper() + def _define_WmiInfo_struct(self): + """Return string for C code defining *_WmiInfo struct - source = separator - source += " * %s\n" % self.name - source += " */\n" - source += "\n" - source += "int\n" - source += "hypervGet%sList(hypervPrivate *priv, virBufferPtr query, %s **list)\n" \ - % (self.name.replace("_", ""), self.name) - source += "{\n" - - if self.name.startswith("Win32_") or self.name.startswith("CIM_"): - source += " return hypervEnumAndPull(priv, query, ROOT_CIMV2,\n" - else: - source += " return hypervEnumAndPull(priv, query, ROOT_VIRTUALIZATION,\n" + Those structs hold info with meta-data needed to make wsman requests for + each version of WMI class + """ + + source = "hypervWmiClassInfoListPtr %s_WmiInfo = &(hypervWmiClassInfoList) {\n" % self.name + source += " .count = %d,\n" % len(self.versions) + source += " .objs = (hypervWmiClassInfoPtr []) {\n" - source += " %s_Data_TypeInfo,\n" % self.name - source += " %s_RESOURCE_URI,\n" % name_upper - source += " %s_CLASSNAME,\n" % name_upper - source += " (hypervObject **)list);\n" - source += "}\n" - source += "\n" - source += "\n" - source += "\n" + for cls in self.versions: + source += " &(hypervWmiClassInfo) {\n" + source += " .name = %s_CLASSNAME,\n" % self.name.upper() + if cls.version is not None: + source += " .version = \"%s\",\n" % cls.version + else: + source += " .version = NULL,\n" + source += " .rootUri = %s,\n" % cls.uri_info.rootUri + source += " .resourceUri = %s_RESOURCE_URI,\n" % cls.name.upper() + source += " .serializerInfo = %s_Data_TypeInfo\n" % cls.name + source += " },\n" + + source += " }\n" + source += "};\n" return source - def generate_classes_source(self): - name_upper = self.name.upper() + def _align_property_members(self): + """Identifies common properties in all class versions. - source = separator - source += " * %s\n" % self.name - source += " */\n" - source += "\n" - source += "SER_START_ITEMS(%s_Data)\n" % self.name + Makes sure that properties in all versions are ordered with common + members first and that they are in the same order. This makes the + generated C structs memory aligned and safe to access via the "common" + struct that "shares" members with v1, v2 etc. + """ - for property in self.properties: - source += property.generate_classes_source(self.name) + num_classes = len(self.versions) + common = {} + property_info = {} - source += "SER_END_ITEMS(%s_Data);\n" % self.name - source += "\n" - source += "\n" - source += "\n" + if num_classes < 2: + return + + # count property occurences in all class versions + for cls in self.versions: + for prop in cls.properties: + # consdered same if matches by name AND type + key = "%s_%s" % (prop.name, prop.type) + + if key in property_info: + property_info[key][1] += 1 + else: + property_info[key] = [prop, 1] + + # isolate those that are common for all and keep track of their postions + pos = 0 + for key in property_info: + info = property_info[key] + # exists in all class versions + if info[1] == num_classes: + common[info[0].name] = [info[0], pos] + pos += 1 + + # alter each versions's property list so that common members are first + # and in the same order as in the common dictionary + total = len(common) + for cls in self.versions: + index = 0 + count = len(cls.properties) + + while index < count: + prop = cls.properties[index] + + # it's a "common" proptery + if prop.name in common: + pos = common[prop.name][1] + + # move to the same position as in "common" dictionary + if index != pos: + tmp = cls.properties[pos] + cls.properties[pos] = prop + cls.properties[index] = tmp + else: + index += 1 + else: + index += 1 + + # finally, get common properties as list sorted by position in dictionary + tmp = sorted(common.values(), key=lambda x: x[1]) + self.common = [] + for x in tmp: + self.common.append(x[0]) + + + +class ClassUriInfo: + """Prepares URI information needed for wsman requests.""" + + def __init__(self, wmi_name, version): + self.rootUri = "ROOT_CIMV2" + self.resourceUri = None + baseUri = "http://schemas.microsoft.com/wbem/wsman/1/wmi/root/cimv2" + + if wmi_name.startswith("Msvm_"): + baseUri = "http://schemas.microsoft.com/wbem/wsman/1/wmi/root/virtualization" + self.rootUri = "ROOT_VIRTUALIZATION" + + if version == "v2": + baseUri += "/v2" + self.rootUri = "ROOT_VIRTUALIZATION_V2" + + self.resourceUri = "%s/%s" % (baseUri, wmi_name) + + + +class WmiClassVersion: + """Represents specific version of WMI class.""" + + def __init__(self, name, version, properties, uri_info): + self.name = name + self.version = version + self.properties = properties + self.uri_info = uri_info - return source class Property: @@ -155,9 +335,13 @@ class Property: "string" : "STR", "datetime" : "STR", "int8" : "INT8", + "sint8" : "INT8", "int16" : "INT16", + "sint16" : "INT16", "int32" : "INT32", + "sint32" : "INT32", "int64" : "INT64", + "sint64" : "INT64", "uint8" : "UINT8", "uint16" : "UINT16", "uint32" : "UINT32", @@ -189,8 +373,6 @@ class Property: return " SER_NS_%s(%s_RESOURCE_URI, \"%s\", 1),\n" \ % (Property.typemap[self.type], class_name.upper(), self.name) - - def open_and_print(filename): if filename.startswith("./"): print " GEN " + filename[2:] @@ -217,8 +399,15 @@ def parse_class(block): assert header_items[0] == "class" name = header_items[1] - properties = [] + version = None + wmi_name = name + ns_separator = name.find(wmi_version_separator) + + if ns_separator != -1: + version = name[:ns_separator] + wmi_name = name[ns_separator + 1:] + name = "%s_%s" % (wmi_name, version) for line in block[1:]: # expected format: <type> <name> @@ -236,7 +425,13 @@ def parse_class(block): properties.append(Property(type=items[0], name=items[1], is_array=is_array)) - return Class(name=name, properties=properties) + cls = WmiClassVersion(name=name, version=version, properties=properties, + uri_info=ClassUriInfo(wmi_name, version)) + + if wmi_name in wmi_classes_by_name: + wmi_classes_by_name[wmi_name].versions.append(cls) + else: + wmi_classes_by_name[wmi_name] = WmiClass(wmi_name, [cls]) @@ -248,15 +443,13 @@ def main(): input_filename = os.path.join(os.getcwd(), "hyperv_wmi_generator.input") output_dirname = os.getcwd() - header = open_and_print(os.path.join(output_dirname, "hyperv_wmi.generated.h")) - source = open_and_print(os.path.join(output_dirname, "hyperv_wmi.generated.c")) + classes_typedef = open_and_print(os.path.join(output_dirname, "hyperv_wmi_classes.generated.typedef")) classes_header = open_and_print(os.path.join(output_dirname, "hyperv_wmi_classes.generated.h")) classes_source = open_and_print(os.path.join(output_dirname, "hyperv_wmi_classes.generated.c")) - # parse input file + number = 0 - classes_by_name = {} block = None for line in file(input_filename, "rb").readlines(): @@ -268,7 +461,7 @@ def main(): line = line.lstrip().rstrip() if len(line) < 1: - continue + continue if line.startswith("class"): if block is not None: @@ -279,8 +472,7 @@ def main(): if block is not None: if line == "end": if block[0][1].startswith("class"): - cls = parse_class(block) - classes_by_name[cls.name] = cls + parse_class(block) block = None else: @@ -289,21 +481,20 @@ def main(): # write output files notice = "/* Generated by hyperv_wmi_generator.py */\n\n\n\n" - header.write(notice) - source.write(notice) classes_typedef.write(notice) classes_header.write(notice) classes_source.write(notice) - names = classes_by_name.keys() + names = wmi_classes_by_name.keys() names.sort() for name in names: - header.write(classes_by_name[name].generate_header()) - source.write(classes_by_name[name].generate_source()) - classes_typedef.write(classes_by_name[name].generate_classes_typedef()) - classes_header.write(classes_by_name[name].generate_classes_header()) - classes_source.write(classes_by_name[name].generate_classes_source()) + cls = wmi_classes_by_name[name] + cls.prepare() + + classes_typedef.write(cls.generate_classes_typedef()) + classes_header.write(cls.generate_classes_header()) + classes_source.write(cls.generate_classes_source()) -- 2.9.3

basically s/data->/data.common->/ Because the data member of hypervObject is a union, get the data via the "common" member everywhere - existing driver does not require special handling for v1 vs v2 separately. --- src/hyperv/hyperv_driver.c | 76 +++++++++++++++++++++++----------------------- src/hyperv/hyperv_wmi.c | 21 ++++++++----- 2 files changed, 51 insertions(+), 46 deletions(-) diff --git a/src/hyperv/hyperv_driver.c b/src/hyperv/hyperv_driver.c index b642a02..5d01c1f 100644 --- a/src/hyperv/hyperv_driver.c +++ b/src/hyperv/hyperv_driver.c @@ -240,7 +240,7 @@ hypervConnectGetHostname(virConnectPtr conn) goto cleanup; } - ignore_value(VIR_STRDUP(hostname, computerSystem->data->DNSHostName)); + ignore_value(VIR_STRDUP(hostname, computerSystem->data.common->DNSHostName)); cleanup: hypervFreeObject(priv, (hypervObject *)computerSystem); @@ -282,7 +282,7 @@ hypervNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info) "{Win32_ComputerSystem.Name=\"%s\"} " "where AssocClass = Win32_ComputerSystemProcessor " "ResultClass = Win32_Processor", - computerSystem->data->Name); + computerSystem->data.common->Name); if (hypervGetWin32ProcessorList(priv, &query, &processorList) < 0) goto cleanup; @@ -295,7 +295,7 @@ hypervNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info) } /* Strip the string to fit more relevant information in 32 chars */ - tmp = processorList->data->Name; + tmp = processorList->data.common->Name; while (*tmp != '\0') { if (STRPREFIX(tmp, " ")) { @@ -313,16 +313,16 @@ hypervNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info) } /* Fill struct */ - if (virStrncpy(info->model, processorList->data->Name, + if (virStrncpy(info->model, processorList->data.common->Name, sizeof(info->model) - 1, sizeof(info->model)) == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, _("CPU model %s too long for destination"), - processorList->data->Name); + processorList->data.common->Name); goto cleanup; } - info->memory = computerSystem->data->TotalPhysicalMemory / 1024; /* byte to kilobyte */ - info->mhz = processorList->data->MaxClockSpeed; + info->memory = computerSystem->data.common->TotalPhysicalMemory / 1024; /* byte to kilobyte */ + info->mhz = processorList->data.common->MaxClockSpeed; info->nodes = 1; info->sockets = 0; @@ -331,8 +331,8 @@ hypervNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info) ++info->sockets; } - info->cores = processorList->data->NumberOfCores; - info->threads = info->cores / processorList->data->NumberOfLogicalProcessors; + info->cores = processorList->data.common->NumberOfCores; + info->threads = info->cores / processorList->data.common->NumberOfLogicalProcessors; info->cpus = info->sockets * info->cores; result = 0; @@ -372,7 +372,7 @@ hypervConnectListDomains(virConnectPtr conn, int *ids, int maxids) for (computerSystem = computerSystemList; computerSystem != NULL; computerSystem = computerSystem->next) { - ids[count++] = computerSystem->data->ProcessID; + ids[count++] = computerSystem->data.common->ProcessID; if (count >= maxids) break; @@ -532,7 +532,7 @@ hypervDomainSuspend(virDomainPtr domain) if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0) goto cleanup; - if (computerSystem->data->EnabledState != + if (computerSystem->data.common->EnabledState != MSVM_COMPUTERSYSTEM_ENABLEDSTATE_ENABLED) { virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("Domain is not active")); @@ -560,7 +560,7 @@ hypervDomainResume(virDomainPtr domain) if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0) goto cleanup; - if (computerSystem->data->EnabledState != + if (computerSystem->data.common->EnabledState != MSVM_COMPUTERSYSTEM_ENABLEDSTATE_PAUSED) { virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("Domain is not paused")); @@ -666,7 +666,7 @@ hypervDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info) virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not lookup %s for domain %s"), "Msvm_VirtualSystemSettingData", - computerSystem->data->ElementName); + computerSystem->data.common->ElementName); goto cleanup; } @@ -676,7 +676,7 @@ hypervDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info) "{Msvm_VirtualSystemSettingData.InstanceID=\"%s\"} " "where AssocClass = Msvm_VirtualSystemSettingDataComponent " "ResultClass = Msvm_ProcessorSettingData", - virtualSystemSettingData->data->InstanceID); + virtualSystemSettingData->data.common->InstanceID); if (hypervGetMsvmProcessorSettingDataList(priv, &query, &processorSettingData) < 0) { @@ -687,7 +687,7 @@ hypervDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info) virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not lookup %s for domain %s"), "Msvm_ProcessorSettingData", - computerSystem->data->ElementName); + computerSystem->data.common->ElementName); goto cleanup; } @@ -697,7 +697,7 @@ hypervDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info) "{Msvm_VirtualSystemSettingData.InstanceID=\"%s\"} " "where AssocClass = Msvm_VirtualSystemSettingDataComponent " "ResultClass = Msvm_MemorySettingData", - virtualSystemSettingData->data->InstanceID); + virtualSystemSettingData->data.common->InstanceID); if (hypervGetMsvmMemorySettingDataList(priv, &query, &memorySettingData) < 0) { @@ -709,15 +709,15 @@ hypervDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info) virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not lookup %s for domain %s"), "Msvm_MemorySettingData", - computerSystem->data->ElementName); + computerSystem->data.common->ElementName); goto cleanup; } /* Fill struct */ info->state = hypervMsvmComputerSystemEnabledStateToDomainState(computerSystem); - info->maxMem = memorySettingData->data->Limit * 1024; /* megabyte to kilobyte */ - info->memory = memorySettingData->data->VirtualQuantity * 1024; /* megabyte to kilobyte */ - info->nrVirtCpu = processorSettingData->data->VirtualQuantity; + info->maxMem = memorySettingData->data.common->Limit * 1024; /* megabyte to kilobyte */ + info->memory = memorySettingData->data.common->VirtualQuantity * 1024; /* megabyte to kilobyte */ + info->nrVirtCpu = processorSettingData->data.common->VirtualQuantity; info->cpuTime = 0; result = 0; @@ -803,7 +803,7 @@ hypervDomainGetXMLDesc(virDomainPtr domain, unsigned int flags) virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not lookup %s for domain %s"), "Msvm_VirtualSystemSettingData", - computerSystem->data->ElementName); + computerSystem->data.common->ElementName); goto cleanup; } @@ -813,7 +813,7 @@ hypervDomainGetXMLDesc(virDomainPtr domain, unsigned int flags) "{Msvm_VirtualSystemSettingData.InstanceID=\"%s\"} " "where AssocClass = Msvm_VirtualSystemSettingDataComponent " "ResultClass = Msvm_ProcessorSettingData", - virtualSystemSettingData->data->InstanceID); + virtualSystemSettingData->data.common->InstanceID); if (hypervGetMsvmProcessorSettingDataList(priv, &query, &processorSettingData) < 0) { @@ -824,7 +824,7 @@ hypervDomainGetXMLDesc(virDomainPtr domain, unsigned int flags) virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not lookup %s for domain %s"), "Msvm_ProcessorSettingData", - computerSystem->data->ElementName); + computerSystem->data.common->ElementName); goto cleanup; } @@ -834,7 +834,7 @@ hypervDomainGetXMLDesc(virDomainPtr domain, unsigned int flags) "{Msvm_VirtualSystemSettingData.InstanceID=\"%s\"} " "where AssocClass = Msvm_VirtualSystemSettingDataComponent " "ResultClass = Msvm_MemorySettingData", - virtualSystemSettingData->data->InstanceID); + virtualSystemSettingData->data.common->InstanceID); if (hypervGetMsvmMemorySettingDataList(priv, &query, &memorySettingData) < 0) { @@ -846,7 +846,7 @@ hypervDomainGetXMLDesc(virDomainPtr domain, unsigned int flags) virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not lookup %s for domain %s"), "Msvm_MemorySettingData", - computerSystem->data->ElementName); + computerSystem->data.common->ElementName); goto cleanup; } @@ -854,34 +854,34 @@ hypervDomainGetXMLDesc(virDomainPtr domain, unsigned int flags) def->virtType = VIR_DOMAIN_VIRT_HYPERV; if (hypervIsMsvmComputerSystemActive(computerSystem, NULL)) { - def->id = computerSystem->data->ProcessID; + def->id = computerSystem->data.common->ProcessID; } else { def->id = -1; } - if (virUUIDParse(computerSystem->data->Name, def->uuid) < 0) { + if (virUUIDParse(computerSystem->data.common->Name, def->uuid) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not parse UUID from string '%s'"), - computerSystem->data->Name); + computerSystem->data.common->Name); return NULL; } - if (VIR_STRDUP(def->name, computerSystem->data->ElementName) < 0) + if (VIR_STRDUP(def->name, computerSystem->data.common->ElementName) < 0) goto cleanup; - if (VIR_STRDUP(def->description, virtualSystemSettingData->data->Notes) < 0) + if (VIR_STRDUP(def->description, virtualSystemSettingData->data.common->Notes) < 0) goto cleanup; - virDomainDefSetMemoryTotal(def, memorySettingData->data->Limit * 1024); /* megabyte to kilobyte */ - def->mem.cur_balloon = memorySettingData->data->VirtualQuantity * 1024; /* megabyte to kilobyte */ + virDomainDefSetMemoryTotal(def, memorySettingData->data.common->Limit * 1024); /* megabyte to kilobyte */ + def->mem.cur_balloon = memorySettingData->data.common->VirtualQuantity * 1024; /* megabyte to kilobyte */ if (virDomainDefSetVcpusMax(def, - processorSettingData->data->VirtualQuantity, + processorSettingData->data.common->VirtualQuantity, NULL) < 0) goto cleanup; if (virDomainDefSetVcpus(def, - processorSettingData->data->VirtualQuantity) < 0) + processorSettingData->data.common->VirtualQuantity) < 0) goto cleanup; def->os.type = VIR_DOMAIN_OSTYPE_HVM; @@ -930,7 +930,7 @@ hypervConnectListDefinedDomains(virConnectPtr conn, char **const names, int maxn for (computerSystem = computerSystemList; computerSystem != NULL; computerSystem = computerSystem->next) { - if (VIR_STRDUP(names[count], computerSystem->data->ElementName) < 0) + if (VIR_STRDUP(names[count], computerSystem->data.common->ElementName) < 0) goto cleanup; ++count; @@ -1154,7 +1154,7 @@ hypervDomainHasManagedSaveImage(virDomainPtr domain, unsigned int flags) if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0) goto cleanup; - result = computerSystem->data->EnabledState == + result = computerSystem->data.common->EnabledState == MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SUSPENDED ? 1 : 0; cleanup: @@ -1177,7 +1177,7 @@ hypervDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags) if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0) goto cleanup; - if (computerSystem->data->EnabledState != + if (computerSystem->data.common->EnabledState != MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SUSPENDED) { virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("Domain has no managed save image")); @@ -1280,7 +1280,7 @@ hypervConnectListAllDomains(virConnectPtr conn, /* managed save filter */ if (MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_MANAGEDSAVE)) { - bool mansave = computerSystem->data->EnabledState == + bool mansave = computerSystem->data.common->EnabledState == MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SUSPENDED; if (!((MATCH(VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE) && mansave) || diff --git a/src/hyperv/hyperv_wmi.c b/src/hyperv/hyperv_wmi.c index 9e62f57..7a9aa52 100644 --- a/src/hyperv/hyperv_wmi.c +++ b/src/hyperv/hyperv_wmi.c @@ -439,6 +439,8 @@ hypervInvokeMsvmComputerSystemRequestStateChange(virDomainPtr domain, virBuffer query = VIR_BUFFER_INITIALIZER; Msvm_ConcreteJob *concreteJob = NULL; bool completed = false; + const char *resourceUri = MSVM_COMPUTERSYSTEM_V2_RESOURCE_URI; + virUUIDFormat(domain->uuid, uuid_string); @@ -447,6 +449,9 @@ hypervInvokeMsvmComputerSystemRequestStateChange(virDomainPtr domain, virAsprintf(&properties, "RequestedState=%d", requestedState) < 0) goto cleanup; + if (priv->wmiVersion == HYPERV_WMI_VERSION_V1) + resourceUri = MSVM_COMPUTERSYSTEM_V2_RESOURCE_URI; + options = wsmc_options_init(); if (options == NULL) { @@ -459,7 +464,7 @@ hypervInvokeMsvmComputerSystemRequestStateChange(virDomainPtr domain, wsmc_add_prop_from_str(options, properties); /* Invoke method */ - response = wsmc_action_invoke(priv->client, MSVM_COMPUTERSYSTEM_RESOURCE_URI, + response = wsmc_action_invoke(priv->client, resourceUri, options, "RequestStateChange", NULL); if (hypervVerifyResponse(priv->client, response, "invocation") < 0) @@ -508,7 +513,7 @@ hypervInvokeMsvmComputerSystemRequestStateChange(virDomainPtr domain, goto cleanup; } - switch (concreteJob->data->JobState) { + switch (concreteJob->data.common->JobState) { case MSVM_CONCRETEJOB_JOBSTATE_NEW: case MSVM_CONCRETEJOB_JOBSTATE_STARTING: case MSVM_CONCRETEJOB_JOBSTATE_RUNNING: @@ -567,7 +572,7 @@ int hypervMsvmComputerSystemEnabledStateToDomainState (Msvm_ComputerSystem *computerSystem) { - switch (computerSystem->data->EnabledState) { + switch (computerSystem->data.common->EnabledState) { case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_UNKNOWN: return VIR_DOMAIN_NOSTATE; @@ -607,7 +612,7 @@ hypervIsMsvmComputerSystemActive(Msvm_ComputerSystem *computerSystem, if (in_transition != NULL) *in_transition = false; - switch (computerSystem->data->EnabledState) { + switch (computerSystem->data.common->EnabledState) { case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_UNKNOWN: return false; @@ -651,20 +656,20 @@ hypervMsvmComputerSystemToDomain(virConnectPtr conn, return -1; } - if (virUUIDParse(computerSystem->data->Name, uuid) < 0) { + if (virUUIDParse(computerSystem->data.common->Name, uuid) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not parse UUID from string '%s'"), - computerSystem->data->Name); + computerSystem->data.common->Name); return -1; } - *domain = virGetDomain(conn, computerSystem->data->ElementName, uuid); + *domain = virGetDomain(conn, computerSystem->data.common->ElementName, uuid); if (*domain == NULL) return -1; if (hypervIsMsvmComputerSystemActive(computerSystem, NULL)) { - (*domain)->id = computerSystem->data->ProcessID; + (*domain)->id = computerSystem->data.common->ProcessID; } else { (*domain)->id = -1; } -- 2.9.3