virtio-ccw: range check in READ_VQ_CONF

[qemu.git] / kvm-all.c

diff --git a/kvm-all.c b/kvm-all.c
index 1402f4f42949115728f712cbdc5e3c67659e942e..335438adb526c133b93cac095b76f973836aa0e3 100644 (file)
--- a/kvm-all.c
+++ b/kvm-all.c
@@ -25,6 +25,7 @@
 #include "qemu/option.h"
 #include "qemu/config-file.h"
 #include "sysemu/sysemu.h"
 #include "qemu/option.h"
 #include "qemu/config-file.h"
 #include "sysemu/sysemu.h"

+#include "sysemu/accel.h"

 #include "hw/hw.h"
 #include "hw/pci/msi.h"
 #include "hw/s390x/adapter.h"
 #include "hw/hw.h"
 #include "hw/pci/msi.h"
 #include "hw/s390x/adapter.h"


@@ -44,10 +45,6 @@
 #include <sys/eventfd.h>
 #endif
 
 #include <sys/eventfd.h>
 #endif
 

-#ifdef CONFIG_VALGRIND_H
-#include <valgrind/memcheck.h>
-#endif
-

 /* KVM uses PAGE_SIZE in its definition of COALESCED_MMIO_MAX */
 #define PAGE_SIZE TARGET_PAGE_SIZE
 
 /* KVM uses PAGE_SIZE in its definition of COALESCED_MMIO_MAX */
 #define PAGE_SIZE TARGET_PAGE_SIZE
 


@@ -76,6 +73,8 @@ typedef struct kvm_dirty_log KVMDirtyLog;
 
 struct KVMState
 {
 
 struct KVMState
 {

+    AccelState parent_obj;
+

     KVMSlot *slots;
     int nr_slots;
     int fd;
     KVMSlot *slots;
     int nr_slots;
     int fd;


@@ -110,17 +109,24 @@ struct KVMState
 #endif
 };
 
 #endif
 };
 

+#define TYPE_KVM_ACCEL ACCEL_CLASS_NAME("kvm")
+
+#define KVM_STATE(obj) \
+    OBJECT_CHECK(KVMState, (obj), TYPE_KVM_ACCEL)
+

 KVMState *kvm_state;
 bool kvm_kernel_irqchip;
 bool kvm_async_interrupts_allowed;
 bool kvm_halt_in_kernel_allowed;
 bool kvm_eventfds_allowed;
 bool kvm_irqfds_allowed;
 KVMState *kvm_state;
 bool kvm_kernel_irqchip;
 bool kvm_async_interrupts_allowed;
 bool kvm_halt_in_kernel_allowed;
 bool kvm_eventfds_allowed;
 bool kvm_irqfds_allowed;

+bool kvm_resamplefds_allowed;

 bool kvm_msi_via_irqfd_allowed;
 bool kvm_gsi_routing_allowed;
 bool kvm_gsi_direct_mapping;
 bool kvm_allowed;
 bool kvm_readonly_mem_allowed;
 bool kvm_msi_via_irqfd_allowed;
 bool kvm_gsi_routing_allowed;
 bool kvm_gsi_direct_mapping;
 bool kvm_allowed;
 bool kvm_readonly_mem_allowed;

+bool kvm_vm_attributes_allowed;

 
 static const KVMCapabilityInfo kvm_required_capabilites[] = {
     KVM_CAP_INFO(USER_MEMORY),
 
 static const KVMCapabilityInfo kvm_required_capabilites[] = {
     KVM_CAP_INFO(USER_MEMORY),


@@ -128,7 +134,7 @@ static const KVMCapabilityInfo kvm_required_capabilites[] = {
     KVM_CAP_LAST_INFO
 };
 
     KVM_CAP_LAST_INFO
 };
 

-static KVMSlot *kvm_alloc_slot(KVMState *s)
+static KVMSlot *kvm_get_free_slot(KVMState *s)

 {
     int i;
 
 {
     int i;
 


@@ -138,6 +144,22 @@ static KVMSlot *kvm_alloc_slot(KVMState *s)
         }
     }
 
         }
     }
 

+    return NULL;
+}
+
+bool kvm_has_free_slot(MachineState *ms)
+{
+    return kvm_get_free_slot(KVM_STATE(ms->accelerator));
+}
+
+static KVMSlot *kvm_alloc_slot(KVMState *s)
+{
+    KVMSlot *slot = kvm_get_free_slot(s);
+
+    if (slot) {
+        return slot;
+    }
+

     fprintf(stderr, "%s: no free slot available\n", __func__);
     abort();
 }
     fprintf(stderr, "%s: no free slot available\n", __func__);
     abort();
 }


@@ -345,7 +367,7 @@ static void kvm_log_stop(MemoryListener *listener,
     }
 }
 
     }
 }
 

-static int kvm_set_migration_log(int enable)
+static int kvm_set_migration_log(bool enable)

 {
     KVMState *s = kvm_state;
     KVMSlot *mem;
 {
     KVMState *s = kvm_state;
     KVMSlot *mem;


@@ -396,7 +418,7 @@ static int kvm_physical_sync_dirty_bitmap(MemoryRegionSection *section)
 {
     KVMState *s = kvm_state;
     unsigned long size, allocated_size = 0;
 {
     KVMState *s = kvm_state;
     unsigned long size, allocated_size = 0;

-    KVMDirtyLog d;
+    KVMDirtyLog d = {};

     KVMSlot *mem;
     int ret = 0;
     hwaddr start_addr = section->offset_within_address_space;
     KVMSlot *mem;
     int ret = 0;
     hwaddr start_addr = section->offset_within_address_space;


@@ -493,13 +515,46 @@ int kvm_check_extension(KVMState *s, unsigned int extension)
     return ret;
 }
 
     return ret;
 }
 

+int kvm_vm_check_extension(KVMState *s, unsigned int extension)
+{
+    int ret;
+
+    ret = kvm_vm_ioctl(s, KVM_CHECK_EXTENSION, extension);
+    if (ret < 0) {
+        /* VM wide version not implemented, use global one instead */
+        ret = kvm_check_extension(s, extension);
+    }
+
+    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;
     struct kvm_ioeventfd iofd;
 
 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.datamatch = datamatch ? adjust_ioeventfd_endianness(val, size) : 0;

     iofd.addr = addr;
     iofd.len = size;
     iofd.flags = 0;
     iofd.addr = addr;
     iofd.len = size;
     iofd.flags = 0;


@@ -529,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,


@@ -617,8 +672,10 @@ static void kvm_set_phys_mem(MemoryRegionSection *section, bool add)
     unsigned delta;
 
     /* kvm works in page size chunks, but the function may be called
     unsigned delta;
 
     /* kvm works in page size chunks, but the function may be called

-       with sub-page size and unaligned start address. */
-    delta = TARGET_PAGE_ALIGN(size) - size;
+       with sub-page size and unaligned start address. Pad the start
+       address to next and truncate size to previous page boundary. */
+    delta = (TARGET_PAGE_SIZE - (start_addr & ~TARGET_PAGE_MASK));
+    delta &= ~TARGET_PAGE_MASK;

     if (delta > size) {
         return;
     }
     if (delta > size) {
         return;
     }


@@ -1189,6 +1246,10 @@ int kvm_irqchip_add_msi_route(KVMState *s, MSIMessage msg)
     kroute.u.msi.address_lo = (uint32_t)msg.address;
     kroute.u.msi.address_hi = msg.address >> 32;
     kroute.u.msi.data = le32_to_cpu(msg.data);
     kroute.u.msi.address_lo = (uint32_t)msg.address;
     kroute.u.msi.address_hi = msg.address >> 32;
     kroute.u.msi.data = le32_to_cpu(msg.data);

+    if (kvm_arch_fixup_msi_route(&kroute, msg.address, msg.data)) {
+        kvm_irqchip_release_virq(s, virq);
+        return -EINVAL;
+    }

 
     kvm_add_routing_entry(s, &kroute);
     kvm_irqchip_commit_routes(s);
 
     kvm_add_routing_entry(s, &kroute);
     kvm_irqchip_commit_routes(s);


@@ -1214,6 +1275,9 @@ int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg)
     kroute.u.msi.address_lo = (uint32_t)msg.address;
     kroute.u.msi.address_hi = msg.address >> 32;
     kroute.u.msi.data = le32_to_cpu(msg.data);
     kroute.u.msi.address_lo = (uint32_t)msg.address;
     kroute.u.msi.address_hi = msg.address >> 32;
     kroute.u.msi.data = le32_to_cpu(msg.data);

+    if (kvm_arch_fixup_msi_route(&kroute, msg.address, msg.data)) {
+        return -EINVAL;
+    }

 
     return kvm_update_routing_entry(s, &kroute);
 }
 
     return kvm_update_routing_entry(s, &kroute);
 }


@@ -1241,7 +1305,7 @@ static int kvm_irqchip_assign_irqfd(KVMState *s, int fd, int rfd, int virq,
 
 int kvm_irqchip_add_adapter_route(KVMState *s, AdapterInfo *adapter)
 {
 
 int kvm_irqchip_add_adapter_route(KVMState *s, AdapterInfo *adapter)
 {

-    struct kvm_irq_routing_entry kroute;
+    struct kvm_irq_routing_entry kroute = {};

     int virq;
 
     if (!kvm_gsi_routing_enabled()) {
     int virq;
 
     if (!kvm_gsi_routing_enabled()) {


@@ -1317,11 +1381,11 @@ int kvm_irqchip_remove_irqfd_notifier(KVMState *s, EventNotifier *n, int virq)
            false);
 }
 
            false);
 }
 

-static int kvm_irqchip_create(KVMState *s)
+static int kvm_irqchip_create(MachineState *machine, KVMState *s)

 {
     int ret;
 
 {
     int ret;
 

-    if (!qemu_opt_get_bool(qemu_get_machine_opts(), "kernel_irqchip", true) ||
+    if (!machine_kernel_irqchip_allowed(machine) ||

         (!kvm_check_extension(s, KVM_CAP_IRQCHIP) &&
          (kvm_vm_enable_cap(s, KVM_CAP_S390_IRQCHIP, 0) < 0))) {
         return 0;
         (!kvm_check_extension(s, KVM_CAP_IRQCHIP) &&
          (kvm_vm_enable_cap(s, KVM_CAP_S390_IRQCHIP, 0) < 0))) {
         return 0;


@@ -1368,8 +1432,9 @@ static int kvm_max_vcpus(KVMState *s)
     return (ret) ? ret : kvm_recommended_vcpus(s);
 }
 
     return (ret) ? ret : kvm_recommended_vcpus(s);
 }
 

-int kvm_init(MachineClass *mc)
+static int kvm_init(MachineState *ms)

 {
 {

+    MachineClass *mc = MACHINE_GET_CLASS(ms);

     static const char upgrade_note[] =
         "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
         "(see http://sourceforge.net/projects/kvm).\n";
     static const char upgrade_note[] =
         "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
         "(see http://sourceforge.net/projects/kvm).\n";


@@ -1388,7 +1453,7 @@ int kvm_init(MachineClass *mc)
     int i, type = 0;
     const char *kvm_type;
 
     int i, type = 0;
     const char *kvm_type;
 

-    s = g_malloc0(sizeof(KVMState));
+    s = KVM_STATE(ms->accelerator);

 
     /*
      * On systems where the kernel can support different base page
 
     /*
      * On systems where the kernel can support different base page


@@ -1548,12 +1613,21 @@ int kvm_init(MachineClass *mc)
     kvm_eventfds_allowed =
         (kvm_check_extension(s, KVM_CAP_IOEVENTFD) > 0);
 
     kvm_eventfds_allowed =
         (kvm_check_extension(s, KVM_CAP_IOEVENTFD) > 0);
 

-    ret = kvm_arch_init(s);
+    kvm_irqfds_allowed =
+        (kvm_check_extension(s, KVM_CAP_IRQFD) > 0);
+
+    kvm_resamplefds_allowed =
+        (kvm_check_extension(s, KVM_CAP_IRQFD_RESAMPLE) > 0);
+
+    kvm_vm_attributes_allowed =
+        (kvm_check_extension(s, KVM_CAP_VM_ATTRIBUTES) > 0);
+
+    ret = kvm_arch_init(ms, s);

     if (ret < 0) {
         goto err;
     }
 
     if (ret < 0) {
         goto err;
     }
 

-    ret = kvm_irqchip_create(s);
+    ret = kvm_irqchip_create(ms, s);

     if (ret < 0) {
         goto err;
     }
     if (ret < 0) {
         goto err;
     }


@@ -1577,7 +1651,6 @@ err:
         close(s->fd);
     }
     g_free(s->slots);
         close(s->fd);
     }
     g_free(s->slots);

-    g_free(s);

 
     return ret;
 }
 
     return ret;
 }


@@ -1669,18 +1742,37 @@ void kvm_cpu_synchronize_state(CPUState *cpu)
     }
 }
 
     }
 }
 

-void kvm_cpu_synchronize_post_reset(CPUState *cpu)
+static void do_kvm_cpu_synchronize_post_reset(void *arg)

 {
 {

+    CPUState *cpu = arg;
+

     kvm_arch_put_registers(cpu, KVM_PUT_RESET_STATE);
     cpu->kvm_vcpu_dirty = false;
 }
 
     kvm_arch_put_registers(cpu, KVM_PUT_RESET_STATE);
     cpu->kvm_vcpu_dirty = false;
 }
 

-void kvm_cpu_synchronize_post_init(CPUState *cpu)
+void kvm_cpu_synchronize_post_reset(CPUState *cpu)

 {
 {

+    run_on_cpu(cpu, do_kvm_cpu_synchronize_post_reset, cpu);
+}
+
+static void do_kvm_cpu_synchronize_post_init(void *arg)
+{
+    CPUState *cpu = arg;
+

     kvm_arch_put_registers(cpu, KVM_PUT_FULL_STATE);
     cpu->kvm_vcpu_dirty = false;
 }
 
     kvm_arch_put_registers(cpu, KVM_PUT_FULL_STATE);
     cpu->kvm_vcpu_dirty = false;
 }
 

+void kvm_cpu_synchronize_post_init(CPUState *cpu)
+{
+    run_on_cpu(cpu, do_kvm_cpu_synchronize_post_init, cpu);
+}
+
+void kvm_cpu_clean_state(CPUState *cpu)
+{
+    cpu->kvm_vcpu_dirty = false;
+}
+

 int kvm_cpu_exec(CPUState *cpu)
 {
     struct kvm_run *run = cpu->kvm_run;
 int kvm_cpu_exec(CPUState *cpu)
 {
     struct kvm_run *run = cpu->kvm_run;


@@ -1724,7 +1816,8 @@ int kvm_cpu_exec(CPUState *cpu)
             }
             fprintf(stderr, "error: kvm run failed %s\n",
                     strerror(-run_ret));
             }
             fprintf(stderr, "error: kvm run failed %s\n",
                     strerror(-run_ret));

-            abort();
+            ret = -1;
+            break;

         }
 
         trace_kvm_run_exit(cpu->cpu_index, run->exit_reason);
         }
 
         trace_kvm_run_exit(cpu->cpu_index, run->exit_reason);


@@ -1867,6 +1960,23 @@ int kvm_device_ioctl(int fd, int type, ...)
     return ret;
 }
 
     return ret;
 }
 

+int kvm_vm_check_attr(KVMState *s, uint32_t group, uint64_t attr)
+{
+    int ret;
+    struct kvm_device_attr attribute = {
+        .group = group,
+        .attr = attr,
+    };
+
+    if (!kvm_vm_attributes_allowed) {
+        return 0;
+    }
+
+    ret = kvm_vm_ioctl(s, KVM_HAS_DEVICE_ATTR, &attribute);
+    /* kvm returns 0 on success for HAS_DEVICE_ATTR */
+    return ret ? 0 : 1;
+}
+

 int kvm_has_sync_mmu(void)
 {
     return kvm_check_extension(kvm_state, KVM_CAP_SYNC_MMU);
 int kvm_has_sync_mmu(void)
 {
     return kvm_check_extension(kvm_state, KVM_CAP_SYNC_MMU);


@@ -1926,9 +2036,6 @@ int kvm_has_intx_set_mask(void)
 
 void kvm_setup_guest_memory(void *start, size_t size)
 {
 
 void kvm_setup_guest_memory(void *start, size_t size)
 {

-#ifdef CONFIG_VALGRIND_H
-    VALGRIND_MAKE_MEM_DEFINED(start, size);
-#endif

     if (!kvm_has_sync_mmu()) {
         int ret = qemu_madvise(start, size, QEMU_MADV_DONTFORK);
 
     if (!kvm_has_sync_mmu()) {
         int ret = qemu_madvise(start, size, QEMU_MADV_DONTFORK);
 


@@ -2004,10 +2111,6 @@ int kvm_insert_breakpoint(CPUState *cpu, target_ulong addr,
         }
 
         bp = g_malloc(sizeof(struct kvm_sw_breakpoint));
         }
 
         bp = g_malloc(sizeof(struct kvm_sw_breakpoint));

-        if (!bp) {
-            return -ENOMEM;
-        }
-

         bp->pc = addr;
         bp->use_count = 1;
         err = kvm_arch_insert_sw_breakpoint(cpu, bp);
         bp->pc = addr;
         bp->use_count = 1;
         err = kvm_arch_insert_sw_breakpoint(cpu, bp);


@@ -2199,3 +2302,25 @@ int kvm_get_one_reg(CPUState *cs, uint64_t id, void *target)
     }
     return r;
 }
     }
     return r;
 }

+
+static void kvm_accel_class_init(ObjectClass *oc, void *data)
+{
+    AccelClass *ac = ACCEL_CLASS(oc);
+    ac->name = "KVM";
+    ac->init_machine = kvm_init;
+    ac->allowed = &kvm_allowed;
+}
+
+static const TypeInfo kvm_accel_type = {
+    .name = TYPE_KVM_ACCEL,
+    .parent = TYPE_ACCEL,
+    .class_init = kvm_accel_class_init,
+    .instance_size = sizeof(KVMState),
+};
+
+static void kvm_type_init(void)
+{
+    type_register_static(&kvm_accel_type);
+}
+
+type_init(kvm_type_init);