/**
* virConfWriteMem:
* @memory: pointer to the memory to store the config file
* @len: pointer to the length in bytes of the store, on output the size
* @conf: the conf
*
* Writes a configuration file back to a memory area. @len is an IN/OUT
* parameter, it indicates the size available in bytes, and on output the
* size required for the configuration file (even if the call fails due to
* insufficient space).
*
* Returns the number of bytes written or -1 in case of error.
*/
int
virConfWriteMem(char *memory, int *len, virConfPtr conf)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virConfEntryPtr cur;
char *content;
unsigned int use;
if ((memory == NULL) || (len == NULL) || (*len <= 0) || (conf == NULL))
return -1;
cur = conf->entries;
while (cur != NULL) {
virConfSaveEntry(&buf, cur);
cur = cur->next;
}
if (virBufferCheckError(&buf) < 0)
return -1;
use = virBufferUse(&buf);
content = virBufferContentAndReset(&buf);
if ((int)use >= *len) {
*len = (int)use;
VIR_FREE(content);
return -1;
}
memcpy(memory, content, use);
VIR_FREE(content);
*len = use;
return use;
}
/* returns error description if any received from the server */
char *
returnErrorFromSession(xen_session *session)
{
size_t i;
virBuffer buf = VIR_BUFFER_INITIALIZER;
for (i = 0; i < session->error_description_count; i++) {
if (!i)
virBufferEscapeString(&buf, "%s", session->error_description[i]);
else
virBufferEscapeString(&buf, " : %s", session->error_description[i]);
}
if (virBufferUse(&buf) < 1)
virBufferAdd(&buf, _("unknown error"), -1);
return virBufferContentAndReset(&buf);
}
/**
* virConfWriteFile:
* @filename: the path to the configuration file.
* @conf: the conf
*
* Writes a configuration file back to a file.
*
* Returns the number of bytes written or -1 in case of error.
*/
int
virConfWriteFile(const char *filename, virConfPtr conf)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virConfEntryPtr cur;
int ret;
int fd;
char *content;
unsigned int use;
if (conf == NULL)
return -1;
cur = conf->entries;
while (cur != NULL) {
virConfSaveEntry(&buf, cur);
cur = cur->next;
}
if (virBufferError(&buf)) {
virBufferFreeAndReset(&buf);
virReportOOMError();
return -1;
}
fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
if (fd < 0) {
virBufferFreeAndReset(&buf);
virConfError(NULL, VIR_ERR_WRITE_FAILED, _("failed to open file"));
return -1;
}
use = virBufferUse(&buf);
content = virBufferContentAndReset(&buf);
ret = safewrite(fd, content, use);
VIR_FREE(content);
VIR_FORCE_CLOSE(fd);
if (ret != (int)use) {
virConfError(NULL, VIR_ERR_WRITE_FAILED, _("failed to save content"));
return -1;
}
return ret;
}
/**
* virSysinfoFormat:
* @buf: buffer to append output to (may use auto-indentation)
* @def: structure to convert to xml string
*
* Returns 0 on success, -1 on failure after generating an error message.
*/
int
virSysinfoFormat(virBufferPtr buf, virSysinfoDefPtr def)
{
virBuffer childrenBuf = VIR_BUFFER_INITIALIZER;
const char *type = virSysinfoTypeToString(def->type);
int indent = virBufferGetIndent(buf, false);
int ret = -1;
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected sysinfo type model %d"),
def->type);
virBufferFreeAndReset(buf);
goto cleanup;
}
virBufferAdjustIndent(&childrenBuf, indent + 2);
virSysinfoBIOSFormat(&childrenBuf, def->bios);
virSysinfoSystemFormat(&childrenBuf, def->system);
virSysinfoBaseBoardFormat(&childrenBuf, def->baseBoard, def->nbaseBoard);
virSysinfoProcessorFormat(&childrenBuf, def);
virSysinfoMemoryFormat(&childrenBuf, def);
virBufferAsprintf(buf, "<sysinfo type='%s'", type);
if (virBufferUse(&childrenBuf)) {
virBufferAddLit(buf, ">\n");
virBufferAddBuffer(buf, &childrenBuf);
virBufferAddLit(buf, "</sysinfo>\n");
} else {
virBufferAddLit(buf, "/>\n");
}
if (virBufferCheckError(buf) < 0)
goto cleanup;
ret = 0;
cleanup:
virBufferFreeAndReset(&childrenBuf);
return ret;
}
static char *
hypervDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
{
char *xml = NULL;
hypervPrivate *priv = domain->conn->privateData;
virDomainDefPtr def = NULL;
char uuid_string[VIR_UUID_STRING_BUFLEN];
virBuffer query = VIR_BUFFER_INITIALIZER;
Msvm_ComputerSystem *computerSystem = NULL;
Msvm_VirtualSystemSettingData *virtualSystemSettingData = NULL;
Msvm_ProcessorSettingData *processorSettingData = NULL;
Msvm_MemorySettingData *memorySettingData = NULL;
/* Flags checked by virDomainDefFormat */
if (!(def = virDomainDefNew()))
goto cleanup;
virUUIDFormat(domain->uuid, uuid_string);
/* Get Msvm_ComputerSystem */
if (hypervMsvmComputerSystemFromDomain(domain, &computerSystem) < 0)
goto cleanup;
/* Get Msvm_VirtualSystemSettingData */
virBufferAsprintf(&query,
"associators of "
"{Msvm_ComputerSystem.CreationClassName=\"Msvm_ComputerSystem\","
"Name=\"%s\"} "
"where AssocClass = Msvm_SettingsDefineState "
"ResultClass = Msvm_VirtualSystemSettingData",
uuid_string);
if (hypervGetMsvmVirtualSystemSettingDataList(priv, &query,
&virtualSystemSettingData) < 0) {
goto cleanup;
}
if (virtualSystemSettingData == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Could not lookup %s for domain %s"),
"Msvm_VirtualSystemSettingData",
computerSystem->data.common->ElementName);
goto cleanup;
}
/* Get Msvm_ProcessorSettingData */
virBufferAsprintf(&query,
"associators of "
"{Msvm_VirtualSystemSettingData.InstanceID=\"%s\"} "
"where AssocClass = Msvm_VirtualSystemSettingDataComponent "
"ResultClass = Msvm_ProcessorSettingData",
virtualSystemSettingData->data.common->InstanceID);
if (hypervGetMsvmProcessorSettingDataList(priv, &query,
&processorSettingData) < 0) {
goto cleanup;
}
if (processorSettingData == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Could not lookup %s for domain %s"),
"Msvm_ProcessorSettingData",
computerSystem->data.common->ElementName);
goto cleanup;
}
/* Get Msvm_MemorySettingData */
virBufferAsprintf(&query,
"associators of "
"{Msvm_VirtualSystemSettingData.InstanceID=\"%s\"} "
"where AssocClass = Msvm_VirtualSystemSettingDataComponent "
"ResultClass = Msvm_MemorySettingData",
virtualSystemSettingData->data.common->InstanceID);
if (hypervGetMsvmMemorySettingDataList(priv, &query,
&memorySettingData) < 0) {
goto cleanup;
}
if (memorySettingData == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Could not lookup %s for domain %s"),
"Msvm_MemorySettingData",
computerSystem->data.common->ElementName);
goto cleanup;
}
/* Fill struct */
def->virtType = VIR_DOMAIN_VIRT_HYPERV;
if (hypervIsMsvmComputerSystemActive(computerSystem, NULL)) {
def->id = computerSystem->data.common->ProcessID;
} else {
def->id = -1;
}
if (virUUIDParse(computerSystem->data.common->Name, def->uuid) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Could not parse UUID from string '%s'"),
computerSystem->data.common->Name);
return NULL;
}
if (VIR_STRDUP(def->name, computerSystem->data.common->ElementName) < 0)
goto cleanup;
if (priv->wmiVersion == HYPERV_WMI_VERSION_V1) {
if (VIR_STRDUP(def->description,
virtualSystemSettingData->data.v1->Notes) < 0)
goto cleanup;
} else if (priv->wmiVersion == HYPERV_WMI_VERSION_V2 &&
virtualSystemSettingData->data.v2->Notes.data != NULL) {
char **notes = (char **)virtualSystemSettingData->data.v2->Notes.data;
virBuffer buf = VIR_BUFFER_INITIALIZER;
size_t i = 0;
/* in practice Notes has 1 element */
for (i = 0; i < virtualSystemSettingData->data.v2->Notes.count; i++) {
/* but if there's more than 1, separate by double new line */
if (virBufferUse(&buf) > 0)
virBufferAddLit(&buf, "\n\n");
virBufferAdd(&buf, *notes, -1);
notes++;
}
if (virBufferCheckError(&buf))
goto cleanup;
def->description = virBufferContentAndReset(&buf);
}
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.common->VirtualQuantity,
NULL) < 0)
goto cleanup;
if (virDomainDefSetVcpus(def,
processorSettingData->data.common->VirtualQuantity) < 0)
goto cleanup;
def->os.type = VIR_DOMAIN_OSTYPE_HVM;
/* FIXME: devices section is totally missing */
xml = virDomainDefFormat(def, NULL,
virDomainDefFormatConvertXMLFlags(flags));
cleanup:
virDomainDefFree(def);
hypervFreeObject(priv, (hypervObject *)computerSystem);
hypervFreeObject(priv, (hypervObject *)virtualSystemSettingData);
hypervFreeObject(priv, (hypervObject *)processorSettingData);
hypervFreeObject(priv, (hypervObject *)memorySettingData);
return xml;
}
int
virCPUDefFormatBufFull(virBufferPtr buf,
virCPUDefPtr def,
virDomainNumaPtr numa)
{
int ret = -1;
virBuffer attributeBuf = VIR_BUFFER_INITIALIZER;
virBuffer childrenBuf = VIR_BUFFER_INITIALIZER;
if (!def)
return 0;
/* Format attributes for guest CPUs unless they only specify
* topology or cache. */
if (def->type == VIR_CPU_TYPE_GUEST &&
(def->mode != VIR_CPU_MODE_CUSTOM || def->model)) {
const char *tmp;
if (!(tmp = virCPUModeTypeToString(def->mode))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unexpected CPU mode %d"), def->mode);
goto cleanup;
}
virBufferAsprintf(&attributeBuf, " mode='%s'", tmp);
if (def->mode == VIR_CPU_MODE_CUSTOM) {
if (!(tmp = virCPUMatchTypeToString(def->match))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unexpected CPU match policy %d"),
def->match);
goto cleanup;
}
virBufferAsprintf(&attributeBuf, " match='%s'", tmp);
}
if (def->check) {
virBufferAsprintf(&attributeBuf, " check='%s'",
virCPUCheckTypeToString(def->check));
}
}
/* Format children */
virBufferSetChildIndent(&childrenBuf, buf);
if (def->type == VIR_CPU_TYPE_HOST && def->arch)
virBufferAsprintf(&childrenBuf, "<arch>%s</arch>\n",
virArchToString(def->arch));
if (virCPUDefFormatBuf(&childrenBuf, def) < 0)
goto cleanup;
if (virDomainNumaDefCPUFormatXML(&childrenBuf, numa) < 0)
goto cleanup;
if (virBufferCheckError(&attributeBuf) < 0 ||
virBufferCheckError(&childrenBuf) < 0)
goto cleanup;
/* Put it all together */
if (virBufferUse(&attributeBuf) || virBufferUse(&childrenBuf)) {
virBufferAddLit(buf, "<cpu");
if (virBufferUse(&attributeBuf))
virBufferAddBuffer(buf, &attributeBuf);
if (virBufferUse(&childrenBuf)) {
virBufferAddLit(buf, ">\n");
virBufferAddBuffer(buf, &childrenBuf);
virBufferAddLit(buf, "</cpu>\n");
} else {
virBufferAddLit(buf, "/>\n");
}
}
ret = 0;
cleanup:
virBufferFreeAndReset(&attributeBuf);
virBufferFreeAndReset(&childrenBuf);
return ret;
}
