This tells the hypervisor that the guest should have its memory
- allocated using hugepages instead of the normal native page size.
+ allocated using hugepages instead of the normal native page size.
+ Since 1.2.5 it's possible to set hugepages
+ more specifically per numa node. The page element is
+ introduced. It has one compulsory attribute size which
+ specifies which hugepages should be used (especially useful on systems
+ supporting hugepages of different sizes). The default unit for the
+ size attribute is kilobytes (multiplier of 1024). If you
+ want to use different unit, use optional unit attribute.
+ For systems with NUMA, the optional nodeset attribute may
+ come handy as it ties given guest's NUMA nodes to certain hugepage
+ sizes. From the example snippet, one gigabyte hugepages are used for
+ every NUMA node except node number four. For the correct syntax see
+ this.
nosharepages
Instructs hypervisor to disable shared pages (memory merge, KSM) for
this domain. Since 1.0.6
diff --git a/docs/schemas/domaincommon.rng b/docs/schemas/domaincommon.rng
index 7ace1c228d77431d81441dc1fd7d6df8fb03214b..aa0dcd5814819d34e69a3aee62db0450cdce4dbb 100644
--- a/docs/schemas/domaincommon.rng
+++ b/docs/schemas/domaincommon.rng
@@ -568,7 +568,24 @@
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index 910f6e22d531e806147efcc71c853b8f35e4e0d4..65b1857f90f8340601b6bc749cc50826b71196c4 100644
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -11330,6 +11330,57 @@ virDomainParseMemory(const char *xpath, xmlXPathContextPtr ctxt,
}
+static int
+virDomainHugepagesParseXML(xmlNodePtr node,
+ xmlXPathContextPtr ctxt,
+ virDomainHugePagePtr hugepage)
+{
+ int ret = -1;
+ xmlNodePtr oldnode = ctxt->node;
+ unsigned long long bytes, max;
+ char *unit = NULL, *nodeset = NULL;
+
+ ctxt->node = node;
+
+ /* On 32-bit machines, our bound is 0xffffffff * KiB. On 64-bit
+ * machines, our bound is off_t (2^63). */
+ if (sizeof(unsigned long) < sizeof(long long))
+ max = 1024ull * ULONG_MAX;
+ else
+ max = LLONG_MAX;
+
+ if (virXPathULongLong("string(./@size)", ctxt, &bytes) < 0) {
+ virReportError(VIR_ERR_XML_DETAIL, "%s",
+ _("unable to parse size attribute"));
+ goto cleanup;
+ }
+
+ unit = virXPathString("string(./@unit)", ctxt);
+
+ if (virScaleInteger(&bytes, unit, 1024, max) < 0)
+ goto cleanup;
+
+ if (!(hugepage->size = VIR_DIV_UP(bytes, 1024))) {
+ virReportError(VIR_ERR_XML_DETAIL, "%s",
+ _("hugepage size can't be zero"));
+ goto cleanup;
+ }
+
+ if ((nodeset = virXMLPropString(node, "nodeset"))) {
+ if (virBitmapParse(nodeset, 0, &hugepage->nodemask,
+ VIR_DOMAIN_CPUMASK_LEN) < 0)
+ goto cleanup;
+ }
+
+ ret = 0;
+ cleanup:
+ VIR_FREE(unit);
+ VIR_FREE(nodeset);
+ ctxt->node = oldnode;
+ return ret;
+}
+
+
static virDomainResourceDefPtr
virDomainResourceDefParse(xmlNodePtr node,
xmlXPathContextPtr ctxt)
@@ -11397,7 +11448,7 @@ virDomainDefParseXML(xmlDocPtr xml,
{
xmlNodePtr *nodes = NULL, node = NULL;
char *tmp = NULL;
- size_t i;
+ size_t i, j;
int n;
long id = -1;
virDomainDefPtr def;
@@ -11547,8 +11598,55 @@ virDomainDefParseXML(xmlDocPtr xml,
def->mem.cur_balloon = def->mem.max_balloon;
}
- if ((node = virXPathNode("./memoryBacking/hugepages", ctxt)))
- def->mem.hugepage_backed = true;
+
+ if ((n = virXPathNodeSet("./memoryBacking/hugepages/page", ctxt, &nodes)) < 0) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("cannot extract hugepages nodes"));
+ goto error;
+ }
+
+ if (n) {
+ if (VIR_ALLOC_N(def->mem.hugepages, n) < 0)
+ goto error;
+
+ for (i = 0; i < n; i++) {
+ if (virDomainHugepagesParseXML(nodes[i], ctxt,
+ &def->mem.hugepages[i]) < 0)
+ goto error;
+ def->mem.nhugepages++;
+
+ for (j = 0; j < i; j++) {
+ if (def->mem.hugepages[i].nodemask &&
+ def->mem.hugepages[j].nodemask &&
+ virBitmapOverlaps(def->mem.hugepages[i].nodemask,
+ def->mem.hugepages[j].nodemask)) {
+ virReportError(VIR_ERR_XML_DETAIL,
+ _("nodeset attribute of hugepages "
+ "of sizes %llu and %llu intersect"),
+ def->mem.hugepages[i].size,
+ def->mem.hugepages[j].size);
+ goto error;
+ } else if (!def->mem.hugepages[i].nodemask &&
+ !def->mem.hugepages[j].nodemask) {
+ virReportError(VIR_ERR_XML_DETAIL,
+ _("two master hugepages detected: "
+ "%llu and %llu"),
+ def->mem.hugepages[i].size,
+ def->mem.hugepages[j].size);
+ goto error;
+ }
+ }
+ }
+
+ VIR_FREE(nodes);
+ } else {
+ if ((node = virXPathNode("./memoryBacking/hugepages", ctxt))) {
+ if (VIR_ALLOC(def->mem.hugepages) < 0)
+ goto error;
+
+ def->mem.nhugepages = 1;
+ }
+ }
if ((node = virXPathNode("./memoryBacking/nosharepages", ctxt)))
def->mem.nosharepages = true;
@@ -11570,7 +11668,6 @@ virDomainDefParseXML(xmlDocPtr xml,
goto error;
for (i = 0; i < n; i++) {
- size_t j;
if (virDomainBlkioDeviceParseXML(nodes[i],
&def->blkio.devices[i]) < 0)
goto error;
@@ -12509,7 +12606,6 @@ virDomainDefParseXML(xmlDocPtr xml,
if (chr->target.port == -1) {
int maxport = -1;
- size_t j;
for (j = 0; j < i; j++) {
if (def->parallels[j]->target.port > maxport)
maxport = def->parallels[j]->target.port;
@@ -12537,7 +12633,6 @@ virDomainDefParseXML(xmlDocPtr xml,
if (chr->target.port == -1) {
int maxport = -1;
- size_t j;
for (j = 0; j < i; j++) {
if (def->serials[j]->target.port > maxport)
maxport = def->serials[j]->target.port;
@@ -12595,7 +12690,6 @@ virDomainDefParseXML(xmlDocPtr xml,
if (chr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL &&
chr->info.addr.vioserial.port == 0) {
int maxport = 0;
- size_t j;
for (j = 0; j < i; j++) {
virDomainChrDefPtr thischr = def->channels[j];
if (thischr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL &&
@@ -12712,7 +12806,7 @@ virDomainDefParseXML(xmlDocPtr xml,
if (n && VIR_ALLOC_N(def->videos, n) < 0)
goto error;
for (i = 0; i < n; i++) {
- size_t j = def->nvideos;
+ j = def->nvideos;
virDomainVideoDefPtr video = virDomainVideoDefParseXML(nodes[j],
def,
flags);
@@ -14138,13 +14232,38 @@ virDomainDefCheckABIStability(virDomainDefPtr src,
dst->mem.cur_balloon, src->mem.cur_balloon);
goto error;
}
- if (src->mem.hugepage_backed != dst->mem.hugepage_backed) {
+ if (src->mem.nhugepages != dst->mem.nhugepages) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain huge page backing %d does not match source %d"),
- dst->mem.hugepage_backed,
- src->mem.hugepage_backed);
+ _("Target domain huge pages count %zu does not match source %zu"),
+ dst->mem.nhugepages, src->mem.nhugepages);
goto error;
}
+ for (i = 0; i < src->mem.nhugepages; i++) {
+ virDomainHugePagePtr src_huge = &src->mem.hugepages[i];
+ virDomainHugePagePtr dst_huge = &dst->mem.hugepages[i];
+
+ if (src_huge->size != dst_huge->size) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+ _("Target domain huge page size %llu "
+ "does not match source %llu"),
+ dst_huge->size, src_huge->size);
+ goto error;
+ }
+
+ if (src_huge->nodemask && dst_huge->nodemask) {
+ if (!virBitmapEqual(src_huge->nodemask, dst_huge->nodemask)) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+ _("Target huge page nodemask does not match source"));
+ goto error;
+ }
+ } else {
+ if (src_huge->nodemask || dst_huge->nodemask) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+ _("Target huge page nodemask does not match source"));
+ goto error;
+ }
+ }
+ }
if (src->vcpus != dst->vcpus) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
@@ -17264,6 +17383,54 @@ virDomainResourceDefFormat(virBufferPtr buf,
}
+static int
+virDomainHugepagesFormatBuf(virBufferPtr buf,
+ virDomainHugePagePtr hugepage)
+{
+ int ret = -1;
+
+ virBufferAsprintf(buf, "size);
+
+ if (hugepage->nodemask) {
+ char *nodeset = NULL;
+ if (!(nodeset = virBitmapFormat(hugepage->nodemask)))
+ goto cleanup;
+ virBufferAsprintf(buf, " nodeset='%s'", nodeset);
+ VIR_FREE(nodeset);
+ }
+
+ virBufferAddLit(buf, "/>\n");
+
+ ret = 0;
+ cleanup:
+ return ret;
+}
+
+static void
+virDomainHugepagesFormat(virBufferPtr buf,
+ virDomainHugePagePtr hugepages,
+ size_t nhugepages)
+{
+ size_t i;
+
+ if (nhugepages == 1 &&
+ hugepages[0].size == 0) {
+ virBufferAddLit(buf, "\n");
+ return;
+ }
+
+ virBufferAddLit(buf, "\n");
+ virBufferAdjustIndent(buf, 2);
+
+ for (i = 0; i < nhugepages; i++)
+ virDomainHugepagesFormatBuf(buf, &hugepages[i]);
+
+ virBufferAdjustIndent(buf, -2);
+ virBufferAddLit(buf, "\n");
+}
+
+
#define DUMPXML_FLAGS \
(VIR_DOMAIN_XML_SECURE | \
VIR_DOMAIN_XML_INACTIVE | \
@@ -17460,11 +17627,11 @@ virDomainDefFormatInternal(virDomainDefPtr def,
virBufferAddLit(buf, "\n");
}
- if (def->mem.hugepage_backed || def->mem.nosharepages || def->mem.locked) {
+ if (def->mem.nhugepages || def->mem.nosharepages || def->mem.locked) {
virBufferAddLit(buf, "\n");
virBufferAdjustIndent(buf, 2);
- if (def->mem.hugepage_backed)
- virBufferAddLit(buf, "\n");
+ if (def->mem.nhugepages)
+ virDomainHugepagesFormat(buf, def->mem.hugepages, def->mem.nhugepages);
if (def->mem.nosharepages)
virBufferAddLit(buf, "\n");
if (def->mem.locked)
diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h
index b988b1782c4cb0997dcc37b7bc7ef318e0caca87..85e1da29ee31007884ea17b5deca7bb769892a6b 100644
--- a/src/conf/domain_conf.h
+++ b/src/conf/domain_conf.h
@@ -1843,6 +1843,14 @@ struct _virDomainResourceDef {
char *partition;
};
+typedef struct _virDomaiHugePage virDomainHugePage;
+typedef virDomainHugePage *virDomainHugePagePtr;
+
+struct _virDomaiHugePage {
+ virBitmapPtr nodemask; /* guest's NUMA node mask */
+ unsigned long long size; /* hugepage size in KiB */
+};
+
/*
* Guest VM main configuration
*
@@ -1869,7 +1877,10 @@ struct _virDomainDef {
struct {
unsigned long long max_balloon; /* in kibibytes */
unsigned long long cur_balloon; /* in kibibytes */
- bool hugepage_backed;
+
+ virDomainHugePagePtr hugepages;
+ size_t nhugepages;
+
bool nosharepages;
bool locked;
int dump_core; /* enum virTristateSwitch */
diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c
index a503dea932b27a9b77bf712dfacb52bfb34e590c..bb9538f3a0ddd77019028f3a2deefaa69c7a4262 100644
--- a/src/parallels/parallels_driver.c
+++ b/src/parallels/parallels_driver.c
@@ -2023,7 +2023,7 @@ parallelsApplyChanges(virDomainObjPtr dom, virDomainDefPtr new)
return -1;
}
- if (old->mem.hugepage_backed != new->mem.hugepage_backed ||
+ if (old->mem.nhugepages != new->mem.nhugepages ||
old->mem.hard_limit != new->mem.hard_limit ||
old->mem.soft_limit != new->mem.soft_limit ||
old->mem.min_guarantee != new->mem.min_guarantee ||
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index 2f788e956e39086bb95e8ed5c491a0da19d6255a..85327fba355b242f91c4c0f5381d4d3fe9c507bc 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -7383,7 +7383,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-m");
def->mem.max_balloon = VIR_DIV_UP(def->mem.max_balloon, 1024) * 1024;
virCommandAddArgFormat(cmd, "%llu", def->mem.max_balloon / 1024);
- if (def->mem.hugepage_backed) {
+ if (def->mem.nhugepages) {
char *mem_path;
if (!cfg->nhugetlbfs) {
diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index 7626cef2aec1eb529f414c5198e5efcb1197b6ee..36922cbd261f9c5786787b0a586228796a84d32a 100644
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -3791,7 +3791,7 @@ int qemuProcessStart(virConnectPtr conn,
}
virDomainAuditSecurityLabel(vm, true);
- if (vm->def->mem.hugepage_backed) {
+ if (vm->def->mem.nhugepages) {
for (i = 0; i < cfg->nhugetlbfs; i++) {
char *hugepagePath = qemuGetHugepagePath(&cfg->hugetlbfs[i]);
diff --git a/tests/qemuxml2argvdata/qemuxml2argv-hugepages-pages.xml b/tests/qemuxml2argvdata/qemuxml2argv-hugepages-pages.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5ad0695734e87b554ebba603f085ec41d12c937f
--- /dev/null
+++ b/tests/qemuxml2argvdata/qemuxml2argv-hugepages-pages.xml
@@ -0,0 +1,45 @@
+
+ QEMUGuest1
+ c7a5fdbd-edaf-9455-926a-d65c16db1809
+ 4194304
+ 4194304
+
+
+
+
+
+
+ 4
+
+
+
+
+
+ hvm
+
+
+
+
+
+
+
+
+
+
+
+ destroy
+ restart
+ destroy
+
+ /usr/bin/qemu
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/qemuxml2xmltest.c b/tests/qemuxml2xmltest.c
index cefe05b2b67aed7633b037da04f1110a5b62f6fb..09cb228c66fc23e3bf7b782f991d9c52ca879e30 100644
--- a/tests/qemuxml2xmltest.c
+++ b/tests/qemuxml2xmltest.c
@@ -197,6 +197,7 @@ mymain(void)
DO_TEST("hyperv-off");
DO_TEST("hugepages");
+ DO_TEST("hugepages-pages");
DO_TEST("nosharepages");
DO_TEST("disk-aio");
DO_TEST("disk-cdrom");