External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-07-08 02:45:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

src: Move _virDomainMemoryDef source nodes into an union

Browse Source 
The _virDomainMemoryDef struct is getting a bit messy. It has
various members and only some of them are valid for given model.
Worse, some are re-used for different models. We tried to make
this more bearable by putting a comment next to each member
describing what models the member is valid for, but that gets
messy too.

Therefore, do what we do elsewhere: introduce an union of structs
and move individual members into their respective groups.

This allows us to shorten some names (e.g. nvdimmPath or
sourceNodes) as their purpose is obvious due to their placement.
But to make this commit as small as possible, that'll be
addressed later.

Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
Reviewed-by: Ján Tomko <jtomko@redhat.com>
This commit is contained in:
Michal Privoznik 2023-07-25 16:48:21 +02:00
parent a03b6cedfd
commit f23a991bea
13 changed files with 276 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
src/conf/domain_conf.c
View File

@ -3490,8 +3490,27 @@ void virDomainMemoryDefFree(virDomainMemoryDef *def)
if (!def) if (!def)
return; return;
g_free(def->nvdimmPath); switch (def->model) {
virBitmapFree(def->sourceNodes); case VIR_DOMAIN_MEMORY_MODEL_DIMM:
virBitmapFree(def->source.dimm.sourceNodes);
break;
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
g_free(def->source.nvdimm.nvdimmPath);
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
g_free(def->source.virtio_pmem.nvdimmPath);
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
virBitmapFree(def->source.virtio_mem.sourceNodes);
break;
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
virBitmapFree(def->source.sgx_epc.sourceNodes);
break;
case VIR_DOMAIN_MEMORY_MODEL_NONE:
case VIR_DOMAIN_MEMORY_MODEL_LAST:
break;
}
g_free(def->uuid); g_free(def->uuid);
virDomainDeviceInfoClear(&def->info); virDomainDeviceInfoClear(&def->info);
g_free(def); g_free(def);
@ -13266,22 +13285,33 @@ virDomainMemorySourceDefParseXML(xmlNodePtr node,
{ {
VIR_XPATH_NODE_AUTORESTORE(ctxt) VIR_XPATH_NODE_AUTORESTORE(ctxt)
g_autofree char *nodemask = NULL; g_autofree char *nodemask = NULL;
unsigned long long *pagesize;
virBitmap **sourceNodes = NULL;
ctxt->node = node; ctxt->node = node;
switch (def->model) { switch (def->model) {
case VIR_DOMAIN_MEMORY_MODEL_DIMM: case VIR_DOMAIN_MEMORY_MODEL_DIMM:
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
if (def->model == VIR_DOMAIN_MEMORY_MODEL_DIMM) {
pagesize = &def->source.dimm.pagesize;
sourceNodes = &def->source.dimm.sourceNodes;
} else {
pagesize = &def->source.virtio_mem.pagesize;
sourceNodes = &def->source.virtio_mem.sourceNodes;
}
if (virDomainParseMemory("./pagesize", "./pagesize/@unit", ctxt, if (virDomainParseMemory("./pagesize", "./pagesize/@unit", ctxt,
&def->pagesize, false, false) < 0) pagesize, false, false) < 0)
return -1; return -1;
if ((nodemask = virXPathString("string(./nodemask)", ctxt))) { if ((nodemask = virXPathString("string(./nodemask)", ctxt))) {
if (virBitmapParse(nodemask, &def->sourceNodes, if (virBitmapParse(nodemask, sourceNodes,
VIR_DOMAIN_CPUMASK_LEN) < 0) VIR_DOMAIN_CPUMASK_LEN) < 0)
return -1; return -1;
if (virBitmapIsAllClear(def->sourceNodes)) { if (virBitmapIsAllClear(*sourceNodes)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Invalid value of 'nodemask': %1$s"), nodemask); _("Invalid value of 'nodemask': %1$s"), nodemask);
return -1; return -1;
@ -13290,28 +13320,28 @@ virDomainMemorySourceDefParseXML(xmlNodePtr node,
break; break;
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
def->nvdimmPath = virXPathString("string(./path)", ctxt); def->source.nvdimm.nvdimmPath = virXPathString("string(./path)", ctxt);
if (virDomainParseMemory("./alignsize", "./alignsize/@unit", ctxt, if (virDomainParseMemory("./alignsize", "./alignsize/@unit", ctxt,
&def->alignsize, false, false) < 0) &def->source.nvdimm.alignsize, false, false) < 0)
return -1; return -1;
if (virXPathBoolean("boolean(./pmem)", ctxt)) if (virXPathBoolean("boolean(./pmem)", ctxt))
def->nvdimmPmem = true; def->source.nvdimm.nvdimmPmem = true;
break; break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
def->nvdimmPath = virXPathString("string(./path)", ctxt); def->source.virtio_pmem.nvdimmPath = virXPathString("string(./path)", ctxt);
break; break;
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC: case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
if ((nodemask = virXPathString("string(./nodemask)", ctxt))) { if ((nodemask = virXPathString("string(./nodemask)", ctxt))) {
if (virBitmapParse(nodemask, &def->sourceNodes, if (virBitmapParse(nodemask, &def->source.sgx_epc.sourceNodes,
VIR_DOMAIN_CPUMASK_LEN) < 0) VIR_DOMAIN_CPUMASK_LEN) < 0)
return -1; return -1;
if (virBitmapIsAllClear(def->sourceNodes)) { if (virBitmapIsAllClear(def->source.sgx_epc.sourceNodes)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Invalid value of 'nodemask': %1$s"), nodemask); _("Invalid value of 'nodemask': %1$s"), nodemask);
return -1; return -1;
@ -15259,27 +15289,36 @@ virDomainMemoryFindByDefInternal(virDomainDef *def,
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_DIMM: case VIR_DOMAIN_MEMORY_MODEL_DIMM:
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM: if (tmp->source.dimm.pagesize != mem->source.dimm.pagesize)
/* source stuff -> match with device */
if (tmp->pagesize != mem->pagesize)
continue; continue;
if (!virBitmapEqual(tmp->sourceNodes, mem->sourceNodes)) if (!virBitmapEqual(tmp->source.dimm.sourceNodes,
mem->source.dimm.sourceNodes))
continue;
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
if (tmp->source.virtio_mem.pagesize != mem->source.virtio_mem.pagesize)
continue;
if (!virBitmapEqual(tmp->source.virtio_mem.sourceNodes,
mem->source.virtio_mem.sourceNodes))
continue; continue;
break; break;
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
if (STRNEQ(tmp->nvdimmPath, mem->nvdimmPath)) if (STRNEQ(tmp->source.nvdimm.nvdimmPath, mem->source.nvdimm.nvdimmPath))
continue; continue;
break; break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
if (STRNEQ(tmp->nvdimmPath, mem->nvdimmPath)) if (STRNEQ(tmp->source.virtio_pmem.nvdimmPath,
mem->source.virtio_pmem.nvdimmPath))
continue; continue;
break; break;
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC: case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
if (!virBitmapEqual(tmp->sourceNodes, mem->sourceNodes)) if (!virBitmapEqual(tmp->source.sgx_epc.sourceNodes,
mem->source.sgx_epc.sourceNodes))
continue; continue;
break; break;
@ -21007,7 +21046,8 @@ virDomainMemoryDefCheckABIStability(virDomainMemoryDef *src,
return false; return false;
} }
if (src->model == VIR_DOMAIN_MEMORY_MODEL_NVDIMM) { switch (src->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
if (src->labelsize != dst->labelsize) { if (src->labelsize != dst->labelsize) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Target NVDIMM label size '%1$llu' doesn't match source NVDIMM label size '%2$llu'"), _("Target NVDIMM label size '%1$llu' doesn't match source NVDIMM label size '%2$llu'"),
@ -21015,14 +21055,15 @@ virDomainMemoryDefCheckABIStability(virDomainMemoryDef *src,
return false; return false;
} }
if (src->alignsize != dst->alignsize) { if (src->source.nvdimm.alignsize != dst->source.nvdimm.alignsize) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Target NVDIMM alignment '%1$llu' doesn't match source NVDIMM alignment '%2$llu'"), _("Target NVDIMM alignment '%1$llu' doesn't match source NVDIMM alignment '%2$llu'"),
src->alignsize, dst->alignsize); src->source.nvdimm.alignsize,
dst->source.nvdimm.alignsize);
return false; return false;
} }
if (src->nvdimmPmem != dst->nvdimmPmem) { if (src->source.nvdimm.nvdimmPmem != dst->source.nvdimm.nvdimmPmem) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Target NVDIMM pmem flag doesn't match " _("Target NVDIMM pmem flag doesn't match "
"source NVDIMM pmem flag")); "source NVDIMM pmem flag"));
@ -21043,6 +21084,15 @@ virDomainMemoryDefCheckABIStability(virDomainMemoryDef *src,
_("Target NVDIMM UUID doesn't match source NVDIMM")); _("Target NVDIMM UUID doesn't match source NVDIMM"));
return false; return false;
} }
break;
case VIR_DOMAIN_MEMORY_MODEL_DIMM:
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
case VIR_DOMAIN_MEMORY_MODEL_NONE:
case VIR_DOMAIN_MEMORY_MODEL_LAST:
break;
} }
return virDomainDeviceInfoCheckABIStability(&src->info, &dst->info); return virDomainDeviceInfoCheckABIStability(&src->info, &dst->info);
@ -25100,37 +25150,48 @@ virDomainMemorySourceDefFormat(virBuffer *buf,
switch (def->model) { switch (def->model) {
case VIR_DOMAIN_MEMORY_MODEL_DIMM: case VIR_DOMAIN_MEMORY_MODEL_DIMM:
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM: if (def->source.dimm.sourceNodes) {
if (def->sourceNodes) { if (!(bitmap = virBitmapFormat(def->source.dimm.sourceNodes)))
if (!(bitmap = virBitmapFormat(def->sourceNodes)))
return -1; return -1;
virBufferAsprintf(&childBuf, "<nodemask>%s</nodemask>\n", bitmap); virBufferAsprintf(&childBuf, "<nodemask>%s</nodemask>\n", bitmap);
} }
if (def->pagesize) if (def->source.dimm.pagesize)
virBufferAsprintf(&childBuf, "<pagesize unit='KiB'>%llu</pagesize>\n", virBufferAsprintf(&childBuf, "<pagesize unit='KiB'>%llu</pagesize>\n",
def->pagesize); def->source.dimm.pagesize);
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
if (def->source.virtio_mem.sourceNodes) {
if (!(bitmap = virBitmapFormat(def->source.virtio_mem.sourceNodes)))
return -1;
virBufferAsprintf(&childBuf, "<nodemask>%s</nodemask>\n", bitmap);
}
if (def->source.virtio_mem.pagesize)
virBufferAsprintf(&childBuf, "<pagesize unit='KiB'>%llu</pagesize>\n",
def->source.virtio_mem.pagesize);
break; break;
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
virBufferEscapeString(&childBuf, "<path>%s</path>\n", def->nvdimmPath); virBufferEscapeString(&childBuf, "<path>%s</path>\n", def->source.nvdimm.nvdimmPath);
if (def->alignsize) if (def->source.nvdimm.alignsize)
virBufferAsprintf(&childBuf, "<alignsize unit='KiB'>%llu</alignsize>\n", virBufferAsprintf(&childBuf, "<alignsize unit='KiB'>%llu</alignsize>\n",
def->alignsize); def->source.nvdimm.alignsize);
if (def->nvdimmPmem) if (def->source.nvdimm.nvdimmPmem)
virBufferAddLit(&childBuf, "<pmem/>\n"); virBufferAddLit(&childBuf, "<pmem/>\n");
break; break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
virBufferEscapeString(&childBuf, "<path>%s</path>\n", def->nvdimmPath); virBufferEscapeString(&childBuf, "<path>%s</path>\n", def->source.virtio_pmem.nvdimmPath);
break; break;
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC: case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
if (def->sourceNodes) { if (def->source.sgx_epc.sourceNodes) {
if (!(bitmap = virBitmapFormat(def->sourceNodes))) if (!(bitmap = virBitmapFormat(def->source.sgx_epc.sourceNodes)))
return -1; return -1;
virBufferAsprintf(&childBuf, "<nodemask>%s</nodemask>\n", bitmap); virBufferAsprintf(&childBuf, "<nodemask>%s</nodemask>\n", bitmap);

29
src/conf/domain_conf.h
View File

@ -2634,18 +2634,33 @@ typedef enum {
} virDomainMemoryModel; } virDomainMemoryModel;
struct _virDomainMemoryDef { struct _virDomainMemoryDef {
virDomainMemoryModel model;
virDomainMemoryAccess access; virDomainMemoryAccess access;
virTristateBool discard; virTristateBool discard;
/* source */ union {
virBitmap *sourceNodes; struct {
unsigned long long pagesize; /* kibibytes */ unsigned long long pagesize; /* kibibytes */
char *nvdimmPath; /* valid for NVDIMM an VIRTIO_PMEM */ virBitmap *sourceNodes;
unsigned long long alignsize; /* kibibytes; valid only for NVDIMM */ } dimm;
bool nvdimmPmem; /* valid only for NVDIMM */ struct {
char *nvdimmPath;
bool nvdimmPmem;
unsigned long long alignsize; /* kibibytes */
} nvdimm;
struct {
char *nvdimmPath;
} virtio_pmem;
struct {
unsigned long long pagesize; /* kibibytes */
virBitmap *sourceNodes;
} virtio_mem;
struct {
virBitmap *sourceNodes;
} sgx_epc;
} source;
/* target */ /* target */
virDomainMemoryModel model;
int targetNode; int targetNode;
unsigned long long size; /* kibibytes */ unsigned long long size; /* kibibytes */
unsigned long long labelsize; /* kibibytes; valid only for NVDIMM */ unsigned long long labelsize; /* kibibytes; valid only for NVDIMM */

4
src/conf/domain_validate.c
View File

@ -2260,7 +2260,7 @@ virDomainMemoryDefValidate(const virDomainMemoryDef *mem,
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
if (!mem->nvdimmPath) { if (!mem->source.nvdimm.nvdimmPath) {
virReportError(VIR_ERR_XML_DETAIL, "%s", virReportError(VIR_ERR_XML_DETAIL, "%s",
_("path is required for model 'nvdimm'")); _("path is required for model 'nvdimm'"));
return -1; return -1;
@ -2286,7 +2286,7 @@ virDomainMemoryDefValidate(const virDomainMemoryDef *mem,
break; break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
if (!mem->nvdimmPath) { if (!mem->source.virtio_pmem.nvdimmPath) {
virReportError(VIR_ERR_XML_DETAIL, virReportError(VIR_ERR_XML_DETAIL,
_("path is required for model '%1$s'"), _("path is required for model '%1$s'"),
virDomainMemoryModelTypeToString(mem->model)); virDomainMemoryModelTypeToString(mem->model));

12
src/qemu/qemu_cgroup.c
View File

@ -553,8 +553,12 @@ qemuSetupMemoryDevicesCgroup(virDomainObj *vm,
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
if (qemuCgroupAllowDevicePath(vm, mem->source.nvdimm.nvdimmPath,
VIR_CGROUP_DEVICE_RW, false) < 0)
return -1;
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
if (qemuCgroupAllowDevicePath(vm, mem->nvdimmPath, if (qemuCgroupAllowDevicePath(vm, mem->source.virtio_pmem.nvdimmPath,
VIR_CGROUP_DEVICE_RW, false) < 0) VIR_CGROUP_DEVICE_RW, false) < 0)
return -1; return -1;
break; break;
@ -587,8 +591,12 @@ qemuTeardownMemoryDevicesCgroup(virDomainObj *vm,
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
if (qemuCgroupDenyDevicePath(vm, mem->source.nvdimm.nvdimmPath,
VIR_CGROUP_DEVICE_RWM, false) < 0)
return -1;
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
if (qemuCgroupDenyDevicePath(vm, mem->nvdimmPath, if (qemuCgroupDenyDevicePath(vm, mem->source.virtio_pmem.nvdimmPath,
VIR_CGROUP_DEVICE_RWM, false) < 0) VIR_CGROUP_DEVICE_RWM, false) < 0)
return -1; return -1;
break; break;

97
src/qemu/qemu_command.c
View File

@ -3146,11 +3146,34 @@ qemuBuildMemoryGetPagesize(virQEMUDriverConfig *cfg,
bool *preallocRet) bool *preallocRet)
{ {
const long system_page_size = virGetSystemPageSizeKB(); const long system_page_size = virGetSystemPageSizeKB();
unsigned long long pagesize = mem->pagesize; unsigned long long pagesize = 0;
bool needHugepage = !!pagesize; const char *nvdimmPath = NULL;
bool useHugepage = !!pagesize; bool needHugepage = false;
bool useHugepage = false;
bool prealloc = false; bool prealloc = false;
switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_DIMM:
pagesize = mem->source.dimm.pagesize;
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
pagesize = mem->source.virtio_mem.pagesize;
break;
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
nvdimmPath = mem->source.nvdimm.nvdimmPath;
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
nvdimmPath = mem->source.virtio_pmem.nvdimmPath;
break;
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
case VIR_DOMAIN_MEMORY_MODEL_NONE:
case VIR_DOMAIN_MEMORY_MODEL_LAST:
break;
}
needHugepage = !!pagesize;
useHugepage = !!pagesize;
if (pagesize == 0) { if (pagesize == 0) {
virDomainHugePage *master_hugepage = NULL; virDomainHugePage *master_hugepage = NULL;
virDomainHugePage *hugepage = NULL; virDomainHugePage *hugepage = NULL;
@ -3216,10 +3239,11 @@ qemuBuildMemoryGetPagesize(virQEMUDriverConfig *cfg,
/* If the NVDIMM is a real device then there's nothing to prealloc. /* If the NVDIMM is a real device then there's nothing to prealloc.
* If anything, we would be only wearing off the device. * If anything, we would be only wearing off the device.
* Similarly, virtio-pmem-pci doesn't need prealloc either. */ * Similarly, virtio-pmem-pci doesn't need prealloc either. */
if (mem->nvdimmPath) { if (nvdimmPath) {
if (!mem->nvdimmPmem && if (mem->model == VIR_DOMAIN_MEMORY_MODEL_NVDIMM &&
mem->model != VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM) !mem->source.nvdimm.nvdimmPmem) {
prealloc = true; prealloc = true;
}
} else if (useHugepage) { } else if (useHugepage) {
prealloc = true; prealloc = true;
} }
@ -3286,6 +3310,8 @@ qemuBuildMemoryBackendProps(virJSONValue **backendProps,
unsigned long long pagesize = 0; unsigned long long pagesize = 0;
bool needHugepage = false; bool needHugepage = false;
bool useHugepage = false; bool useHugepage = false;
bool hasSourceNodes = false;
const char *nvdimmPath = NULL;
int discard = mem->discard; int discard = mem->discard;
bool disableCanonicalPath = false; bool disableCanonicalPath = false;
@ -3324,12 +3350,36 @@ qemuBuildMemoryBackendProps(virJSONValue **backendProps,
props = virJSONValueNewObject(); props = virJSONValueNewObject();
switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_DIMM:
nodemask = mem->source.dimm.sourceNodes;
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
nodemask = mem->source.virtio_mem.sourceNodes;
break;
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
nodemask = mem->source.sgx_epc.sourceNodes;
break;
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
nvdimmPath = mem->source.nvdimm.nvdimmPath;
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
nvdimmPath = mem->source.virtio_pmem.nvdimmPath;
break;
case VIR_DOMAIN_MEMORY_MODEL_NONE:
case VIR_DOMAIN_MEMORY_MODEL_LAST:
break;
}
hasSourceNodes = !!nodemask;
if (mem->model == VIR_DOMAIN_MEMORY_MODEL_SGX_EPC) { if (mem->model == VIR_DOMAIN_MEMORY_MODEL_SGX_EPC) {
backendType = "memory-backend-epc"; backendType = "memory-backend-epc";
if (!priv->memPrealloc) if (!priv->memPrealloc)
prealloc = true; prealloc = true;
} else if (!mem->nvdimmPath &&
def->mem.source == VIR_DOMAIN_MEMORY_SOURCE_MEMFD) { } else if (!nvdimmPath &&
def->mem.source == VIR_DOMAIN_MEMORY_SOURCE_MEMFD) {
backendType = "memory-backend-memfd"; backendType = "memory-backend-memfd";
if (useHugepage && if (useHugepage &&
@ -3343,11 +3393,11 @@ qemuBuildMemoryBackendProps(virJSONValue **backendProps,
if (systemMemory) if (systemMemory)
disableCanonicalPath = true; disableCanonicalPath = true;
} else if (useHugepage || mem->nvdimmPath || memAccess || } else if (useHugepage || nvdimmPath || memAccess ||
def->mem.source == VIR_DOMAIN_MEMORY_SOURCE_FILE) { def->mem.source == VIR_DOMAIN_MEMORY_SOURCE_FILE) {
if (mem->nvdimmPath) { if (nvdimmPath) {
memPath = g_strdup(mem->nvdimmPath); memPath = g_strdup(nvdimmPath);
} else if (useHugepage) { } else if (useHugepage) {
if (qemuGetDomainHupageMemPath(priv->driver, def, pagesize, &memPath) < 0) if (qemuGetDomainHupageMemPath(priv->driver, def, pagesize, &memPath) < 0)
return -1; return -1;
@ -3363,7 +3413,7 @@ qemuBuildMemoryBackendProps(virJSONValue **backendProps,
NULL) < 0) NULL) < 0)
return -1; return -1;
if (!mem->nvdimmPath && if (!nvdimmPath &&
virJSONValueObjectAdd(&props, virJSONValueObjectAdd(&props,
"T:discard-data", discard, "T:discard-data", discard,
NULL) < 0) { NULL) < 0) {
@ -3423,10 +3473,13 @@ qemuBuildMemoryBackendProps(virJSONValue **backendProps,
if (virJSONValueObjectAdd(&props, "U:size", mem->size * 1024, NULL) < 0) if (virJSONValueObjectAdd(&props, "U:size", mem->size * 1024, NULL) < 0)
return -1; return -1;
if (virJSONValueObjectAdd(&props, "P:align", mem->alignsize * 1024, NULL) < 0) if (mem->model == VIR_DOMAIN_MEMORY_MODEL_NVDIMM &&
virJSONValueObjectAdd(&props, "P:align",
mem->source.nvdimm.alignsize * 1024, NULL) < 0)
return -1; return -1;
if (mem->nvdimmPmem) { if (mem->model == VIR_DOMAIN_MEMORY_MODEL_NVDIMM &&
mem->source.nvdimm.nvdimmPmem) {
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_MEMORY_FILE_PMEM)) { if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_MEMORY_FILE_PMEM)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("nvdimm pmem property is not available " _("nvdimm pmem property is not available "
@ -3437,12 +3490,10 @@ qemuBuildMemoryBackendProps(virJSONValue **backendProps,
return -1; return -1;
} }
if (mem->sourceNodes) { if (!hasSourceNodes &&
nodemask = mem->sourceNodes; virDomainNumatuneMaybeGetNodeset(def->numa, priv->autoNodeset,
} else { &nodemask, mem->targetNode) < 0) {
if (virDomainNumatuneMaybeGetNodeset(def->numa, priv->autoNodeset, return -1;
&nodemask, mem->targetNode) < 0)
return -1;
} }
if (nodemask) { if (nodemask) {
@ -3466,8 +3517,8 @@ qemuBuildMemoryBackendProps(virJSONValue **backendProps,
} }
/* If none of the following is requested... */ /* If none of the following is requested... */
if (!needHugepage && !mem->sourceNodes && !nodeSpecified && if (!needHugepage && !hasSourceNodes && !nodeSpecified &&
!mem->nvdimmPath && !nvdimmPath &&
memAccess == VIR_DOMAIN_MEMORY_ACCESS_DEFAULT && memAccess == VIR_DOMAIN_MEMORY_ACCESS_DEFAULT &&
def->mem.source != VIR_DOMAIN_MEMORY_SOURCE_FILE && def->mem.source != VIR_DOMAIN_MEMORY_SOURCE_FILE &&
def->mem.source != VIR_DOMAIN_MEMORY_SOURCE_MEMFD && def->mem.source != VIR_DOMAIN_MEMORY_SOURCE_MEMFD &&

10
src/qemu/qemu_hotplug.c
View File

@ -7010,18 +7010,18 @@ qemuDomainChangeMemoryLiveValidateChange(const virDomainMemoryDef *oldDef,
return false; return false;
} }
if (!virBitmapEqual(oldDef->sourceNodes, if (!virBitmapEqual(oldDef->source.virtio_mem.sourceNodes,
newDef->sourceNodes)) { newDef->source.virtio_mem.sourceNodes)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("cannot modify memory source nodes")); _("cannot modify memory source nodes"));
return false; return false;
} }
if (oldDef->pagesize != newDef->pagesize) { if (oldDef->source.virtio_mem.pagesize != newDef->source.virtio_mem.pagesize) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("cannot modify memory pagesize from '%1$llu' to '%2$llu'"), _("cannot modify memory pagesize from '%1$llu' to '%2$llu'"),
oldDef->pagesize, oldDef->source.virtio_mem.pagesize,
newDef->pagesize); newDef->source.virtio_mem.pagesize);
return false; return false;
} }

4
src/qemu/qemu_namespace.c
View File

@ -372,8 +372,10 @@ qemuDomainSetupMemory(virDomainMemoryDef *mem,
{ {
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
*paths = g_slist_prepend(*paths, g_strdup(mem->source.nvdimm.nvdimmPath));
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
*paths = g_slist_prepend(*paths, g_strdup(mem->nvdimmPath)); *paths = g_slist_prepend(*paths, g_strdup(mem->source.virtio_pmem.nvdimmPath));
break; break;
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC: case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:

10
src/qemu/qemu_process.c
View File

@ -3927,11 +3927,15 @@ static bool
qemuProcessDomainMemoryDefNeedHugepagesPath(const virDomainMemoryDef *mem, qemuProcessDomainMemoryDefNeedHugepagesPath(const virDomainMemoryDef *mem,
const long system_pagesize) const long system_pagesize)
{ {
unsigned long long pagesize = 0;
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_DIMM: case VIR_DOMAIN_MEMORY_MODEL_DIMM:
pagesize = mem->source.dimm.pagesize;
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
return mem->pagesize && mem->pagesize != system_pagesize; pagesize = mem->source.virtio_mem.pagesize;
break;
case VIR_DOMAIN_MEMORY_MODEL_NONE: case VIR_DOMAIN_MEMORY_MODEL_NONE:
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
@ -3941,7 +3945,7 @@ qemuProcessDomainMemoryDefNeedHugepagesPath(const virDomainMemoryDef *mem,
return false; return false;
} }
return false; return pagesize != 0 && pagesize != system_pagesize;
} }

4
src/qemu/qemu_validate.c
View File

@ -5066,8 +5066,8 @@ qemuValidateDomainDeviceDefMemory(virDomainMemoryDef *mem,
return -1; return -1;
} }
if (mem->sourceNodes) { if (mem->source.sgx_epc.sourceNodes) {
while ((node = virBitmapNextSetBit(mem->sourceNodes, node)) >= 0) { while ((node = virBitmapNextSetBit(mem->source.sgx_epc.sourceNodes, node)) >= 0) {
if (mem->size > sgxCaps->sgxSections[node].size) { if (mem->size > sgxCaps->sgxSections[node].size) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("sgx epc size %1$lld on host node %2$zd is less than requested size %3$lld"), _("sgx epc size %1$lld on host node %2$zd is less than requested size %3$lld"),

24
src/security/security_apparmor.c
View File

@ -638,16 +638,15 @@ AppArmorSetMemoryLabel(virSecurityManager *mgr,
virDomainDef *def, virDomainDef *def,
virDomainMemoryDef *mem) virDomainMemoryDef *mem)
{ {
const char *path = NULL;
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
path = mem->source.nvdimm.nvdimmPath;
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
if (!virFileExists(mem->nvdimmPath)) { path = mem->source.virtio_pmem.nvdimmPath;
virReportError(VIR_ERR_INTERNAL_ERROR, break;
_("%1$s: \'%2$s\' does not exist"),
__func__, mem->nvdimmPath);
return -1;
}
return reload_profile(mgr, def, mem->nvdimmPath, true);
case VIR_DOMAIN_MEMORY_MODEL_NONE: case VIR_DOMAIN_MEMORY_MODEL_NONE:
case VIR_DOMAIN_MEMORY_MODEL_DIMM: case VIR_DOMAIN_MEMORY_MODEL_DIMM:
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
@ -656,7 +655,16 @@ AppArmorSetMemoryLabel(virSecurityManager *mgr,
break; break;
} }
return 0; if (!path)
return 0;
if (!virFileExists(path)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%1$s: \'%2$s\' does not exist"),
__func__, path);
return -1;
}
return reload_profile(mgr, def, path, true);
} }

9
src/security/security_dac.c
View File

@ -1857,8 +1857,9 @@ virSecurityDACRestoreMemoryLabel(virSecurityManager *mgr,
{ {
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
return virSecurityDACRestoreFileLabel(mgr, mem->source.nvdimm.nvdimmPath);
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
return virSecurityDACRestoreFileLabel(mgr, mem->nvdimmPath); return virSecurityDACRestoreFileLabel(mgr, mem->source.virtio_pmem.nvdimmPath);
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC: case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
/* We set label on SGX /dev nodes iff running with namespaces, so we /* We set label on SGX /dev nodes iff running with namespaces, so we
@ -2044,9 +2045,13 @@ virSecurityDACSetMemoryLabel(virSecurityManager *mgr,
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
return virSecurityDACSetOwnership(mgr, NULL,
mem->source.nvdimm.nvdimmPath,
user, group, true);
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
return virSecurityDACSetOwnership(mgr, NULL, return virSecurityDACSetOwnership(mgr, NULL,
mem->nvdimmPath, mem->source.virtio_pmem.nvdimmPath,
user, group, true); user, group, true);
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC: case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:

56
src/security/security_selinux.c
View File

@ -1610,24 +1610,20 @@ virSecuritySELinuxSetMemoryLabel(virSecurityManager *mgr,
virDomainMemoryDef *mem) virDomainMemoryDef *mem)
{ {
virSecurityLabelDef *seclabel; virSecurityLabelDef *seclabel;
const char *path = NULL;
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!seclabel || !seclabel->relabel)
return 0;
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: path = mem->source.nvdimm.nvdimmPath;
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME); break;
if (!seclabel || !seclabel->relabel) case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
return 0; path = mem->source.virtio_pmem.nvdimmPath;
if (virSecuritySELinuxSetFilecon(mgr, mem->nvdimmPath,
seclabel->imagelabel, true) < 0)
return -1;
break; break;
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC: case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!seclabel || !seclabel->relabel)
return 0;
if (virSecuritySELinuxSetFilecon(mgr, DEV_SGX_VEPC, if (virSecuritySELinuxSetFilecon(mgr, DEV_SGX_VEPC,
seclabel->imagelabel, true) < 0 || seclabel->imagelabel, true) < 0 ||
virSecuritySELinuxSetFilecon(mgr, DEV_SGX_PROVISION, virSecuritySELinuxSetFilecon(mgr, DEV_SGX_PROVISION,
@ -1642,6 +1638,12 @@ virSecuritySELinuxSetMemoryLabel(virSecurityManager *mgr,
break; break;
} }
if (!path)
return 0;
if (virSecuritySELinuxSetFilecon(mgr, path,
seclabel->imagelabel, true) < 0)
return -1;
return 0; return 0;
} }
@ -1653,36 +1655,36 @@ virSecuritySELinuxRestoreMemoryLabel(virSecurityManager *mgr,
{ {
int ret = -1; int ret = -1;
virSecurityLabelDef *seclabel; virSecurityLabelDef *seclabel;
const char *path = NULL;
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!seclabel || !seclabel->relabel)
return 0;
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: path = mem->source.nvdimm.nvdimmPath;
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME); break;
if (!seclabel || !seclabel->relabel) case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
return 0; path = mem->source.virtio_pmem.nvdimmPath;
ret = virSecuritySELinuxRestoreFileLabel(mgr, mem->nvdimmPath, true);
break; break;
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC: case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
seclabel = virDomainDefGetSecurityLabelDef(def, SECURITY_SELINUX_NAME);
if (!seclabel || !seclabel->relabel)
return 0;
ret = virSecuritySELinuxRestoreFileLabel(mgr, DEV_SGX_VEPC, true); ret = virSecuritySELinuxRestoreFileLabel(mgr, DEV_SGX_VEPC, true);
if (virSecuritySELinuxRestoreFileLabel(mgr, DEV_SGX_PROVISION, true) < 0) if (virSecuritySELinuxRestoreFileLabel(mgr, DEV_SGX_PROVISION, true) < 0)
ret = -1; ret = -1;
break; return ret;
case VIR_DOMAIN_MEMORY_MODEL_DIMM: case VIR_DOMAIN_MEMORY_MODEL_DIMM:
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
case VIR_DOMAIN_MEMORY_MODEL_NONE: case VIR_DOMAIN_MEMORY_MODEL_NONE:
case VIR_DOMAIN_MEMORY_MODEL_LAST: case VIR_DOMAIN_MEMORY_MODEL_LAST:
ret = 0;
break; break;
} }
return ret; if (!path)
return 0;
return virSecuritySELinuxRestoreFileLabel(mgr, path, true);
} }

5
src/security/virt-aa-helper.c
View File

@ -1151,8 +1151,11 @@ get_files(vahControl * ctl)
switch (mem->model) { switch (mem->model) {
case VIR_DOMAIN_MEMORY_MODEL_NVDIMM: case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
if (vah_add_file(&buf, mem->source.nvdimm.nvdimmPath, "rw") != 0)
goto cleanup;
break;
case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM: case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
if (vah_add_file(&buf, mem->nvdimmPath, "rw") != 0) if (vah_add_file(&buf, mem->source.virtio_pmem.nvdimmPath, "rw") != 0)
goto cleanup; goto cleanup;
break; break;
case VIR_DOMAIN_MEMORY_MODEL_DIMM: case VIR_DOMAIN_MEMORY_MODEL_DIMM: