[v7][RFC][PATCH 06/13] hvmloader/ram: check if guest memory is out of reserved device memory maps

[Tiejun Chen <tiejun.chen@intel.com>]

We need to check to reserve all reserved device memory maps in e820
to avoid any potential guest memory conflict.

Currently, if we can't insert RDM entries directly, we may need to handle
several ranges as follows:
a. Fixed Ranges --> BUG()
 lowmem_reserved_base-0xA0000: reserved by BIOS implementation,
 BIOS region,
 RESERVED_MEMBASE ~ 0x100000000,
b. RAM or RAM:Hole -> Try to reserve

Signed-off-by: Tiejun Chen <tiejun.chen@intel.com>
---
 tools/firmware/hvmloader/e820.c | 215 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 215 insertions(+)

diff --git a/tools/firmware/hvmloader/e820.c b/tools/firmware/hvmloader/e820.c
index 2e05e93..d188e02 100644
--- a/tools/firmware/hvmloader/e820.c
+++ b/tools/firmware/hvmloader/e820.c
@@ -68,12 +68,218 @@ void dump_e820_table(struct e820entry *e820, unsigned int nr)
     }
 }
 
+static unsigned int construct_rdm_e820_maps(unsigned int next_e820_entry_index,
+                                            uint32_t nr_map,
+                                            struct xen_mem_reserved_device_memory *map,
+                                            struct e820entry *e820,
+                                            unsigned int lowmem_reserved_base,
+                                            unsigned int bios_image_base)
+{
+    unsigned int i, j, sum_nr = next_e820_entry_index + nr_map;
+    uint64_t start, end, next_start, rdm_start, rdm_end;
+    uint32_t type;
+    unsigned int insert = 0, do_insert = 0;
+    int err = 0;
+
+ do_real_construct:
+    for ( i = 0; i < nr_map; i++ )
+    {
+        rdm_start = map[i].start_pfn << PAGE_SHIFT;
+        rdm_end = rdm_start + (map[i].nr_pages << PAGE_SHIFT);
+
+        for ( j = 0; j < next_e820_entry_index - 1; j++ )
+        {
+            start = e820[j].addr;
+            end = e820[j].addr + e820[j].size;
+            type = e820[j].type;
+            next_start = e820[j+1].addr;
+
+            /* lowmem_reserved_base-0xA0000: reserved by BIOS implementation. */
+            if ( lowmem_reserved_base < 0xA0000 &&
+                 start == lowmem_reserved_base )
+            {
+                if ( rdm_start >= start && rdm_start <= end )
+                {
+                    err = -1;
+                    break;
+                }
+            }
+
+            /*
+             * BIOS region.
+             */
+            if ( start == bios_image_base )
+            {
+                if ( rdm_start >= start && rdm_start <= end )
+                {
+                    err = -1;
+                    break;
+                }
+            }
+
+            /* The default memory map always occupy one fixed reserved
+             * range: RESERVED_MEMBASE ~ 0x100000000
+             */
+            if ( rdm_start >= RESERVED_MEMBASE &&
+                      rdm_start <= ((uint64_t)1 << 32) )
+            {
+                err = -1;
+                break;
+            }
+
+            /* Just amid those remaining e820 entries. */
+            if ( (rdm_start > end) && (rdm_end < next_start) )
+            {
+                if ( do_insert )
+                {
+                    memmove(&e820[j+2], &e820[j+1],
+                            (sum_nr - j - 1) * sizeof(struct e820entry));
+
+                    /* Then fill RMRR into that entry. */
+                    e820[j+1].addr = rdm_start;
+                    e820[j+1].size = rdm_end - rdm_start;
+                    e820[j+1].type = E820_RESERVED;
+                    next_e820_entry_index++;
+                }
+                insert++;
+            }
+            /* Already at the end. */
+            else if ( (rdm_start > end) && !next_start )
+            {
+                if ( do_insert )
+                {
+                    e820[next_e820_entry_index].addr = rdm_start;
+                    e820[next_e820_entry_index].size = rdm_end - rdm_start;
+                    e820[next_e820_entry_index].type = E820_RESERVED;
+                    next_e820_entry_index++;
+                }
+                insert++;
+            }
+            /* If completely overlap with one RAM range. */
+            else if ( rdm_start == start && rdm_end == end && type == E820_RAM )
+            {
+                if ( do_insert )
+                    e820[j].type = E820_RESERVED;
+                insert++;
+            }
+            /* If we're just alligned with start of one RAM range. */
+            else if ( rdm_start == start && rdm_end < end && type == E820_RAM )
+            {
+                if ( do_insert )
+                {
+                    memmove(&e820[j+1], &e820[j],
+                            (sum_nr - j) * sizeof(struct e820entry));
+
+                    e820[j+1].addr = rdm_end;
+                    e820[j+1].size = e820[j].addr + e820[j].size - rdm_end;
+                    e820[j+1].type = E820_RAM;
+                    next_e820_entry_index++;
+
+                    e820[j].addr = rdm_start;
+                    e820[j].size = rdm_end - rdm_start;
+                    e820[j].type = E820_RESERVED;
+                }
+                insert++;
+            }
+            /* If we're just alligned with end of one RAM range. */
+            else if ( rdm_start > start && rdm_end == end && type == E820_RAM )
+            {
+                if ( do_insert )
+                {
+                    memmove(&e820[j+1], &e820[j],
+                            (sum_nr - j) * sizeof(struct e820entry));
+
+                    e820[j].size = rdm_start - e820[j].addr;
+                    e820[j].type = E820_RAM;
+
+                    e820[j+1].addr = rdm_start;
+                    e820[j+1].size = rdm_end - rdm_start;
+                    e820[j+1].type = E820_RESERVED;
+                    next_e820_entry_index++;
+                }
+                insert++;
+            }
+            /* If we're just in of one RAM range */
+            else if ( rdm_start > start && rdm_end < end && type == E820_RAM )
+            {
+                if ( do_insert )
+                {
+                    memmove(&e820[j+2], &e820[j],
+                            (sum_nr - j) * sizeof(struct e820entry));
+
+                    e820[j+2].addr = rdm_end;
+                    e820[j+2].size = e820[j].addr + e820[j].size - rdm_end;
+                    e820[j+2].type = E820_RAM;
+                    next_e820_entry_index++;
+
+                    e820[j+1].addr = rdm_start;
+                    e820[j+1].size = rdm_end - rdm_start;
+                    e820[j+1].type = E820_RESERVED;
+                    next_e820_entry_index++;
+
+                    e820[j].size = rdm_start - e820[j].addr;
+                    e820[j].type = E820_RAM;
+                }
+                insert++;
+            }
+            /* If we're going last RAM:Hole range */
+            else if ( end < next_start &&
+                      rdm_start > start &&
+                      rdm_end < next_start &&
+                      type == E820_RAM )
+            {
+                if ( do_insert )
+                {
+                    memmove(&e820[j+1], &e820[j],
+                            (sum_nr - j) * sizeof(struct e820entry));
+
+                    e820[j].size = rdm_start - e820[j].addr;
+                    e820[j].type = E820_RAM;
+
+                    e820[j+1].addr = rdm_start;
+                    e820[j+1].size = rdm_end - rdm_start;
+                    e820[j+1].type = E820_RESERVED;
+                    next_e820_entry_index++;
+                }
+                insert++;
+            }
+        }
+    }
+
+    /* These overlap may issue guest can't work well. */
+    if ( err )
+    {
+        printf("Guest can't work with some reserved device memory overlap!\n");
+        BUG();
+    }
+
+    /* Just return if done. */
+    if ( do_insert )
+        return next_e820_entry_index;
+
+    /* Fine to construct RDM mappings into e820. */
+    if ( insert == nr_map )
+    {
+        do_insert = 1;
+        goto do_real_construct;
+    }
+    /* Overlap. */
+    else
+    {
+        printf("RDM overlap with those existing e820 entries!\n");
+        printf("So we don't construct RDM mapping in e820!\n");
+    }
+
+    return next_e820_entry_index;
+}
+
 /* Create an E820 table based on memory parameters provided in hvm_info. */
 int build_e820_table(struct e820entry *e820,
                      unsigned int lowmem_reserved_base,
                      unsigned int bios_image_base)
 {
     unsigned int nr = 0;
+    int nr_entries = 0;
 
     if ( !lowmem_reserved_base )
             lowmem_reserved_base = 0xA0000;
@@ -169,6 +375,15 @@ int build_e820_table(struct e820entry *e820,
         nr++;
     }
 
+    if ( rdm_map )
+    {
+        nr_entries = hvm_get_reserved_device_memory_map();
+        if ( nr_entries > 0 )
+            nr = construct_rdm_e820_maps(nr, nr_entries, rdm_map, e820,
+                                         lowmem_reserved_base,
+                                         bios_image_base);
+    }
+
     return nr;
 }
 
-- 
1.9.1