Skip memory balance for preloaded until pause

Balloon is allowed before paused and can be canceled by touching the
file.

For: QubesOS/qubes-issues#1512

Author: ben-grande

qubes/qmemman/systemstate.py

@@ -73,6 +73,13 @@ def init(self) -> None:
     def get_xs_path(self, domid, key) -> str:
         return "/local/domain/" + str(domid) + "/memory/" + key
 
+    def can_membalance(self, domid) -> bool:
+        file = "/var/run/qubes/do-not-membalance-domid-" + domid
+        if os.path.isfile(file):
+            self.log.debug("%s file present" % file)
+            return False
+        return True
+
     def add_domain(self, domid) -> None:
         self.log.debug("add_domain(domid={!r})".format(domid))
         self.dom_dict[domid] = DomainState(domid)
@@ -208,6 +215,7 @@ def inhibit_balloon_up(self) -> None:
             if (
                 dom.mem_actual is not None
                 and dom.mem_actual + 200 * 1024 < dom.last_target
+                and self.can_membalance(domid)
             ):
                 self.log.info(
                     "Preventing balloon up to {}".format(dom.last_target)
@@ -247,7 +255,7 @@ def do_balloon(self, mem_size) -> bool:
             xenfree_ring[ring_slot] = xenfree
             for domid, prev_mem in prev_mem_actual.items():
                 dom = self.dom_dict[domid]
-                if prev_mem == dom.mem_actual:
+                if prev_mem == dom.mem_actual or not self.can_membalance(domid):
                     # domain not responding to memset requests, remove it
                     #  from donors
                     dom.no_progress = True
@@ -289,6 +297,9 @@ def do_balloon_dom(self, dom_memset: dict) -> bool:
         memset_reqs = {}
         for domid, memset in dom_memset.items():
             dom = dom_dict[domid]
+            if not self.can_membalance(domid):
+                succeeded.append(domid)
+                continue
             if memset == 0:
                 # Domain hasn't sent meminfo back to the server, it is still at
                 # the initial amount. pref_mem can't be calculated yet.
@@ -327,6 +338,8 @@ def do_balloon_dom(self, dom_memset: dict) -> bool:
         while True:
             self.refresh_mem_actual(domid_list)
             for domid, dom in dom_dict.items():
+                if not self.can_membalance(domid):
+                    succeeded.append(domid)
                 if domid in succeeded:
                     continue
                 assert isinstance(dom.mem_actual, int)

qubes/vm/dispvm.py

@@ -26,6 +26,7 @@
 import copy
 import subprocess
 from typing import Optional
+from pathlib import Path
 
 import qubes.config
 import qubes.vm.appvm
@@ -487,6 +488,7 @@ def on_domain_loaded(self, event) -> None:
         """
         # pylint: disable=unused-argument
         assert self.template
+        self.do_not_membalance_file = Path("/var/run/qubes/do-not-membalance-domid-" + str(self.xid))
 
     async def wait_operational_preload(
         self, service: str, timeout: int | float
@@ -632,6 +634,7 @@ async def on_domain_pre_paused(self, event, **kwargs) -> None:
                     cancelled = True
                     qmemman_task.cancel()
                 else:
+                    self.do_not_membalance_file.touch(exist_ok=True)
                     result = qmemman_task.result()
                     break_task.cancel()
         except asyncio.CancelledError:
@@ -649,6 +652,7 @@ async def on_domain_pre_paused(self, event, **kwargs) -> None:
             if not result or cancelled:
                 self.log.warning("Failed to set memory")
             if self.preload_requested:
+                self.do_not_membalance_file.unlink(missing_ok=True)
                 raise qubes.exc.QubesVMCancelledPauseError(
                     self,
                     "preload was requested before memory request completed",
@@ -665,6 +669,7 @@ def on_domain_paused(
         """
         if self.is_preload:
             self.log.info("Paused preloaded qube")
+            self.do_not_membalance_file.unlink(missing_ok=True)
 
     @qubes.events.handler("domain-unpaused")
     async def on_domain_unpaused(