Fix ia64 HVM boot failure. Remove mmap bounce buffer in ia64.

For Non-MAPCACHE case, to get the virtual address corresponding to
guest physical address, only an offset value is added to guest
physical address.  With this patch, ia64 HVM boot failure bug can be
fixed.

[ This reverts part of 2ed2ee1704a4ef956ecc61848c84d12aaa4419d5,
  once again removing the bounce buffer in the non-MAPCACHE
  version of cpu_physical_memory_map. -iwj ]

Signed-off-by: Xiantao Zhang <xiantao.zhang@intel.com>

diff --git a/hw/xen_machine_fv.c b/hw/xen_machine_fv.c
index cbd32c7fdd3adfd656edfc26247b3f2a83ad0400..a5292c1aef6106596b32b57abae95fcf2bd7fbcd 100644 (file)
--- a/hw/xen_machine_fv.c
+++ b/hw/xen_machine_fv.c
@@ -256,6 +256,15 @@ void qemu_invalidate_map_cache(void)
 
     mapcache_unlock();
 }
+#else
+uint8_t *qemu_map_cache(target_phys_addr_t phys_addr, uint8_t lock)
+{
+       return phys_ram_addr(phys_addr);
+}
+
+void qemu_invalidate_map_cache(void) {};
+
+void qemu_invalidate_entry(uint8_t *buffer) {};
 
 #endif /* defined(MAPCACHE) */
 

diff --git a/i386-dm/exec-dm.c b/i386-dm/exec-dm.c
index 40c886847fc8ef185f7f8264d85ab948e76ecc12..daf5f564a1f43b13ad766dc9be8a44b25f0e10c3 100644 (file)
--- a/i386-dm/exec-dm.c
+++ b/i386-dm/exec-dm.c
@@ -453,12 +453,6 @@ void unregister_iomem(target_phys_addr_t start)
 }
 
 
-#if defined(__i386__) || defined(__x86_64__)
-#define phys_ram_addr(x) (qemu_map_cache(x, 0))
-#elif defined(__ia64__)
-#define phys_ram_addr(x) (((x) < ram_size) ? (phys_ram_base + (x)) : NULL)
-#endif
-
 unsigned long *logdirty_bitmap;
 unsigned long logdirty_bitmap_size;
 
@@ -795,7 +789,6 @@ static void cpu_notify_map_clients(void)
     }
 }
 
-#ifdef MAPCACHE
 /* Map a physical memory region into a host virtual address.
  * May map a subset of the requested range, given by and returned in *plen.
  * May return NULL if resources needed to perform the mapping are exhausted.
@@ -807,9 +800,11 @@ void *cpu_physical_memory_map(target_phys_addr_t addr,
                               target_phys_addr_t *plen,
                               int is_write)
 {
+#ifdef MAPCACHE
     unsigned long l = MCACHE_BUCKET_SIZE - (addr & (MCACHE_BUCKET_SIZE-1));
     if ((*plen) > l)
         *plen = l;
+#endif
     return qemu_map_cache(addr, 1);
 }
 
@@ -822,71 +817,3 @@ void cpu_physical_memory_unmap(void *buffer, target_phys_addr_t len,
 {
     qemu_invalidate_entry(buffer);
 }
-#else
-/* Map a physical memory region into a host virtual address.
- * May map a subset of the requested range, given by and returned in *plen.
- * May return NULL if resources needed to perform the mapping are exhausted.
- * Use only for reads OR writes - not for read-modify-write operations.
- * Use cpu_register_map_client() to know when retrying the map operation is
- * likely to succeed.
- */
-void *cpu_physical_memory_map(target_phys_addr_t addr,
-                              target_phys_addr_t *plen,
-                              int is_write)
-{
-    target_phys_addr_t len = *plen;
-    target_phys_addr_t done = 0;
-    int l;
-    uint8_t *ret = NULL;
-    uint8_t *ptr;
-    target_phys_addr_t page;
-    PhysPageDesc *p;
-    unsigned long addr1;
-
-    while (len > 0) {
-        page = addr & TARGET_PAGE_MASK;
-        l = (page + TARGET_PAGE_SIZE) - addr;
-        if (l > len)
-            l = len;
-
-        if (done || bounce.buffer) {
-            break;
-        }
-       bounce.buffer = qemu_memalign(TARGET_PAGE_SIZE, TARGET_PAGE_SIZE);
-        bounce.addr = addr;
-        bounce.len = l;
-        if (!is_write) {
-            cpu_physical_memory_rw(addr, bounce.buffer, l, 0);
-        }
-        ptr = bounce.buffer;
-
-        if (!done) {
-            ret = ptr;
-        } else if (ret + done != ptr) {
-            break;
-        }
-
-        len -= l;
-        addr += l;
-        done += l;
-    }
-    *plen = done;
-    return ret;
-}
-
-/* Unmaps a memory region previously mapped by cpu_physical_memory_map().
- * Will also mark the memory as dirty if is_write == 1.  access_len gives
- * the amount of memory that was actually read or written by the caller.
- */
-void cpu_physical_memory_unmap(void *buffer, target_phys_addr_t len,
-                               int is_write, target_phys_addr_t access_len)
-{
-    assert(buffer == bounce.buffer);
-    if (is_write) {
-        cpu_physical_memory_write(bounce.addr, bounce.buffer, access_len);
-    }
-    qemu_free(bounce.buffer);
-    bounce.buffer = NULL;
-    cpu_notify_map_clients();
-}
-#endif

diff --git a/qemu-xen.h b/qemu-xen.h
index 06d4f27d6406a0d6418e79b2b66fe491e35f713b..41fbc539fecc1774b1eb5b3a968c645f0408b4eb 100644 (file)
--- a/qemu-xen.h
+++ b/qemu-xen.h
@@ -5,6 +5,12 @@
 extern int restore;
 extern int vga_ram_size;
 
+#if defined(__i386__) || defined(__x86_64__)
+#define phys_ram_addr(x) (qemu_map_cache(x, 0))
+#elif defined(__ia64__)
+#define phys_ram_addr(x) (((x) < ram_size) ? (phys_ram_base + (x)) : NULL)
+#endif
+
 /* xen_machine_fv.c */
 
 #if (defined(__i386__) || defined(__x86_64__)) && !defined(QEMU_TOOL)
@@ -19,13 +25,11 @@ extern int vga_ram_size;
 #endif
 
 #define MCACHE_BUCKET_SIZE (1UL << MCACHE_BUCKET_SHIFT)
+#endif
 
 uint8_t *qemu_map_cache(target_phys_addr_t phys_addr, uint8_t lock);
 void     qemu_invalidate_entry(uint8_t *buffer);
 void     qemu_invalidate_map_cache(void);
-#else 
-#define qemu_invalidate_map_cache() ((void)0)
-#endif
 
 #define mapcache_lock()   ((void)0)
 #define mapcache_unlock() ((void)0)