__func__, dom->kernel_size, dom->kernel_blob, dst);
memcpy(dst, dom->kernel_blob, dom->kernel_size);
+ xc_cache_flush(dom->xch, dst, dom->kernel_size);
return 0;
}
memcpy(dest, image + skip, text_size);
memset(dest + text_size, 0, bss_size);
+ xc_cache_flush(dom->xch, dest, text_size+bss_size);
return 0;
}
}
else
memcpy(ramdiskmap, dom->ramdisk_blob, dom->ramdisk_size);
+ xc_cache_flush(dom->xch, ramdiskmap, ramdisklen);
}
/* load devicetree */
goto err;
}
memcpy(devicetreemap, dom->devicetree_blob, dom->devicetree_size);
+ xc_cache_flush(dom->xch, devicetreemap, dom->devicetree_size);
}
/* allocate other pages */
#include <sys/mman.h>
#include <sys/ioctl.h>
+#include <sys/syscall.h>
#include <xen/memory.h>
#include <xen/sys/evtchn.h>
return ret;
}
+static void linux_privcmd_cache_flush(xc_interface *xch,
+ const void *ptr, size_t nr)
+{
+#if defined(__arm__)
+ unsigned long start = (unsigned long)ptr;
+ unsigned long end = start + nr;
+ /* cacheflush(unsigned long start, unsigned long end, int flags) */
+ int rc = syscall(__ARM_NR_cacheflush, start, end, 0);
+ if ( rc < 0 )
+ PERROR("cache flush operation failed: %d\n", errno);
+#elif defined(__aarch64__)
+ unsigned long start = (unsigned long)ptr;
+ unsigned long end = start + nr;
+ unsigned long p, ctr;
+ int stride;
+
+ /* Flush cache using direct DC CVAC instructions. This is
+ * available to EL0 when SCTLR_EL1.UCI is set, which Linux does.
+ *
+ * Bits 19:16 of CTR_EL0 are log2 of the minimum dcache line size
+ * in words, which we use as our stride length. This is readable
+ * with SCTLR_EL1.UCT is set, which Linux does.
+ */
+ asm volatile ("mrs %0, ctr_el0" : "=r" (ctr));
+
+ stride = 4 * (1 << ((ctr & 0xf0000UL) >> 16));
+
+ for ( p = start ; p < end ; p += stride )
+ asm volatile ("dc cvac, %0" : : "r" (p));
+ asm volatile ("dsb sy");
+#elif defined(__i386__) || defined(__x86_64__)
+ /* No need for cache maintenance on x86 */
+#else
+ PERROR("No cache flush operation defined for architecture");
+ abort();
+#endif
+}
+
static struct xc_osdep_ops linux_privcmd_ops = {
.open = &linux_privcmd_open,
.close = &linux_privcmd_close,
.map_foreign_bulk = &linux_privcmd_map_foreign_bulk,
.map_foreign_range = &linux_privcmd_map_foreign_range,
.map_foreign_ranges = &linux_privcmd_map_foreign_ranges,
+
+ .cache_flush = &linux_privcmd_cache_flush,
},
};
return ret;
}
+static void minios_privcmd_cache_flush(xc_interface *xch,
+ const void *ptr, size_t nr)
+{
+#if defined(__i386__) || defined(__x86_64__)
+ /* No need for cache maintenance on x86 */
+#else
+ printf("No cache flush operation defined for architecture");
+ BUG();
+#endif
+}
static struct xc_osdep_ops minios_privcmd_ops = {
.open = &minios_privcmd_open,
.map_foreign_bulk = &minios_privcmd_map_foreign_bulk,
.map_foreign_range = &minios_privcmd_map_foreign_range,
.map_foreign_ranges = &minios_privcmd_map_foreign_ranges,
+
+ .cache_flush = &minios_privcmd_cache_flush,
},
};
#include <xen/sys/evtchn.h>
#include <unistd.h>
+#include <stdlib.h>
#include <fcntl.h>
#include <malloc.h>
#include <sys/mman.h>
return NULL;
}
+static void netbsd_privcmd_cache_flush(xc_interface *xch,
+ const void *ptr, size_t nr)
+{
+#if defined(__i386__) || defined(__x86_64__)
+ /* No need for cache maintenance on x86 */
+#else
+ PERROR("No cache flush operation defined for architecture");
+ abort();
+#endif
+}
+
static struct xc_osdep_ops netbsd_privcmd_ops = {
.open = &netbsd_privcmd_open,
.close = &netbsd_privcmd_close,
.map_foreign_bulk = &xc_map_foreign_bulk_compat,
.map_foreign_range = &netbsd_privcmd_map_foreign_range,
.map_foreign_ranges = &netbsd_privcmd_map_foreign_ranges,
+
+ .cache_flush = &netbsd_privcmd_cache_flush,
},
};
return xch->ops->u.privcmd.hypercall(xch, xch->ops_handle, hypercall);
}
+void xc_cache_flush(xc_interface *xch, const void *p, size_t n)
+{
+ xch->ops->u.privcmd.cache_flush(xch, p, n);
+}
+
xc_evtchn *xc_evtchn_open(xentoollog_logger *logger,
unsigned open_flags)
{
/* Optionally flush file to disk and discard page cache */
void discard_file_cache(xc_interface *xch, int fd, int flush);
+/* Flush data cache */
+void xc_cache_flush(xc_interface *xch, const void *p, size_t n);
+
#define MAX_MMU_UPDATES 1024
struct xc_mmu {
mmu_update_t updates[MAX_MMU_UPDATES];
#include <xen/memory.h>
#include <xen/sys/evtchn.h>
#include <unistd.h>
+#include <stdlib.h>
#include <fcntl.h>
#include <malloc.h>
return NULL;
}
+static void solaris_privcmd_cache_flush(xc_interface *xch,
+ const void *ptr, size_t nr)
+{
+#if defined(__i386__) || defined(__x86_64__)
+ /* No need for cache maintenance on x86 */
+#else
+ PERROR("No cache flush operation defined for architecture");
+ abort();
+#endif
+}
+
static struct xc_osdep_ops solaris_privcmd_ops = {
.open = &solaris_privcmd_open,
.close = &solaris_privcmd_close,
.map_foreign_bulk = &xc_map_foreign_bulk_compat,
.map_foreign_range = &solaris_privcmd_map_foreign_range,
.map_foreign_ranges = &solaris_privcmd_map_foreign_ranges,
+
+ .cache_flush = &solaris_privcmd_cache_flush,
},
};
return MAP_FAILED;
}
+static void ENOSYS_privcmd_cache_flush(xc_interface *xch, const void *p, size_t n)
+{
+ unsigned long start = (unsigned long)p;
+ unsigned long end = start + n;
+ IPRINTF(xch, "ENOSYS_privcmd: cache_flush: %#lx-%#lx\n", start, end);
+}
+
static struct xc_osdep_ops ENOSYS_privcmd_ops =
{
.open = &ENOSYS_privcmd_open,
.map_foreign_bulk = &ENOSYS_privcmd_map_foreign_bulk,
.map_foreign_range = &ENOSYS_privcmd_map_foreign_range,
.map_foreign_ranges = &ENOSYS_privcmd_map_foreign_ranges,
+
+ .cache_flush = &ENOSYS_privcmd_cache_flush,
}
};
void *(*map_foreign_ranges)(xc_interface *xch, xc_osdep_handle h, uint32_t dom, size_t size, int prot,
size_t chunksize, privcmd_mmap_entry_t entries[],
int nentries);
+ void (*cache_flush)(xc_interface *xch, const void *p, size_t n);
} privcmd;
struct {
int (*fd)(xc_evtchn *xce, xc_osdep_handle h);
projects / xen.git / commitdiff