From 1e7e8f89183bc993b0158998595ad2043c46486e Mon Sep 17 00:00:00 2001
From: Benjamin Block <bebl@mageta.org>
Date: Fri, 7 Nov 2014 18:57:11 +0100
Subject: [PATCH] tools: config-create: exclude kernel-area from mem-allocation

When allocating memory for jailhouse, we currently don't look at where
the kernel lives on the system. In case our `memmap` overlaps with this
area, the kernel will just ignore the kernel-cmd-option and out generated
configuration will be invalid.

To fix this, the script now looks out for any kernel-region while
parsing the tree from /proc/iomem and splits the parent-region on the
kernels boundaries. This region will then not be considered anymore and
could additionally be handled special in other cases in the future. The
config will contain it as extra memory-region with all rights.

Signed-off-by: Benjamin Block <bebl@mageta.org>
Reviewed-by: Henning Schild <henning.schild@siemens.com>
Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>
---
 tools/jailhouse-config-create | 40 +++++++++++++++++++++++++++++++++--
 1 file changed, 38 insertions(+), 2 deletions(-)

diff --git a/tools/jailhouse-config-create b/tools/jailhouse-config-create
index 5fce509..4ece2a1 100755
--- a/tools/jailhouse-config-create
+++ b/tools/jailhouse-config-create
@@ -290,6 +290,7 @@ class MemRegion:
     def flagstr(self, p=''):
         if (
             self.typestr == 'System RAM' or
+            self.typestr == 'Kernel' or
             self.typestr == 'RAM buffer' or
             self.typestr == 'ACPI DMAR RMRR'
         ):
@@ -320,6 +321,39 @@ class IOMemRegionTree:
             s += str(c)
         return s
 
+    def regions_split_by_kernel(self):
+        kernel = [x for x in self.children if
+                    x.region.typestr.startswith('Kernel ')]
+
+        if (len(kernel) == 0):
+            return [self.region]
+
+        r = self.region
+        s = r.typestr
+
+        kernel_start = kernel[0].region.start
+        kernel_stop = kernel[len(kernel) - 1].region.stop
+
+        # align this for 16M, but only if we have enough space
+        kernel_stop = (kernel_stop & ~0xFFFFFF) + 0xFFFFFF
+        if (kernel_stop > r.stop):
+            kernel_stop = r.stop
+
+        before_kernel = None
+        after_kernel = None
+
+        # before Kernel if any
+        if (r.start < kernel_start):
+            before_kernel = MemRegion(r.start, kernel_start - 1, s)
+
+        kernel_region = MemRegion(kernel_start, kernel_stop, "Kernel")
+
+        # after Kernel if any
+        if (r.stop > kernel_stop):
+            after_kernel = MemRegion(kernel_stop + 1, r.stop, s)
+
+        return [before_kernel, kernel_region, after_kernel]
+
     @staticmethod
     def parse_iomem_line(line):
         a = line.split(':', 1)
@@ -365,9 +399,11 @@ class IOMemRegionTree:
             r = tree.region
             s = r.typestr
 
-            # System RAM on first level will be added without digging deeper
+            # System RAM on the first level will be added completely,
+            # if they don't contain the kernel itself, if they do,
+            # we split them
             if (tree.level == 1 and s == 'System RAM'):
-                regions.append(r)
+                regions.extend(tree.regions_split_by_kernel())
                 continue
 
             # blacklisted on all levels
-- 
2.39.2