156 lines
5.6 KiB
Diff
156 lines
5.6 KiB
Diff
From 7f5b89a15bfcd964c7f2b6ccbf3c03fd867f93b5 Mon Sep 17 00:00:00 2001
|
|
Message-Id: <7f5b89a15bfcd964c7f2b6ccbf3c03fd867f93b5@dist-git>
|
|
From: Jiri Denemark <jdenemar@redhat.com>
|
|
Date: Wed, 22 Jun 2022 15:21:30 +0200
|
|
Subject: [PATCH] qemu: Add qemuDomainSetMaxMemLock helper
|
|
MIME-Version: 1.0
|
|
Content-Type: text/plain; charset=UTF-8
|
|
Content-Transfer-Encoding: 8bit
|
|
|
|
qemuDomainAdjustMaxMemLock combined computing the desired limit with
|
|
applying it. This patch separates the code to apply a memory locking
|
|
limit to a new qemuDomainSetMaxMemLock helper for better reusability.
|
|
|
|
Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
|
|
Reviewed-by: Ján Tomko <jtomko@redhat.com>
|
|
(cherry picked from commit dff51c7f5760ded8235076f55d082fe4363f2f78)
|
|
|
|
https://bugzilla.redhat.com/show_bug.cgi?id=2117272
|
|
|
|
Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
|
|
---
|
|
src/qemu/qemu_domain.c | 95 ++++++++++++++++++++++++++----------------
|
|
src/qemu/qemu_domain.h | 3 ++
|
|
2 files changed, 61 insertions(+), 37 deletions(-)
|
|
|
|
diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
|
|
index ee7d310903..a81789f194 100644
|
|
--- a/src/qemu/qemu_domain.c
|
|
+++ b/src/qemu/qemu_domain.c
|
|
@@ -9261,6 +9261,61 @@ qemuDomainGetMemLockLimitBytes(virDomainDef *def,
|
|
}
|
|
|
|
|
|
+/**
|
|
+ * qemuDomainSetMaxMemLock:
|
|
+ * @vm: domain
|
|
+ * @limit: the desired memory locking limit
|
|
+ * @origPtr: where to store (or load from) the original value of the limit
|
|
+ *
|
|
+ * Set the memory locking limit for @vm unless it's already big enough. If
|
|
+ * @origPtr is non-NULL, the original value of the limit will be store there
|
|
+ * and can be restored by calling this function with @limit == 0.
|
|
+ *
|
|
+ * Returns: 0 on success, -1 otherwise.
|
|
+ */
|
|
+int
|
|
+qemuDomainSetMaxMemLock(virDomainObj *vm,
|
|
+ unsigned long long limit,
|
|
+ unsigned long long *origPtr)
|
|
+{
|
|
+ unsigned long long current = 0;
|
|
+
|
|
+ if (virProcessGetMaxMemLock(vm->pid, ¤t) < 0)
|
|
+ return -1;
|
|
+
|
|
+ if (limit > 0) {
|
|
+ VIR_DEBUG("Requested memory lock limit: %llu", limit);
|
|
+ /* If the limit is already high enough, we can assume
|
|
+ * that some external process is taking care of managing
|
|
+ * process limits and we shouldn't do anything ourselves:
|
|
+ * we're probably running in a containerized environment
|
|
+ * where we don't have enough privilege anyway */
|
|
+ if (current >= limit) {
|
|
+ VIR_DEBUG("Current limit %llu is big enough", current);
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ /* If this is the first time adjusting the limit, save the current
|
|
+ * value so that we can restore it once memory locking is no longer
|
|
+ * required */
|
|
+ if (origPtr && *origPtr == 0)
|
|
+ *origPtr = current;
|
|
+ } else {
|
|
+ /* Once memory locking is no longer required, we can restore the
|
|
+ * original, usually very low, limit. But only if we actually stored
|
|
+ * the original limit before. */
|
|
+ if (!origPtr || *origPtr == 0)
|
|
+ return 0;
|
|
+
|
|
+ limit = *origPtr;
|
|
+ *origPtr = 0;
|
|
+ VIR_DEBUG("Resetting memory lock limit back to %llu", limit);
|
|
+ }
|
|
+
|
|
+ return virProcessSetMaxMemLock(vm->pid, limit);
|
|
+}
|
|
+
|
|
+
|
|
/**
|
|
* qemuDomainAdjustMaxMemLock:
|
|
* @vm: domain
|
|
@@ -9282,43 +9337,9 @@ int
|
|
qemuDomainAdjustMaxMemLock(virDomainObj *vm,
|
|
bool forceVFIO)
|
|
{
|
|
- qemuDomainObjPrivate *priv = vm->privateData;
|
|
- unsigned long long currentMemLock = 0;
|
|
- unsigned long long desiredMemLock = 0;
|
|
-
|
|
- desiredMemLock = qemuDomainGetMemLockLimitBytes(vm->def, forceVFIO);
|
|
- if (virProcessGetMaxMemLock(vm->pid, ¤tMemLock) < 0)
|
|
- return -1;
|
|
-
|
|
- if (desiredMemLock > 0) {
|
|
- if (currentMemLock < desiredMemLock) {
|
|
- /* If this is the first time adjusting the limit, save the current
|
|
- * value so that we can restore it once memory locking is no longer
|
|
- * required */
|
|
- if (priv->originalMemlock == 0) {
|
|
- priv->originalMemlock = currentMemLock;
|
|
- }
|
|
- } else {
|
|
- /* If the limit is already high enough, we can assume
|
|
- * that some external process is taking care of managing
|
|
- * process limits and we shouldn't do anything ourselves:
|
|
- * we're probably running in a containerized environment
|
|
- * where we don't have enough privilege anyway */
|
|
- desiredMemLock = 0;
|
|
- }
|
|
- } else {
|
|
- /* Once memory locking is no longer required, we can restore the
|
|
- * original, usually very low, limit */
|
|
- desiredMemLock = priv->originalMemlock;
|
|
- priv->originalMemlock = 0;
|
|
- }
|
|
-
|
|
- if (desiredMemLock > 0 &&
|
|
- virProcessSetMaxMemLock(vm->pid, desiredMemLock) < 0) {
|
|
- return -1;
|
|
- }
|
|
-
|
|
- return 0;
|
|
+ return qemuDomainSetMaxMemLock(vm,
|
|
+ qemuDomainGetMemLockLimitBytes(vm->def, forceVFIO),
|
|
+ &QEMU_DOMAIN_PRIVATE(vm)->originalMemlock);
|
|
}
|
|
|
|
|
|
diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h
|
|
index e9497d20de..6d1d23439a 100644
|
|
--- a/src/qemu/qemu_domain.h
|
|
+++ b/src/qemu/qemu_domain.h
|
|
@@ -789,6 +789,9 @@ int qemuDomainAdjustMaxMemLock(virDomainObj *vm,
|
|
bool forceVFIO);
|
|
int qemuDomainAdjustMaxMemLockHostdev(virDomainObj *vm,
|
|
virDomainHostdevDef *hostdev);
|
|
+int qemuDomainSetMaxMemLock(virDomainObj *vm,
|
|
+ unsigned long long limit,
|
|
+ unsigned long long *origPtr);
|
|
|
|
int qemuDomainDefValidateMemoryHotplug(const virDomainDef *def,
|
|
const virDomainMemoryDef *mem);
|
|
--
|
|
2.35.1
|
|
|