← Back to branch summary

~ubuntu-branches/ubuntu/natty/qemu-linaro/natty

« back to all changes in this revision

Viewing changes to kvm-all.c

  • Committer: Package Import Robot
  • Author(s): Steve Langasek, Loïc Minier, Steve Langasek
  • Date: 2011-03-07 22:55:03 UTC
  • Revision ID: package-import@ubuntu.com-20110307225503-3opjapw0ksg7glo6
[ Loïc Minier ]
* Also pass -fno-var-tracking on armhf.

[ Steve Langasek ]
* New upstream release.
* Build with -marm on armel/armhf; Peter Maydell reports that building for
  Thumb-2 gives an emulator that doesn't work.
* Add support for cross-compiling the package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
kvm-all.c
63
63
    int fd;
64
64
    int vmfd;
65
65
    int coalesced_mmio;
66
 
#ifdef KVM_CAP_COALESCED_MMIO
67
66
    struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
68
 
#endif
69
67
    int broken_set_mem_region;
70
68
    int migration_log;
71
69
    int vcpu_events;
80
78
    int many_ioeventfds;
81
79
};
82
80
 
83
 
static KVMState *kvm_state;
 
81
KVMState *kvm_state;
 
82
 
 
83
static const KVMCapabilityInfo kvm_required_capabilites[] = {
 
84
    KVM_CAP_INFO(USER_MEMORY),
 
85
    KVM_CAP_INFO(DESTROY_MEMORY_REGION_WORKS),
 
86
    KVM_CAP_LAST_INFO
 
87
};
84
88
 
85
89
static KVMSlot *kvm_alloc_slot(KVMState *s)
86
90
{
87
91
    int i;
88
92
 
89
93
    for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
90
 
        /* KVM private memory slots */
91
 
        if (i >= 8 && i < 12)
92
 
            continue;
93
 
        if (s->slots[i].memory_size == 0)
 
94
        if (s->slots[i].memory_size == 0) {
94
95
            return &s->slots[i];
 
96
        }
95
97
    }
96
98
 
97
99
    fprintf(stderr, "%s: no free slot available\n", __func__);
193
195
    return kvm_state->pit_in_kernel;
194
196
}
195
197
 
196
 
 
197
198
int kvm_init_vcpu(CPUState *env)
198
199
{
199
200
    KVMState *s = kvm_state;
213
214
 
214
215
    mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
215
216
    if (mmap_size < 0) {
 
217
        ret = mmap_size;
216
218
        DPRINTF("KVM_GET_VCPU_MMAP_SIZE failed\n");
217
219
        goto err;
218
220
    }
225
227
        goto err;
226
228
    }
227
229
 
228
 
#ifdef KVM_CAP_COALESCED_MMIO
229
 
    if (s->coalesced_mmio && !s->coalesced_mmio_ring)
230
 
        s->coalesced_mmio_ring = (void *) env->kvm_run +
231
 
                s->coalesced_mmio * PAGE_SIZE;
232
 
#endif
 
230
    if (s->coalesced_mmio && !s->coalesced_mmio_ring) {
 
231
        s->coalesced_mmio_ring =
 
232
            (void *)env->kvm_run + s->coalesced_mmio * PAGE_SIZE;
 
233
    }
233
234
 
234
235
    ret = kvm_arch_init_vcpu(env);
235
236
    if (ret == 0) {
273
274
    return kvm_set_user_memory_region(s, mem);
274
275
}
275
276
 
276
 
int kvm_log_start(target_phys_addr_t phys_addr, ram_addr_t size)
 
277
static int kvm_log_start(CPUPhysMemoryClient *client,
 
278
                         target_phys_addr_t phys_addr, ram_addr_t size)
277
279
{
278
 
        return kvm_dirty_pages_log_change(phys_addr, size,
279
 
                                          KVM_MEM_LOG_DIRTY_PAGES,
280
 
                                          KVM_MEM_LOG_DIRTY_PAGES);
 
280
    return kvm_dirty_pages_log_change(phys_addr, size, KVM_MEM_LOG_DIRTY_PAGES,
 
281
                                      KVM_MEM_LOG_DIRTY_PAGES);
281
282
}
282
283
 
283
 
int kvm_log_stop(target_phys_addr_t phys_addr, ram_addr_t size)
 
284
static int kvm_log_stop(CPUPhysMemoryClient *client,
 
285
                        target_phys_addr_t phys_addr, ram_addr_t size)
284
286
{
285
 
        return kvm_dirty_pages_log_change(phys_addr, size,
286
 
                                          0,
287
 
                                          KVM_MEM_LOG_DIRTY_PAGES);
 
287
    return kvm_dirty_pages_log_change(phys_addr, size, 0,
 
288
                                      KVM_MEM_LOG_DIRTY_PAGES);
288
289
}
289
290
 
290
291
static int kvm_set_migration_log(int enable)
356
357
 * @end_addr: end of logged region.
357
358
 */
358
359
static int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
359
 
                                          target_phys_addr_t end_addr)
 
360
                                          target_phys_addr_t end_addr)
360
361
{
361
362
    KVMState *s = kvm_state;
362
363
    unsigned long size, allocated_size = 0;
400
401
int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
401
402
{
402
403
    int ret = -ENOSYS;
403
 
#ifdef KVM_CAP_COALESCED_MMIO
404
404
    KVMState *s = kvm_state;
405
405
 
406
406
    if (s->coalesced_mmio) {
411
411
 
412
412
        ret = kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
413
413
    }
414
 
#endif
415
414
 
416
415
    return ret;
417
416
}
419
418
int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
420
419
{
421
420
    int ret = -ENOSYS;
422
 
#ifdef KVM_CAP_COALESCED_MMIO
423
421
    KVMState *s = kvm_state;
424
422
 
425
423
    if (s->coalesced_mmio) {
430
428
 
431
429
        ret = kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
432
430
    }
433
 
#endif
434
431
 
435
432
    return ret;
436
433
}
449
446
 
450
447
static int kvm_check_many_ioeventfds(void)
451
448
{
452
 
    /* Older kernels have a 6 device limit on the KVM io bus.  Find out so we
 
449
    /* Userspace can use ioeventfd for io notification.  This requires a host
 
450
     * that supports eventfd(2) and an I/O thread; since eventfd does not
 
451
     * support SIGIO it cannot interrupt the vcpu.
 
452
     *
 
453
     * Older kernels have a 6 device limit on the KVM io bus.  Find out so we
453
454
     * can avoid creating too many ioeventfds.
454
455
     */
455
 
#ifdef CONFIG_EVENTFD
 
456
#if defined(CONFIG_EVENTFD) && defined(CONFIG_IOTHREAD)
456
457
    int ioeventfds[7];
457
458
    int i, ret = 0;
458
459
    for (i = 0; i < ARRAY_SIZE(ioeventfds); i++) {
480
481
#endif
481
482
}
482
483
 
483
 
static void kvm_set_phys_mem(target_phys_addr_t start_addr,
484
 
                             ram_addr_t size,
485
 
                             ram_addr_t phys_offset)
 
484
static const KVMCapabilityInfo *
 
485
kvm_check_extension_list(KVMState *s, const KVMCapabilityInfo *list)
 
486
{
 
487
    while (list->name) {
 
488
        if (!kvm_check_extension(s, list->value)) {
 
489
            return list;
 
490
        }
 
491
        list++;
 
492
    }
 
493
    return NULL;
 
494
}
 
495
 
 
496
static void kvm_set_phys_mem(target_phys_addr_t start_addr, ram_addr_t size,
 
497
                             ram_addr_t phys_offset)
486
498
{
487
499
    KVMState *s = kvm_state;
488
500
    ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
589
601
    }
590
602
 
591
603
    /* in case the KVM bug workaround already "consumed" the new slot */
592
 
    if (!size)
 
604
    if (!size) {
593
605
        return;
594
 
 
 
606
    }
595
607
    /* KVM does not need to know about this memory */
596
 
    if (flags >= IO_MEM_UNASSIGNED)
 
608
    if (flags >= IO_MEM_UNASSIGNED) {
597
609
        return;
598
 
 
 
610
    }
599
611
    mem = kvm_alloc_slot(s);
600
612
    mem->memory_size = size;
601
613
    mem->start_addr = start_addr;
611
623
}
612
624
 
613
625
static void kvm_client_set_memory(struct CPUPhysMemoryClient *client,
614
 
                                  target_phys_addr_t start_addr,
615
 
                                  ram_addr_t size,
616
 
                                  ram_addr_t phys_offset)
 
626
                                  target_phys_addr_t start_addr,
 
627
                                  ram_addr_t size, ram_addr_t phys_offset)
617
628
{
618
 
        kvm_set_phys_mem(start_addr, size, phys_offset);
 
629
    kvm_set_phys_mem(start_addr, size, phys_offset);
619
630
}
620
631
 
621
632
static int kvm_client_sync_dirty_bitmap(struct CPUPhysMemoryClient *client,
622
 
                                        target_phys_addr_t start_addr,
623
 
                                        target_phys_addr_t end_addr)
 
633
                                        target_phys_addr_t start_addr,
 
634
                                        target_phys_addr_t end_addr)
624
635
{
625
 
        return kvm_physical_sync_dirty_bitmap(start_addr, end_addr);
 
636
    return kvm_physical_sync_dirty_bitmap(start_addr, end_addr);
626
637
}
627
638
 
628
639
static int kvm_client_migration_log(struct CPUPhysMemoryClient *client,
629
 
                                    int enable)
 
640
                                    int enable)
630
641
{
631
 
        return kvm_set_migration_log(enable);
 
642
    return kvm_set_migration_log(enable);
632
643
}
633
644
 
634
645
static CPUPhysMemoryClient kvm_cpu_phys_memory_client = {
635
 
        .set_memory = kvm_client_set_memory,
636
 
        .sync_dirty_bitmap = kvm_client_sync_dirty_bitmap,
637
 
        .migration_log = kvm_client_migration_log,
 
646
    .set_memory = kvm_client_set_memory,
 
647
    .sync_dirty_bitmap = kvm_client_sync_dirty_bitmap,
 
648
    .migration_log = kvm_client_migration_log,
 
649
    .log_start = kvm_log_start,
 
650
    .log_stop = kvm_log_stop,
638
651
};
639
652
 
640
 
int kvm_init(int smp_cpus)
 
653
int kvm_init(void)
641
654
{
642
655
    static const char upgrade_note[] =
643
656
        "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
644
657
        "(see http://sourceforge.net/projects/kvm).\n";
645
658
    KVMState *s;
 
659
    const KVMCapabilityInfo *missing_cap;
646
660
    int ret;
647
661
    int i;
648
662
 
651
665
#ifdef KVM_CAP_SET_GUEST_DEBUG
652
666
    QTAILQ_INIT(&s->kvm_sw_breakpoints);
653
667
#endif
654
 
    for (i = 0; i < ARRAY_SIZE(s->slots); i++)
 
668
    for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
655
669
        s->slots[i].slot = i;
656
 
 
 
670
    }
657
671
    s->vmfd = -1;
658
672
    s->fd = qemu_open("/dev/kvm", O_RDWR);
659
673
    if (s->fd == -1) {
664
678
 
665
679
    ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
666
680
    if (ret < KVM_API_VERSION) {
667
 
        if (ret > 0)
 
681
        if (ret > 0) {
668
682
            ret = -EINVAL;
 
683
        }
669
684
        fprintf(stderr, "kvm version too old\n");
670
685
        goto err;
671
686
    }
685
700
        goto err;
686
701
    }
687
702
 
688
 
    /* initially, KVM allocated its own memory and we had to jump through
689
 
     * hooks to make phys_ram_base point to this.  Modern versions of KVM
690
 
     * just use a user allocated buffer so we can use regular pages
691
 
     * unmodified.  Make sure we have a sufficiently modern version of KVM.
692
 
     */
693
 
    if (!kvm_check_extension(s, KVM_CAP_USER_MEMORY)) {
694
 
        ret = -EINVAL;
695
 
        fprintf(stderr, "kvm does not support KVM_CAP_USER_MEMORY\n%s",
696
 
                upgrade_note);
697
 
        goto err;
698
 
    }
699
 
 
700
 
    /* There was a nasty bug in < kvm-80 that prevents memory slots from being
701
 
     * destroyed properly.  Since we rely on this capability, refuse to work
702
 
     * with any kernel without this capability. */
703
 
    if (!kvm_check_extension(s, KVM_CAP_DESTROY_MEMORY_REGION_WORKS)) {
704
 
        ret = -EINVAL;
705
 
 
706
 
        fprintf(stderr,
707
 
                "KVM kernel module broken (DESTROY_MEMORY_REGION).\n%s",
708
 
                upgrade_note);
709
 
        goto err;
710
 
    }
711
 
 
712
 
    s->coalesced_mmio = 0;
713
 
#ifdef KVM_CAP_COALESCED_MMIO
 
703
    missing_cap = kvm_check_extension_list(s, kvm_required_capabilites);
 
704
    if (!missing_cap) {
 
705
        missing_cap =
 
706
            kvm_check_extension_list(s, kvm_arch_required_capabilities);
 
707
    }
 
708
    if (missing_cap) {
 
709
        ret = -EINVAL;
 
710
        fprintf(stderr, "kvm does not support %s\n%s",
 
711
                missing_cap->name, upgrade_note);
 
712
        goto err;
 
713
    }
 
714
 
714
715
    s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
715
 
    s->coalesced_mmio_ring = NULL;
716
 
#endif
717
716
 
718
717
    s->broken_set_mem_region = 1;
719
718
#ifdef KVM_CAP_JOIN_MEMORY_REGIONS_WORKS
720
 
    ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
 
719
    ret = kvm_check_extension(s, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
721
720
    if (ret > 0) {
722
721
        s->broken_set_mem_region = 0;
723
722
    }
749
748
    s->xcrs = kvm_check_extension(s, KVM_CAP_XCRS);
750
749
#endif
751
750
 
752
 
    ret = kvm_arch_init(s, smp_cpus);
753
 
    if (ret < 0)
 
751
    ret = kvm_arch_init(s);
 
752
    if (ret < 0) {
754
753
        goto err;
 
754
    }
755
755
 
756
756
    kvm_state = s;
757
757
    cpu_register_phys_memory_client(&kvm_cpu_phys_memory_client);
762
762
 
763
763
err:
764
764
    if (s) {
765
 
        if (s->vmfd != -1)
 
765
        if (s->vmfd != -1) {
766
766
            close(s->vmfd);
767
 
        if (s->fd != -1)
 
767
        }
 
768
        if (s->fd != -1) {
768
769
            close(s->fd);
 
770
        }
769
771
    }
770
772
    qemu_free(s);
771
773
 
772
774
    return ret;
773
775
}
774
776
 
775
 
static int kvm_handle_io(uint16_t port, void *data, int direction, int size,
776
 
                         uint32_t count)
 
777
static void kvm_handle_io(uint16_t port, void *data, int direction, int size,
 
778
                          uint32_t count)
777
779
{
778
780
    int i;
779
781
    uint8_t *ptr = data;
807
809
 
808
810
        ptr += size;
809
811
    }
810
 
 
811
 
    return 1;
812
812
}
813
813
 
814
814
#ifdef KVM_CAP_INTERNAL_ERROR_DATA
815
 
static void kvm_handle_internal_error(CPUState *env, struct kvm_run *run)
 
815
static int kvm_handle_internal_error(CPUState *env, struct kvm_run *run)
816
816
{
817
 
 
 
817
    fprintf(stderr, "KVM internal error.");
818
818
    if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) {
819
819
        int i;
820
820
 
821
 
        fprintf(stderr, "KVM internal error. Suberror: %d\n",
822
 
                run->internal.suberror);
823
 
 
 
821
        fprintf(stderr, " Suberror: %d\n", run->internal.suberror);
824
822
        for (i = 0; i < run->internal.ndata; ++i) {
825
823
            fprintf(stderr, "extra data[%d]: %"PRIx64"\n",
826
824
                    i, (uint64_t)run->internal.data[i]);
827
825
        }
 
826
    } else {
 
827
        fprintf(stderr, "\n");
828
828
    }
829
 
    cpu_dump_state(env, stderr, fprintf, 0);
830
829
    if (run->internal.suberror == KVM_INTERNAL_ERROR_EMULATION) {
831
830
        fprintf(stderr, "emulation failure\n");
832
 
        if (!kvm_arch_stop_on_emulation_error(env))
833
 
                return;
 
831
        if (!kvm_arch_stop_on_emulation_error(env)) {
 
832
            cpu_dump_state(env, stderr, fprintf, CPU_DUMP_CODE);
 
833
            return 0;
 
834
        }
834
835
    }
835
836
    /* FIXME: Should trigger a qmp message to let management know
836
837
     * something went wrong.
837
838
     */
838
 
    vm_stop(0);
 
839
    return -1;
839
840
}
840
841
#endif
841
842
 
842
843
void kvm_flush_coalesced_mmio_buffer(void)
843
844
{
844
 
#ifdef KVM_CAP_COALESCED_MMIO
845
845
    KVMState *s = kvm_state;
846
846
    if (s->coalesced_mmio_ring) {
847
847
        struct kvm_coalesced_mmio_ring *ring = s->coalesced_mmio_ring;
855
855
            ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
856
856
        }
857
857
    }
858
 
#endif
859
858
}
860
859
 
861
860
static void do_kvm_cpu_synchronize_state(void *_env)
870
869
 
871
870
void kvm_cpu_synchronize_state(CPUState *env)
872
871
{
873
 
    if (!env->kvm_vcpu_dirty)
 
872
    if (!env->kvm_vcpu_dirty) {
874
873
        run_on_cpu(env, do_kvm_cpu_synchronize_state, env);
 
874
    }
875
875
}
876
876
 
877
877
void kvm_cpu_synchronize_post_reset(CPUState *env)
893
893
 
894
894
    DPRINTF("kvm_cpu_exec()\n");
895
895
 
 
896
    if (kvm_arch_process_irqchip_events(env)) {
 
897
        env->exit_request = 0;
 
898
        return EXCP_HLT;
 
899
    }
 
900
 
 
901
    cpu_single_env = env;
 
902
 
896
903
    do {
897
 
#ifndef CONFIG_IOTHREAD
898
 
        if (env->exit_request) {
899
 
            DPRINTF("interrupt exit requested\n");
900
 
            ret = 0;
901
 
            break;
902
 
        }
903
 
#endif
904
 
 
905
 
        if (kvm_arch_process_irqchip_events(env)) {
906
 
            ret = 0;
907
 
            break;
908
 
        }
909
 
 
910
904
        if (env->kvm_vcpu_dirty) {
911
905
            kvm_arch_put_registers(env, KVM_PUT_RUNTIME_STATE);
912
906
            env->kvm_vcpu_dirty = 0;
913
907
        }
914
908
 
915
909
        kvm_arch_pre_run(env, run);
 
910
        if (env->exit_request) {
 
911
            DPRINTF("interrupt exit requested\n");
 
912
            /*
 
913
             * KVM requires us to reenter the kernel after IO exits to complete
 
914
             * instruction emulation. This self-signal will ensure that we
 
915
             * leave ASAP again.
 
916
             */
 
917
            qemu_cpu_kick_self();
 
918
        }
916
919
        cpu_single_env = NULL;
917
920
        qemu_mutex_unlock_iothread();
 
921
 
918
922
        ret = kvm_vcpu_ioctl(env, KVM_RUN, 0);
 
923
 
919
924
        qemu_mutex_lock_iothread();
920
925
        cpu_single_env = env;
921
926
        kvm_arch_post_run(env, run);
922
927
 
 
928
        kvm_flush_coalesced_mmio_buffer();
 
929
 
923
930
        if (ret == -EINTR || ret == -EAGAIN) {
924
 
            cpu_exit(env);
925
931
            DPRINTF("io window exit\n");
926
932
            ret = 0;
927
933
            break;
932
938
            abort();
933
939
        }
934
940
 
935
 
        kvm_flush_coalesced_mmio_buffer();
936
 
 
937
941
        ret = 0; /* exit loop */
938
942
        switch (run->exit_reason) {
939
943
        case KVM_EXIT_IO:
940
944
            DPRINTF("handle_io\n");
941
 
            ret = kvm_handle_io(run->io.port,
942
 
                                (uint8_t *)run + run->io.data_offset,
943
 
                                run->io.direction,
944
 
                                run->io.size,
945
 
                                run->io.count);
 
945
            kvm_handle_io(run->io.port,
 
946
                          (uint8_t *)run + run->io.data_offset,
 
947
                          run->io.direction,
 
948
                          run->io.size,
 
949
                          run->io.count);
 
950
            ret = 1;
946
951
            break;
947
952
        case KVM_EXIT_MMIO:
948
953
            DPRINTF("handle_mmio\n");
958
963
        case KVM_EXIT_SHUTDOWN:
959
964
            DPRINTF("shutdown\n");
960
965
            qemu_system_reset_request();
961
 
            ret = 1;
962
966
            break;
963
967
        case KVM_EXIT_UNKNOWN:
964
 
            DPRINTF("kvm_exit_unknown\n");
965
 
            break;
966
 
        case KVM_EXIT_FAIL_ENTRY:
967
 
            DPRINTF("kvm_exit_fail_entry\n");
968
 
            break;
969
 
        case KVM_EXIT_EXCEPTION:
970
 
            DPRINTF("kvm_exit_exception\n");
 
968
            fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
 
969
                    (uint64_t)run->hw.hardware_exit_reason);
 
970
            ret = -1;
971
971
            break;
972
972
#ifdef KVM_CAP_INTERNAL_ERROR_DATA
973
973
        case KVM_EXIT_INTERNAL_ERROR:
974
 
            kvm_handle_internal_error(env, run);
 
974
            ret = kvm_handle_internal_error(env, run);
975
975
            break;
976
976
#endif
977
977
        case KVM_EXIT_DEBUG:
978
978
            DPRINTF("kvm_exit_debug\n");
979
979
#ifdef KVM_CAP_SET_GUEST_DEBUG
980
980
            if (kvm_arch_debug(&run->debug.arch)) {
981
 
                env->exception_index = EXCP_DEBUG;
982
 
                return 0;
 
981
                ret = EXCP_DEBUG;
 
982
                goto out;
983
983
            }
984
984
            /* re-enter, this exception was guest-internal */
985
985
            ret = 1;
992
992
        }
993
993
    } while (ret > 0);
994
994
 
995
 
    if (env->exit_request) {
996
 
        env->exit_request = 0;
997
 
        env->exception_index = EXCP_INTERRUPT;
 
995
    if (ret < 0) {
 
996
        cpu_dump_state(env, stderr, fprintf, CPU_DUMP_CODE);
 
997
        vm_stop(VMSTOP_PANIC);
998
998
    }
 
999
    ret = EXCP_INTERRUPT;
999
1000
 
 
1001
out:
 
1002
    env->exit_request = 0;
 
1003
    cpu_single_env = NULL;
1000
1004
    return ret;
1001
1005
}
1002
1006
 
1011
1015
    va_end(ap);
1012
1016
 
1013
1017
    ret = ioctl(s->fd, type, arg);
1014
 
    if (ret == -1)
 
1018
    if (ret == -1) {
1015
1019
        ret = -errno;
1016
 
 
 
1020
    }
1017
1021
    return ret;
1018
1022
}
1019
1023
 
1028
1032
    va_end(ap);
1029
1033
 
1030
1034
    ret = ioctl(s->vmfd, type, arg);
1031
 
    if (ret == -1)
 
1035
    if (ret == -1) {
1032
1036
        ret = -errno;
1033
 
 
 
1037
    }
1034
1038
    return ret;
1035
1039
}
1036
1040
 
1045
1049
    va_end(ap);
1046
1050
 
1047
1051
    ret = ioctl(env->kvm_fd, type, arg);
1048
 
    if (ret == -1)
 
1052
    if (ret == -1) {
1049
1053
        ret = -errno;
1050
 
 
 
1054
    }
1051
1055
    return ret;
1052
1056
}
1053
1057
 
1054
1058
int kvm_has_sync_mmu(void)
1055
1059
{
1056
 
#ifdef KVM_CAP_SYNC_MMU
1057
 
    KVMState *s = kvm_state;
1058
 
 
1059
 
    return kvm_check_extension(s, KVM_CAP_SYNC_MMU);
1060
 
#else
1061
 
    return 0;
1062
 
#endif
 
1060
    return kvm_check_extension(kvm_state, KVM_CAP_SYNC_MMU);
1063
1061
}
1064
1062
 
1065
1063
int kvm_has_vcpu_events(void)
1116
1114
    struct kvm_sw_breakpoint *bp;
1117
1115
 
1118
1116
    QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) {
1119
 
        if (bp->pc == pc)
 
1117
        if (bp->pc == pc) {
1120
1118
            return bp;
 
1119
        }
1121
1120
    }
1122
1121
    return NULL;
1123
1122
}
1172
1171
        }
1173
1172
 
1174
1173
        bp = qemu_malloc(sizeof(struct kvm_sw_breakpoint));
1175
 
        if (!bp)
 
1174
        if (!bp) {
1176
1175
            return -ENOMEM;
 
1176
        }
1177
1177
 
1178
1178
        bp->pc = addr;
1179
1179
        bp->use_count = 1;
1187
1187
                          bp, entry);
1188
1188
    } else {
1189
1189
        err = kvm_arch_insert_hw_breakpoint(addr, len, type);
1190
 
        if (err)
 
1190
        if (err) {
1191
1191
            return err;
 
1192
        }
1192
1193
    }
1193
1194
 
1194
1195
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
1195
1196
        err = kvm_update_guest_debug(env, 0);
1196
 
        if (err)
 
1197
        if (err) {
1197
1198
            return err;
 
1199
        }
1198
1200
    }
1199
1201
    return 0;
1200
1202
}
1208
1210
 
1209
1211
    if (type == GDB_BREAKPOINT_SW) {
1210
1212
        bp = kvm_find_sw_breakpoint(current_env, addr);
1211
 
        if (!bp)
 
1213
        if (!bp) {
1212
1214
            return -ENOENT;
 
1215
        }
1213
1216
 
1214
1217
        if (bp->use_count > 1) {
1215
1218
            bp->use_count--;
1217
1220
        }
1218
1221
 
1219
1222
        err = kvm_arch_remove_sw_breakpoint(current_env, bp);
1220
 
        if (err)
 
1223
        if (err) {
1221
1224
            return err;
 
1225
        }
1222
1226
 
1223
1227
        QTAILQ_REMOVE(&current_env->kvm_state->kvm_sw_breakpoints, bp, entry);
1224
1228
        qemu_free(bp);
1225
1229
    } else {
1226
1230
        err = kvm_arch_remove_hw_breakpoint(addr, len, type);
1227
 
        if (err)
 
1231
        if (err) {
1228
1232
            return err;
 
1233
        }
1229
1234
    }
1230
1235
 
1231
1236
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
1232
1237
        err = kvm_update_guest_debug(env, 0);
1233
 
        if (err)
 
1238
        if (err) {
1234
1239
            return err;
 
1240
        }
1235
1241
    }
1236
1242
    return 0;
1237
1243
}
1246
1252
        if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
1247
1253
            /* Try harder to find a CPU that currently sees the breakpoint. */
1248
1254
            for (env = first_cpu; env != NULL; env = env->next_cpu) {
1249
 
                if (kvm_arch_remove_sw_breakpoint(env, bp) == 0)
 
1255
                if (kvm_arch_remove_sw_breakpoint(env, bp) == 0) {
1250
1256
                    break;
 
1257
                }
1251
1258
            }
1252
1259
        }
1253
1260
    }
1254
1261
    kvm_arch_remove_all_hw_breakpoints();
1255
1262
 
1256
 
    for (env = first_cpu; env != NULL; env = env->next_cpu)
 
1263
    for (env = first_cpu; env != NULL; env = env->next_cpu) {
1257
1264
        kvm_update_guest_debug(env, 0);
 
1265
    }
1258
1266
}
1259
1267
 
1260
1268
#else /* !KVM_CAP_SET_GUEST_DEBUG */
1286
1294
    struct kvm_signal_mask *sigmask;
1287
1295
    int r;
1288
1296
 
1289
 
    if (!sigset)
 
1297
    if (!sigset) {
1290
1298
        return kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, NULL);
 
1299
    }
1291
1300
 
1292
1301
    sigmask = qemu_malloc(sizeof(*sigmask) + sizeof(*sigset));
1293
1302
 
1342
1351
        .fd = fd,
1343
1352
    };
1344
1353
    int r;
1345
 
    if (!kvm_enabled())
 
1354
    if (!kvm_enabled()) {
1346
1355
        return -ENOSYS;
1347
 
    if (!assign)
 
1356
    }
 
1357
    if (!assign) {
1348
1358
        kick.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
 
1359
    }
1349
1360
    r = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &kick);
1350
 
    if (r < 0)
 
1361
    if (r < 0) {
1351
1362
        return r;
 
1363
    }
1352
1364
    return 0;
1353
1365
#else
1354
1366
    return -ENOSYS;
1355
1367
#endif
1356
1368
}
 
1369
 
 
1370
int kvm_on_sigbus_vcpu(CPUState *env, int code, void *addr)
 
1371
{
 
1372
    return kvm_arch_on_sigbus_vcpu(env, code, addr);
 
1373
}
 
1374
 
 
1375
int kvm_on_sigbus(int code, void *addr)
 
1376
{
 
1377
    return kvm_arch_on_sigbus(code, addr);
 
1378
}