shaba/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-12-23 21:34:54 +03:00
Code Releases Activity

hyperv: Reformat

Browse Source 
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>
This commit is contained in:
Michal Privoznik 2020-10-21 14:53:12 +02:00
parent e8fd9c91c2
commit c383dc948e
3 changed files with 185 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
src/hyperv/hyperv_driver.c
View File

@ -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;
}

268
src/hyperv/hyperv_wmi.c
View File

@ -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;

15
src/hyperv/hyperv_wmi.h
View File

@ -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);