hw/arm/boot: arm_load_kernel implemented as a machine init done notifier

[qemu.git] / kvm-all.c

diff --git a/kvm-all.c b/kvm-all.c
index 55025cc366992b2a1d4a21b426edffe3e37f0ff6..b2b1bc3359e6c9126d6918938a219c9402674140 100644 (file)
--- a/kvm-all.c
+++ b/kvm-all.c
@@ -528,17 +528,37 @@ int kvm_vm_check_extension(KVMState *s, unsigned int extension)
     return ret;
 }
 
     return ret;
 }
 

+static uint32_t adjust_ioeventfd_endianness(uint32_t val, uint32_t size)
+{
+#if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
+    /* The kernel expects ioeventfd values in HOST_WORDS_BIGENDIAN
+     * endianness, but the memory core hands them in target endianness.
+     * For example, PPC is always treated as big-endian even if running
+     * on KVM and on PPC64LE.  Correct here.
+     */
+    switch (size) {
+    case 2:
+        val = bswap16(val);
+        break;
+    case 4:
+        val = bswap32(val);
+        break;
+    }
+#endif
+    return val;
+}
+

 static int kvm_set_ioeventfd_mmio(int fd, hwaddr addr, uint32_t val,
                                   bool assign, uint32_t size, bool datamatch)
 {
     int ret;
 static int kvm_set_ioeventfd_mmio(int fd, hwaddr addr, uint32_t val,
                                   bool assign, uint32_t size, bool datamatch)
 {
     int ret;

-    struct kvm_ioeventfd iofd;
-
-    iofd.datamatch = datamatch ? val : 0;
-    iofd.addr = addr;
-    iofd.len = size;
-    iofd.flags = 0;
-    iofd.fd = fd;
+    struct kvm_ioeventfd iofd = {
+        .datamatch = datamatch ? adjust_ioeventfd_endianness(val, size) : 0,
+        .addr = addr,
+        .len = size,
+        .flags = 0,
+        .fd = fd,
+    };

 
     if (!kvm_enabled()) {
         return -ENOSYS;
 
     if (!kvm_enabled()) {
         return -ENOSYS;


@@ -564,7 +584,7 @@ static int kvm_set_ioeventfd_pio(int fd, uint16_t addr, uint16_t val,
                                  bool assign, uint32_t size, bool datamatch)
 {
     struct kvm_ioeventfd kick = {
                                  bool assign, uint32_t size, bool datamatch)
 {
     struct kvm_ioeventfd kick = {

-        .datamatch = datamatch ? val : 0,
+        .datamatch = datamatch ? adjust_ioeventfd_endianness(val, size) : 0,

         .addr = addr,
         .flags = KVM_IOEVENTFD_FLAG_PIO,
         .len = size,
         .addr = addr,
         .flags = KVM_IOEVENTFD_FLAG_PIO,
         .len = size,


@@ -695,7 +715,7 @@ static void kvm_set_phys_mem(MemoryRegionSection *section, bool add)
 
         old = *mem;
 
 
         old = *mem;
 

-        if (mem->flags & KVM_MEM_LOG_DIRTY_PAGES) {
+        if ((mem->flags & KVM_MEM_LOG_DIRTY_PAGES) || s->migration_log) {

             kvm_physical_sync_dirty_bitmap(section);
         }
 
             kvm_physical_sync_dirty_bitmap(section);
         }
 


@@ -1121,18 +1141,18 @@ static int kvm_irqchip_get_virq(KVMState *s)
 {
     uint32_t *word = s->used_gsi_bitmap;
     int max_words = ALIGN(s->gsi_count, 32) / 32;
 {
     uint32_t *word = s->used_gsi_bitmap;
     int max_words = ALIGN(s->gsi_count, 32) / 32;

-    int i, bit;
+    int i, zeroes;

     bool retry = true;
 
 again:
     /* Return the lowest unused GSI in the bitmap */
     for (i = 0; i < max_words; i++) {
     bool retry = true;
 
 again:
     /* Return the lowest unused GSI in the bitmap */
     for (i = 0; i < max_words; i++) {

-        bit = ffs(~word[i]);
-        if (!bit) {
+        zeroes = ctz32(~word[i]);
+        if (zeroes == 32) {

             continue;
         }
 
             continue;
         }
 

-        return bit - 1 + i * 32;
+        return zeroes + i * 32;

     }
     if (!s->direct_msi && retry) {
         retry = false;
     }
     if (!s->direct_msi && retry) {
         retry = false;


@@ -1208,7 +1228,7 @@ int kvm_irqchip_add_msi_route(KVMState *s, MSIMessage msg)
     int virq;
 
     if (kvm_gsi_direct_mapping()) {
     int virq;
 
     if (kvm_gsi_direct_mapping()) {

-        return msg.data & 0xffff;
+        return kvm_arch_msi_data_to_gsi(msg.data);

     }
 
     if (!kvm_gsi_routing_enabled()) {
     }
 
     if (!kvm_gsi_routing_enabled()) {


@@ -1524,8 +1544,17 @@ static int kvm_init(MachineState *ms)
                 strerror(-ret));
 
 #ifdef TARGET_S390X
                 strerror(-ret));
 
 #ifdef TARGET_S390X

-        fprintf(stderr, "Please add the 'switch_amode' kernel parameter to "
-                        "your host kernel command line\n");
+        if (ret == -EINVAL) {
+            fprintf(stderr,
+                    "Host kernel setup problem detected. Please verify:\n");
+            fprintf(stderr, "- for kernels supporting the switch_amode or"
+                    " user_mode parameters, whether\n");
+            fprintf(stderr,
+                    "  user space is running in primary address space\n");
+            fprintf(stderr,
+                    "- for kernels supporting the vm.allocate_pgste sysctl, "
+                    "whether it is enabled\n");
+        }

 #endif
         goto err;
     }
 #endif
         goto err;
     }


@@ -1640,14 +1669,15 @@ void kvm_set_sigmask_len(KVMState *s, unsigned int sigmask_len)
     s->sigmask_len = sigmask_len;
 }
 
     s->sigmask_len = sigmask_len;
 }
 

-static void kvm_handle_io(uint16_t port, void *data, int direction, int size,
-                          uint32_t count)
+static void kvm_handle_io(uint16_t port, MemTxAttrs attrs, void *data, int direction,
+                          int size, uint32_t count)

 {
     int i;
     uint8_t *ptr = data;
 
     for (i = 0; i < count; i++) {
 {
     int i;
     uint8_t *ptr = data;
 
     for (i = 0; i < count; i++) {

-        address_space_rw(&address_space_io, port, ptr, size,
+        address_space_rw(&address_space_io, port, attrs,
+                         ptr, size,

                          direction == KVM_EXIT_IO_OUT);
         ptr += size;
     }
                          direction == KVM_EXIT_IO_OUT);
         ptr += size;
     }


@@ -1766,6 +1796,8 @@ int kvm_cpu_exec(CPUState *cpu)
     }
 
     do {
     }
 
     do {

+        MemTxAttrs attrs;
+

         if (cpu->kvm_vcpu_dirty) {
             kvm_arch_put_registers(cpu, KVM_PUT_RUNTIME_STATE);
             cpu->kvm_vcpu_dirty = false;
         if (cpu->kvm_vcpu_dirty) {
             kvm_arch_put_registers(cpu, KVM_PUT_RUNTIME_STATE);
             cpu->kvm_vcpu_dirty = false;


@@ -1786,7 +1818,7 @@ int kvm_cpu_exec(CPUState *cpu)
         run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);
 
         qemu_mutex_lock_iothread();
         run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);
 
         qemu_mutex_lock_iothread();

-        kvm_arch_post_run(cpu, run);
+        attrs = kvm_arch_post_run(cpu, run);

 
         if (run_ret < 0) {
             if (run_ret == -EINTR || run_ret == -EAGAIN) {
 
         if (run_ret < 0) {
             if (run_ret == -EINTR || run_ret == -EAGAIN) {


@@ -1804,7 +1836,7 @@ int kvm_cpu_exec(CPUState *cpu)
         switch (run->exit_reason) {
         case KVM_EXIT_IO:
             DPRINTF("handle_io\n");
         switch (run->exit_reason) {
         case KVM_EXIT_IO:
             DPRINTF("handle_io\n");

-            kvm_handle_io(run->io.port,
+            kvm_handle_io(run->io.port, attrs,

                           (uint8_t *)run + run->io.data_offset,
                           run->io.direction,
                           run->io.size,
                           (uint8_t *)run + run->io.data_offset,
                           run->io.direction,
                           run->io.size,


@@ -1813,10 +1845,11 @@ int kvm_cpu_exec(CPUState *cpu)
             break;
         case KVM_EXIT_MMIO:
             DPRINTF("handle_mmio\n");
             break;
         case KVM_EXIT_MMIO:
             DPRINTF("handle_mmio\n");

-            cpu_physical_memory_rw(run->mmio.phys_addr,
-                                   run->mmio.data,
-                                   run->mmio.len,
-                                   run->mmio.is_write);
+            address_space_rw(&address_space_memory,
+                             run->mmio.phys_addr, attrs,
+                             run->mmio.data,
+                             run->mmio.len,
+                             run->mmio.is_write);

             ret = 0;
             break;
         case KVM_EXIT_IRQ_WINDOW_OPEN:
             ret = 0;
             break;
         case KVM_EXIT_IRQ_WINDOW_OPEN: