hyperv: Reformat

This is mostly opening hyperv driver sources in vim, selecting
everything, hitting reformat and then fixing a very few places.

Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
Reviewed-by: Matt Coleman <matt@datto.com>

diff --git a/src/hyperv/hyperv_driver.c b/src/hyperv/hyperv_driver.c
index b8cd213758db800c3b5fc7320284f9ded1e8cc00..002434c56a48a222ed0c460a12dfef64f39b30df 100644 (file)
--- a/src/hyperv/hyperv_driver.c
+++ b/src/hyperv/hyperv_driver.c
@@ -932,8 +932,8 @@ hypervDomainResume(virDomainPtr domain)
         goto cleanup;
     }
 
-    result = hypervInvokeMsvmComputerSystemRequestStateChange
-               (domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_ENABLED);
+    result = hypervInvokeMsvmComputerSystemRequestStateChange(domain,
+                                                              MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_ENABLED);
 
  cleanup:
     hypervFreeObject(priv, (hypervObject *)computerSystem);
@@ -1051,8 +1051,8 @@ hypervDomainDestroyFlags(virDomainPtr domain, unsigned int flags)
         goto cleanup;
     }
 
-    result = hypervInvokeMsvmComputerSystemRequestStateChange
-               (domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_DISABLED);
+    result = hypervInvokeMsvmComputerSystemRequestStateChange(domain,
+                                                              MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_DISABLED);
 
  cleanup:
     hypervFreeObject(priv, (hypervObject *)computerSystem);
@@ -1103,14 +1103,14 @@ hypervDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
     }
 
     if (hypervGetProcSDByVSSDInstanceId(priv,
-                            virtualSystemSettingData->data.common->InstanceID,
-                            &processorSettingData) < 0) {
+                                        virtualSystemSettingData->data.common->InstanceID,
+                                        &processorSettingData) < 0) {
         goto cleanup;
     }
 
     if (hypervGetMemSDByVSSDInstanceId(priv,
-                           virtualSystemSettingData->data.common->InstanceID,
-                           &memorySettingData) < 0) {
+                                       virtualSystemSettingData->data.common->InstanceID,
+                                       &memorySettingData) < 0) {
         goto cleanup;
     }
 
@@ -1189,14 +1189,14 @@ hypervDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
     }
 
     if (hypervGetProcSDByVSSDInstanceId(priv,
-                           virtualSystemSettingData->data.common->InstanceID,
-                           &processorSettingData) < 0) {
+                                        virtualSystemSettingData->data.common->InstanceID,
+                                        &processorSettingData) < 0) {
         goto cleanup;
     }
 
     if (hypervGetMemSDByVSSDInstanceId(priv,
-                           virtualSystemSettingData->data.common->InstanceID,
-                           &memorySettingData) < 0) {
+                                       virtualSystemSettingData->data.common->InstanceID,
+                                       &memorySettingData) < 0) {
         goto cleanup;
     }
 
@@ -1358,8 +1358,8 @@ hypervDomainCreateWithFlags(virDomainPtr domain, unsigned int flags)
         goto cleanup;
     }
 
-    result = hypervInvokeMsvmComputerSystemRequestStateChange
-               (domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_ENABLED);
+    result = hypervInvokeMsvmComputerSystemRequestStateChange(domain,
+                                                              MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_ENABLED);
 
  cleanup:
     hypervFreeObject(priv, (hypervObject *)computerSystem);
@@ -1405,7 +1405,7 @@ hypervDomainGetAutostart(virDomainPtr domain, int *autostart)
         result = 0;
     }
 
-    cleanup:
+ cleanup:
     hypervFreeObject(priv, (hypervObject *) vsgsd);
     hypervFreeObject(priv, (hypervObject *) vssd);
 
@@ -1675,8 +1675,8 @@ hypervDomainManagedSaveRemove(virDomainPtr domain, unsigned int flags)
         goto cleanup;
     }
 
-    result = hypervInvokeMsvmComputerSystemRequestStateChange
-               (domain, MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_DISABLED);
+    result = hypervInvokeMsvmComputerSystemRequestStateChange(domain,
+                                                              MSVM_COMPUTERSYSTEM_REQUESTEDSTATE_DISABLED);
 
  cleanup:
     hypervFreeObject(priv, (hypervObject *)computerSystem);
@@ -1816,8 +1816,8 @@ hypervConnectListAllDomains(virConnectPtr conn,
 
 static int
 hypervDomainSendKey(virDomainPtr domain, unsigned int codeset,
-        unsigned int holdtime, unsigned int *keycodes, int nkeycodes,
-        unsigned int flags)
+                    unsigned int holdtime, unsigned int *keycodes, int nkeycodes,
+                    unsigned int flags)
 {
     int result = -1;
     size_t i = 0;
@@ -1840,11 +1840,11 @@ hypervDomainSendKey(virDomainPtr domain, unsigned int codeset,
         goto cleanup;
 
     virBufferEscapeSQL(&query,
-            "associators of "
-            "{Msvm_ComputerSystem.CreationClassName=\"Msvm_ComputerSystem\","
-            "Name=\"%s\"} "
-            "where ResultClass = Msvm_Keyboard",
-            uuid_string);
+                       "associators of "
+                       "{Msvm_ComputerSystem.CreationClassName=\"Msvm_ComputerSystem\","
+                       "Name=\"%s\"} "
+                       "where ResultClass = Msvm_Keyboard",
+                       uuid_string);
 
     if (hypervGetWmiClass(Msvm_Keyboard, &keyboard) < 0)
         goto cleanup;
@@ -1854,12 +1854,13 @@ hypervDomainSendKey(virDomainPtr domain, unsigned int codeset,
     /* translate keycodes to win32 and generate keyup scancodes. */
     for (i = 0; i < nkeycodes; i++) {
         if (codeset != VIR_KEYCODE_SET_WIN32) {
-            keycode = virKeycodeValueTranslate(codeset, VIR_KEYCODE_SET_WIN32,
-                    keycodes[i]);
+            keycode = virKeycodeValueTranslate(codeset,
+                                               VIR_KEYCODE_SET_WIN32,
+                                               keycodes[i]);
 
             if (keycode < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Could not translate keycode"));
+                               _("Could not translate keycode"));
                 goto cleanup;
             }
             translatedKeycodes[i] = keycode;
@@ -1907,8 +1908,8 @@ hypervDomainSendKey(virDomainPtr domain, unsigned int codeset,
             goto cleanup;
 
         if (hypervInvokeMethod(priv, &params, NULL) < 0) {
-            virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not release key %s"),
-                    keycodeStr);
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Could not release key %s"), keycodeStr);
             goto cleanup;
         }
     }
@@ -1926,7 +1927,7 @@ hypervDomainSendKey(virDomainPtr domain, unsigned int codeset,
 
 static int
 hypervDomainSetMemoryFlags(virDomainPtr domain, unsigned long memory,
-        unsigned int flags)
+                           unsigned int flags)
 {
     int result = -1;
     char uuid_string[VIR_UUID_STRING_BUFLEN];
@@ -1949,7 +1950,7 @@ hypervDomainSetMemoryFlags(virDomainPtr domain, unsigned long memory,
         goto cleanup;
 
     if (hypervGetMsvmMemorySettingDataFromVSSD(priv, vssd->data.common->InstanceID,
-                &memsd) < 0)
+                                               &memsd) < 0)
         goto cleanup;
 
     if (priv->wmiVersion == HYPERV_WMI_VERSION_V1) {
@@ -1964,7 +1965,7 @@ hypervDomainSetMemoryFlags(virDomainPtr domain, unsigned long memory,
         virBufferEscapeSQL(&eprQuery, "where Name = \"%s\"", uuid_string);
 
         if (hypervAddEprParam(params, "ComputerSystem", priv, &eprQuery,
-                    Msvm_ComputerSystem_WmiInfo) < 0)
+                              Msvm_ComputerSystem_WmiInfo) < 0)
             goto cleanup;
     } else if (priv->wmiVersion == HYPERV_WMI_VERSION_V2) {
         params = hypervCreateInvokeParamsList(priv, "ModifyResourceSettings",
@@ -1983,7 +1984,7 @@ hypervDomainSetMemoryFlags(virDomainPtr domain, unsigned long memory,
         goto cleanup;
 
     if (hypervSetEmbeddedProperty(memResource, "InstanceID",
-                memsd->data.common->InstanceID) < 0) {
+                                  memsd->data.common->InstanceID) < 0) {
         goto cleanup;
     }
 
@@ -2079,30 +2080,30 @@ hypervDebugHandler(const char *message, debug_level_e level,
                    void *user_data G_GNUC_UNUSED)
 {
     switch (level) {
-      case DEBUG_LEVEL_ERROR:
-      case DEBUG_LEVEL_CRITICAL:
-      case DEBUG_LEVEL_ALWAYS:
+    case DEBUG_LEVEL_ERROR:
+    case DEBUG_LEVEL_CRITICAL:
+    case DEBUG_LEVEL_ALWAYS:
         VIR_ERROR(_("openwsman: %s"), message);
         break;
 
-      case DEBUG_LEVEL_WARNING:
+    case DEBUG_LEVEL_WARNING:
         VIR_WARN("openwsman: %s", message);
         break;
 
-      case DEBUG_LEVEL_MESSAGE:
+    case DEBUG_LEVEL_MESSAGE:
         VIR_INFO("openwsman: %s", message);
         break;
 
-      case DEBUG_LEVEL_INFO:
+    case DEBUG_LEVEL_INFO:
         VIR_INFO("openwsman: %s", message);
         break;
 
-      case DEBUG_LEVEL_DEBUG:
+    case DEBUG_LEVEL_DEBUG:
         VIR_DEBUG("openwsman: %s", message);
         break;
 
-      case DEBUG_LEVEL_NONE:
-      default:
+    case DEBUG_LEVEL_NONE:
+    default:
         /* Ignore the rest */
         break;
     }

diff --git a/src/hyperv/hyperv_wmi.c b/src/hyperv/hyperv_wmi.c
index 96ebd1fb0c373fd0aa764bb59cd01689d21ef3f3..421cbfa31b288d8e97fbe88644ba064f6b6ffe7a 100644 (file)
--- a/src/hyperv/hyperv_wmi.c
+++ b/src/hyperv/hyperv_wmi.c
@@ -72,10 +72,10 @@ hypervGetWmiClassInfo(hypervPrivate *priv, hypervWmiClassInfoListPtr list,
         version = "v1";
 
     for (i = 0; i < list->count; i++) {
-       if (STRCASEEQ(list->objs[i]->version, version)) {
-           *info = list->objs[i];
-           return 0;
-       }
+        if (STRCASEEQ(list->objs[i]->version, version)) {
+            *info = list->objs[i];
+            return 0;
+        }
     }
 
     virReportError(VIR_ERR_INTERNAL_ERROR,
@@ -172,7 +172,7 @@ hypervVerifyResponse(WsManClient *client, WsXmlDocH response,
  */
 hypervInvokeParamsListPtr
 hypervCreateInvokeParamsList(hypervPrivate *priv, const char *method,
-        const char *selector, hypervWmiClassInfoListPtr obj)
+                             const char *selector, hypervWmiClassInfoListPtr obj)
 {
     hypervInvokeParamsListPtr params = NULL;
     hypervWmiClassInfoPtr info = NULL;
@@ -213,17 +213,17 @@ hypervFreeInvokeParams(hypervInvokeParamsListPtr params)
         p = &(params->params[i]);
 
         switch (p->type) {
-            case HYPERV_SIMPLE_PARAM:
-                break;
-            case HYPERV_EPR_PARAM:
-                virBufferFreeAndReset(p->epr.query);
-                break;
-            case HYPERV_EMBEDDED_PARAM:
-                hypervFreeEmbeddedParam(p->embedded.table);
-                break;
-            default:
-                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Invalid parameter type passed to free"));
+        case HYPERV_SIMPLE_PARAM:
+            break;
+        case HYPERV_EPR_PARAM:
+            virBufferFreeAndReset(p->epr.query);
+            break;
+        case HYPERV_EMBEDDED_PARAM:
+            hypervFreeEmbeddedParam(p->embedded.table);
+            break;
+        default:
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("Invalid parameter type passed to free"));
         }
     }
 
@@ -257,7 +257,7 @@ hypervCheckParams(hypervInvokeParamsListPtr params)
  */
 int
 hypervAddSimpleParam(hypervInvokeParamsListPtr params, const char *name,
-        const char *value)
+                     const char *value)
 {
     hypervParamPtr p = NULL;
 
@@ -288,14 +288,14 @@ hypervAddSimpleParam(hypervInvokeParamsListPtr params, const char *name,
  */
 int
 hypervAddEprParam(hypervInvokeParamsListPtr params, const char *name,
-        hypervPrivate *priv, virBufferPtr query,
-        hypervWmiClassInfoListPtr eprInfo)
+                  hypervPrivate *priv, virBufferPtr query,
+                  hypervWmiClassInfoListPtr eprInfo)
 {
     hypervParamPtr p = NULL;
     hypervWmiClassInfoPtr classInfo = NULL;
 
     if (hypervGetWmiClassInfo(priv, eprInfo, &classInfo) < 0 ||
-            hypervCheckParams(params) < 0)
+        hypervCheckParams(params) < 0)
         return -1;
 
     p = &params->params[params->nbParams];
@@ -437,7 +437,7 @@ hypervFreeEmbeddedParam(virHashTablePtr p)
  */
 static int
 hypervGetCimTypeInfo(hypervCimTypePtr typemap, const char *name,
-        hypervCimTypePtr *property)
+                     hypervCimTypePtr *property)
 {
     size_t i = 0;
     while (typemap[i].name[0] != '\0') {
@@ -464,14 +464,14 @@ hypervCreateInvokeXmlDoc(hypervInvokeParamsListPtr params, WsXmlDocH *docRoot)
     *docRoot = ws_xml_create_doc(NULL, method);
     if (*docRoot == NULL) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not instantiate XML document"));
+                       _("Could not instantiate XML document"));
         goto cleanup;
     }
 
     xmlNodeMethod = xml_parser_get_root(*docRoot);
     if (xmlNodeMethod == NULL) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not get root node of XML document"));
+                       _("Could not get root node of XML document"));
         goto cleanup;
     }
 
@@ -492,15 +492,15 @@ hypervCreateInvokeXmlDoc(hypervInvokeParamsListPtr params, WsXmlDocH *docRoot)
 
 static int
 hypervSerializeSimpleParam(hypervParamPtr p, const char *resourceUri,
-        WsXmlNodeH *methodNode)
+                           WsXmlNodeH *methodNode)
 {
     WsXmlNodeH xmlNodeParam = NULL;
 
     xmlNodeParam = ws_xml_add_child(*methodNode, resourceUri,
-            p->simple.name, p->simple.value);
+                                    p->simple.name, p->simple.value);
     if (xmlNodeParam == NULL) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not create simple param"));
+                       _("Could not create simple param"));
         return -1;
     }
 
@@ -510,7 +510,7 @@ hypervSerializeSimpleParam(hypervParamPtr p, const char *resourceUri,
 
 static int
 hypervSerializeEprParam(hypervParamPtr p, hypervPrivate *priv,
-        const char *resourceUri, WsXmlNodeH *methodNode)
+                        const char *resourceUri, WsXmlNodeH *methodNode)
 {
     int result = -1;
     WsXmlNodeH xmlNodeParam = NULL,
@@ -542,7 +542,7 @@ hypervSerializeEprParam(hypervParamPtr p, hypervPrivate *priv,
 
     /* enumerate based on the filter from this query */
     xmlDocResponse = wsmc_action_enumerate(priv->client, p->epr.info->rootUri,
-            options, filter);
+                                           options, filter);
     if (hypervVerifyResponse(priv->client, xmlDocResponse, "enumeration") < 0)
         goto cleanup;
 
@@ -552,7 +552,7 @@ hypervSerializeEprParam(hypervParamPtr p, hypervPrivate *priv,
 
     /* Pull using filter and enum context */
     xmlDocResponse = wsmc_action_pull(priv->client, resourceUri, options,
-            filter, enumContext);
+                                      filter, enumContext);
 
     if (hypervVerifyResponse(priv->client, xmlDocResponse, "pull") < 0)
         goto cleanup;
@@ -564,7 +564,7 @@ hypervSerializeEprParam(hypervParamPtr p, hypervPrivate *priv,
     }
 
     if (!(xmlNodeTemp = ws_xml_get_child(xmlNodeTemp, 0, XML_NS_ENUMERATION,
-            WSENUM_PULL_RESP))) {
+                                         WSENUM_PULL_RESP))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not get response"));
         goto cleanup;
     }
@@ -580,37 +580,37 @@ hypervSerializeEprParam(hypervParamPtr p, hypervPrivate *priv,
     }
 
     if (!(xmlNodeAddr = ws_xml_get_child(xmlNodeTemp, 0, XML_NS_ADDRESSING,
-                    WSA_ADDRESS))) {
+                                         WSA_ADDRESS))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not get EPR address"));
         goto cleanup;
     }
 
     if (!(xmlNodeRef = ws_xml_get_child(xmlNodeTemp, 0, XML_NS_ADDRESSING,
-            WSA_REFERENCE_PARAMETERS))) {
+                                        WSA_REFERENCE_PARAMETERS))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not lookup EPR item reference parameters"));
+                       _("Could not lookup EPR item reference parameters"));
         goto cleanup;
     }
 
     /* now build a new xml doc with the EPR node children */
     if (!(xmlNodeParam = ws_xml_add_child(*methodNode, resourceUri,
-                    p->epr.name, NULL))) {
+                                          p->epr.name, NULL))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not add child node to methodNode"));
+                       _("Could not add child node to methodNode"));
         goto cleanup;
     }
 
     if (!(ns = ws_xml_ns_add(xmlNodeParam,
-                    "http://schemas.xmlsoap.org/ws/2004/08/addressing", "a"))) {
+                             "http://schemas.xmlsoap.org/ws/2004/08/addressing", "a"))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not set namespace address for xmlNodeParam"));
+                       _("Could not set namespace address for xmlNodeParam"));
         goto cleanup;
     }
 
     if (!(ns = ws_xml_ns_add(xmlNodeParam,
-                    "http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd", "w"))) {
+                             "http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd", "w"))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not set wsman namespace address for xmlNodeParam"));
+                       _("Could not set wsman namespace address for xmlNodeParam"));
         goto cleanup;
     }
 
@@ -634,7 +634,7 @@ hypervSerializeEprParam(hypervParamPtr p, hypervPrivate *priv,
 
 static int
 hypervSerializeEmbeddedParam(hypervParamPtr p, const char *resourceUri,
-        WsXmlNodeH *methodNode)
+                             WsXmlNodeH *methodNode)
 {
     int result = -1;
     WsXmlNodeH xmlNodeInstance = NULL,
@@ -652,9 +652,9 @@ hypervSerializeEmbeddedParam(hypervParamPtr p, const char *resourceUri,
     int len = 0, i = 0;
 
     if (!(xmlNodeParam = ws_xml_add_child(*methodNode, resourceUri, p->embedded.name,
-                    NULL))) {
+                                          NULL))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, _("Could not add child node %s"),
-                p->embedded.name);
+                       p->embedded.name);
         goto cleanup;
     }
 
@@ -663,21 +663,21 @@ hypervSerializeEmbeddedParam(hypervParamPtr p, const char *resourceUri,
     /* start with the INSTANCE node */
     if (!(xmlDocTemp = ws_xml_create_doc(NULL, "INSTANCE"))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not create temporary xml doc"));
+                       _("Could not create temporary xml doc"));
         goto cleanup;
     }
 
     if (!(xmlNodeInstance = xml_parser_get_root(xmlDocTemp))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not get temp xml doc root"));
+                       _("Could not get temp xml doc root"));
         goto cleanup;
     }
 
     /* add CLASSNAME node to INSTANCE node */
     if (!(ws_xml_add_node_attr(xmlNodeInstance, NULL, "CLASSNAME",
-                classInfo->name))) {
+                               classInfo->name))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not add attribute to node"));
+                       _("Could not add attribute to node"));
         goto cleanup;
     }
 
@@ -686,7 +686,7 @@ hypervSerializeEmbeddedParam(hypervParamPtr p, const char *resourceUri,
     items = virHashGetItems(p->embedded.table, NULL);
     if (!items) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not read embedded param hash table"));
+                       _("Could not read embedded param hash table"));
         goto cleanup;
     }
 
@@ -697,47 +697,47 @@ hypervSerializeEmbeddedParam(hypervParamPtr p, const char *resourceUri,
 
         if (value != NULL) {
             if (hypervGetCimTypeInfo(classInfo->propertyInfo, name,
-                        &property) < 0) {
+                                     &property) < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Could not read type information"));
+                               _("Could not read type information"));
                 goto cleanup;
             }
 
             if (!(xmlNodeProperty = ws_xml_add_child(xmlNodeInstance, NULL,
-                            property->isArray ? "PROPERTY.ARRAY" : "PROPERTY",
-                            NULL))) {
+                                                     property->isArray ? "PROPERTY.ARRAY" : "PROPERTY",
+                                                     NULL))) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Could not add child to XML node"));
+                               _("Could not add child to XML node"));
                 goto cleanup;
             }
 
             if (!(ws_xml_add_node_attr(xmlNodeProperty, NULL, "NAME", name))) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Could not add attribute to XML node"));
+                               _("Could not add attribute to XML node"));
                 goto cleanup;
             }
 
             if (!(ws_xml_add_node_attr(xmlNodeProperty, NULL, "TYPE", property->type))) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Could not add attribute to XML node"));
+                               _("Could not add attribute to XML node"));
                 goto cleanup;
             }
 
             /* If this attribute is an array, add VALUE.ARRAY node */
             if (property->isArray) {
                 if (!(xmlNodeArray = ws_xml_add_child(xmlNodeProperty, NULL,
-                                "VALUE.ARRAY", NULL))) {
+                                                      "VALUE.ARRAY", NULL))) {
                     virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                            _("Could not add child to XML node"));
+                                   _("Could not add child to XML node"));
                     goto cleanup;
                 }
             }
 
             /* add the child */
             if (!(ws_xml_add_child(property->isArray ? xmlNodeArray : xmlNodeProperty,
-                        NULL, "VALUE", value))) {
+                                   NULL, "VALUE", value))) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                        _("Could not add child to XML node"));
+                               _("Could not add child to XML node"));
                 goto cleanup;
             }
 
@@ -750,9 +750,9 @@ hypervSerializeEmbeddedParam(hypervParamPtr p, const char *resourceUri,
     ws_xml_dump_memory_node_tree(xmlNodeInstance, &cdataContent, &len);
 
     if (!(xmlNodeCdata = xmlNewCDataBlock((xmlDocPtr) xmlDocCdata,
-                    (xmlChar *)cdataContent, len))) {
+                                          (xmlChar *)cdataContent, len))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not create CDATA element"));
+                       _("Could not create CDATA element"));
         goto cleanup;
     }
 
@@ -764,7 +764,7 @@ hypervSerializeEmbeddedParam(hypervParamPtr p, const char *resourceUri,
      */
     if (!(xmlAddChild((xmlNodePtr)(void *)xmlNodeParam, xmlNodeCdata))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                _("Could not add CDATA to doc root"));
+                       _("Could not add CDATA to doc root"));
         goto cleanup;
     }
 
@@ -1177,73 +1177,73 @@ const char *
 hypervReturnCodeToString(int returnCode)
 {
     switch (returnCode) {
-      case CIM_RETURNCODE_COMPLETED_WITH_NO_ERROR:
+    case CIM_RETURNCODE_COMPLETED_WITH_NO_ERROR:
         return _("Completed with no error");
 
-      case CIM_RETURNCODE_NOT_SUPPORTED:
+    case CIM_RETURNCODE_NOT_SUPPORTED:
         return _("Not supported");
 
-      case CIM_RETURNCODE_UNKNOWN_ERROR:
+    case CIM_RETURNCODE_UNKNOWN_ERROR:
         return _("Unknown error");
 
-      case CIM_RETURNCODE_CANNOT_COMPLETE_WITHIN_TIMEOUT_PERIOD:
+    case CIM_RETURNCODE_CANNOT_COMPLETE_WITHIN_TIMEOUT_PERIOD:
         return _("Cannot complete within timeout period");
 
-      case CIM_RETURNCODE_FAILED:
+    case CIM_RETURNCODE_FAILED:
         return _("Failed");
 
-      case CIM_RETURNCODE_INVALID_PARAMETER:
+    case CIM_RETURNCODE_INVALID_PARAMETER:
         return _("Invalid parameter");
 
-      case CIM_RETURNCODE_IN_USE:
+    case CIM_RETURNCODE_IN_USE:
         return _("In use");
 
-      case CIM_RETURNCODE_TRANSITION_STARTED:
+    case CIM_RETURNCODE_TRANSITION_STARTED:
         return _("Transition started");
 
-      case CIM_RETURNCODE_INVALID_STATE_TRANSITION:
+    case CIM_RETURNCODE_INVALID_STATE_TRANSITION:
         return _("Invalid state transition");
 
-      case CIM_RETURNCODE_TIMEOUT_PARAMETER_NOT_SUPPORTED:
+    case CIM_RETURNCODE_TIMEOUT_PARAMETER_NOT_SUPPORTED:
         return _("Timeout parameter not supported");
 
-      case CIM_RETURNCODE_BUSY:
+    case CIM_RETURNCODE_BUSY:
         return _("Busy");
 
-      case MSVM_RETURNCODE_FAILED:
+    case MSVM_RETURNCODE_FAILED:
         return _("Failed");
 
-      case MSVM_RETURNCODE_ACCESS_DENIED:
+    case MSVM_RETURNCODE_ACCESS_DENIED:
         return _("Access denied");
 
-      case MSVM_RETURNCODE_NOT_SUPPORTED:
+    case MSVM_RETURNCODE_NOT_SUPPORTED:
         return _("Not supported");
 
-      case MSVM_RETURNCODE_STATUS_IS_UNKNOWN:
+    case MSVM_RETURNCODE_STATUS_IS_UNKNOWN:
         return _("Status is unknown");
 
-      case MSVM_RETURNCODE_TIMEOUT:
+    case MSVM_RETURNCODE_TIMEOUT:
         return _("Timeout");
 
-      case MSVM_RETURNCODE_INVALID_PARAMETER:
+    case MSVM_RETURNCODE_INVALID_PARAMETER:
         return _("Invalid parameter");
 
-      case MSVM_RETURNCODE_SYSTEM_IS_IN_USE:
+    case MSVM_RETURNCODE_SYSTEM_IS_IN_USE:
         return _("System is in use");
 
-      case MSVM_RETURNCODE_INVALID_STATE_FOR_THIS_OPERATION:
+    case MSVM_RETURNCODE_INVALID_STATE_FOR_THIS_OPERATION:
         return _("Invalid state for this operation");
 
-      case MSVM_RETURNCODE_INCORRECT_DATA_TYPE:
+    case MSVM_RETURNCODE_INCORRECT_DATA_TYPE:
         return _("Incorrect data type");
 
-      case MSVM_RETURNCODE_SYSTEM_IS_NOT_AVAILABLE:
+    case MSVM_RETURNCODE_SYSTEM_IS_NOT_AVAILABLE:
         return _("System is not available");
 
-      case MSVM_RETURNCODE_OUT_OF_MEMORY:
+    case MSVM_RETURNCODE_OUT_OF_MEMORY:
         return _("Out of memory");
 
-      default:
+    default:
         return _("Unknown return code");
     }
 }
@@ -1343,30 +1343,30 @@ hypervInvokeMsvmComputerSystemRequestStateChange(virDomainPtr domain,
             }
 
             switch (concreteJob->data.common->JobState) {
-              case MSVM_CONCRETEJOB_JOBSTATE_NEW:
-              case MSVM_CONCRETEJOB_JOBSTATE_STARTING:
-              case MSVM_CONCRETEJOB_JOBSTATE_RUNNING:
-              case MSVM_CONCRETEJOB_JOBSTATE_SHUTTING_DOWN:
+            case MSVM_CONCRETEJOB_JOBSTATE_NEW:
+            case MSVM_CONCRETEJOB_JOBSTATE_STARTING:
+            case MSVM_CONCRETEJOB_JOBSTATE_RUNNING:
+            case MSVM_CONCRETEJOB_JOBSTATE_SHUTTING_DOWN:
                 hypervFreeObject(priv, (hypervObject *)concreteJob);
                 concreteJob = NULL;
 
                 g_usleep(100 * 1000);
                 continue;
 
-              case MSVM_CONCRETEJOB_JOBSTATE_COMPLETED:
+            case MSVM_CONCRETEJOB_JOBSTATE_COMPLETED:
                 completed = true;
                 break;
 
-              case MSVM_CONCRETEJOB_JOBSTATE_TERMINATED:
-              case MSVM_CONCRETEJOB_JOBSTATE_KILLED:
-              case MSVM_CONCRETEJOB_JOBSTATE_EXCEPTION:
-              case MSVM_CONCRETEJOB_JOBSTATE_SERVICE:
+            case MSVM_CONCRETEJOB_JOBSTATE_TERMINATED:
+            case MSVM_CONCRETEJOB_JOBSTATE_KILLED:
+            case MSVM_CONCRETEJOB_JOBSTATE_EXCEPTION:
+            case MSVM_CONCRETEJOB_JOBSTATE_SERVICE:
                 virReportError(VIR_ERR_INTERNAL_ERROR,
                                _("Concrete job for %s invocation is in error state"),
                                "RequestStateChange");
                 goto cleanup;
 
-              default:
+            default:
                 virReportError(VIR_ERR_INTERNAL_ERROR,
                                _("Concrete job for %s invocation is in unknown state"),
                                "RequestStateChange");
@@ -1400,37 +1400,37 @@ hypervInvokeMsvmComputerSystemRequestStateChange(virDomainPtr domain,
 
 int
 hypervMsvmComputerSystemEnabledStateToDomainState
-  (Msvm_ComputerSystem *computerSystem)
+(Msvm_ComputerSystem *computerSystem)
 {
     switch (computerSystem->data.common->EnabledState) {
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_UNKNOWN:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_UNKNOWN:
         return VIR_DOMAIN_NOSTATE;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_ENABLED:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_ENABLED:
         return VIR_DOMAIN_RUNNING;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_DISABLED:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_DISABLED:
         return VIR_DOMAIN_SHUTOFF;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_PAUSED:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_PAUSED:
         return VIR_DOMAIN_PAUSED;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SUSPENDED: /* managed save */
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SUSPENDED: /* managed save */
         return VIR_DOMAIN_SHUTOFF;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_STARTING:
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SNAPSHOTTING:
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SAVING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_STARTING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SNAPSHOTTING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SAVING:
         return VIR_DOMAIN_RUNNING;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_STOPPING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_STOPPING:
         return VIR_DOMAIN_SHUTDOWN;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_PAUSING:
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_RESUMING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_PAUSING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_RESUMING:
         return VIR_DOMAIN_RUNNING;
 
-      default:
+    default:
         return VIR_DOMAIN_NOSTATE;
     }
 }
@@ -1444,33 +1444,33 @@ hypervIsMsvmComputerSystemActive(Msvm_ComputerSystem *computerSystem,
         *in_transition = false;
 
     switch (computerSystem->data.common->EnabledState) {
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_UNKNOWN:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_UNKNOWN:
         return false;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_ENABLED:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_ENABLED:
         return true;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_DISABLED:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_DISABLED:
         return false;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_PAUSED:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_PAUSED:
         return true;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SUSPENDED: /* managed save */
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SUSPENDED: /* managed save */
         return false;
 
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_STARTING:
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SNAPSHOTTING:
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SAVING:
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_STOPPING:
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_PAUSING:
-      case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_RESUMING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_STARTING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SNAPSHOTTING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_SAVING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_STOPPING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_PAUSING:
+    case MSVM_COMPUTERSYSTEM_ENABLEDSTATE_RESUMING:
         if (in_transition != NULL)
             *in_transition = true;
 
         return true;
 
-      default:
+    default:
         return false;
     }
 }
@@ -1545,20 +1545,20 @@ hypervMsvmComputerSystemFromDomain(virDomainPtr domain,
 
 int
 hypervGetMsvmVirtualSystemSettingDataFromUUID(hypervPrivate *priv,
-        const char *uuid_string, Msvm_VirtualSystemSettingData **list)
+                                              const char *uuid_string, Msvm_VirtualSystemSettingData **list)
 {
     g_auto(virBuffer) query = VIR_BUFFER_INITIALIZER;
 
     virBufferAsprintf(&query,
-            "associators of "
-            "{Msvm_ComputerSystem.CreationClassName=\"Msvm_ComputerSystem\","
-            "Name=\"%s\"} "
-            "where AssocClass = Msvm_SettingsDefineState "
-            "ResultClass = Msvm_VirtualSystemSettingData",
-            uuid_string);
+                      "associators of "
+                      "{Msvm_ComputerSystem.CreationClassName=\"Msvm_ComputerSystem\","
+                      "Name=\"%s\"} "
+                      "where AssocClass = Msvm_SettingsDefineState "
+                      "ResultClass = Msvm_VirtualSystemSettingData",
+                      uuid_string);
 
     if (hypervGetWmiClassList(priv, Msvm_VirtualSystemSettingData_WmiInfo, &query,
-                (hypervObject **)list) < 0 || *list == NULL)
+                              (hypervObject **)list) < 0 || *list == NULL)
         return -1;
 
     return 0;
@@ -1571,19 +1571,19 @@ hypervGetMsvmVirtualSystemSettingDataFromUUID(hypervPrivate *priv,
 
 int
 hypervGetMsvmMemorySettingDataFromVSSD(hypervPrivate *priv,
-        const char *vssd_instanceid, Msvm_MemorySettingData **list)
+                                       const char *vssd_instanceid, Msvm_MemorySettingData **list)
 {
     g_auto(virBuffer) query = VIR_BUFFER_INITIALIZER;
 
     virBufferAsprintf(&query,
-            "associators of "
-            "{Msvm_VirtualSystemSettingData.InstanceID=\"%s\"} "
-            "where AssocClass = Msvm_VirtualSystemSettingDataComponent "
-            "ResultClass = Msvm_MemorySettingData",
-            vssd_instanceid);
+                      "associators of "
+                      "{Msvm_VirtualSystemSettingData.InstanceID=\"%s\"} "
+                      "where AssocClass = Msvm_VirtualSystemSettingDataComponent "
+                      "ResultClass = Msvm_MemorySettingData",
+                      vssd_instanceid);
 
     if (hypervGetWmiClassList(priv, Msvm_MemorySettingData_WmiInfo, &query,
-                (hypervObject **)list) < 0 || *list == NULL)
+                              (hypervObject **)list) < 0 || *list == NULL)
         return -1;
 
     return 0;

diff --git a/src/hyperv/hyperv_wmi.h b/src/hyperv/hyperv_wmi.h
index 3a623e99fa27280421f62c5a0118d7b9b1a4f5a5..570aa07eb807ed078f691fac0f20d01e016eeb23 100644 (file)
--- a/src/hyperv/hyperv_wmi.h
+++ b/src/hyperv/hyperv_wmi.h
@@ -132,20 +132,22 @@ typedef hypervInvokeParamsList *hypervInvokeParamsListPtr;
 
 
 hypervInvokeParamsListPtr hypervCreateInvokeParamsList(hypervPrivate *priv,
-        const char *method, const char *selector, hypervWmiClassInfoListPtr obj);
+                                                       const char *method,
+                                                       const char *selector,
+                                                       hypervWmiClassInfoListPtr obj);
 
 void hypervFreeInvokeParams(hypervInvokeParamsListPtr params);
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(hypervInvokeParamsList, hypervFreeInvokeParams);
 
 int hypervAddSimpleParam(hypervInvokeParamsListPtr params, const char *name,
-        const char *value);
+                         const char *value);
 
 int hypervAddEprParam(hypervInvokeParamsListPtr params, const char *name,
-        hypervPrivate *priv, virBufferPtr query,
-        hypervWmiClassInfoListPtr eprInfo);
+                      hypervPrivate *priv, virBufferPtr query,
+                      hypervWmiClassInfoListPtr eprInfo);
 
 virHashTablePtr hypervCreateEmbeddedParam(hypervPrivate *priv,
-        hypervWmiClassInfoListPtr info);
+                                          hypervWmiClassInfoListPtr info);
 
 int hypervSetEmbeddedProperty(virHashTablePtr table,
                               const char *name,
@@ -222,8 +224,7 @@ int hypervGetMsvmMemorySettingDataFromVSSD(hypervPrivate *priv,
 int hypervInvokeMsvmComputerSystemRequestStateChange(virDomainPtr domain,
                                                      int requestedState);
 
-int hypervMsvmComputerSystemEnabledStateToDomainState
-      (Msvm_ComputerSystem *computerSystem);
+int hypervMsvmComputerSystemEnabledStateToDomainState(Msvm_ComputerSystem *computerSystem);
 
 bool hypervIsMsvmComputerSystemActive(Msvm_ComputerSystem *computerSystem,
                                       bool *in_transition);