qemu-kvm.c

   1
   2 #include "config.h"
   3 #include "config-host.h"
   4
   5 #ifdef USE_KVM
   6  #define KVM_ALLOWED_DEFAULT 1
   7 #else
   8  #define KVM_ALLOWED_DEFAULT 0
   9 #endif
  10
  11 int kvm_allowed = KVM_ALLOWED_DEFAULT;
  12 int kvm_irqchip = 1;
  13
  14 #ifdef USE_KVM
  15
  16 #include <string.h>
  17 #include "hw/hw.h"
  18 #include "sysemu.h"
  19
  20 #include "qemu-kvm.h"
  21 #include <libkvm.h>
  22 #include <pthread.h>
  23 #include <sys/utsname.h>
  24
  25 extern void perror(const char *s);
  26
  27 kvm_context_t kvm_context;
  28
  29 extern int smp_cpus;
  30
  31 pthread_mutex_t qemu_mutex = PTHREAD_MUTEX_INITIALIZER;
  32 pthread_cond_t qemu_aio_cond = PTHREAD_COND_INITIALIZER;
  33 __thread CPUState *vcpu_env;
  34
  35 static sigset_t io_sigset, io_negsigset;
  36
  37 #define SIG_IPI (SIGRTMIN+4)
  38
  39 struct vcpu_info {
  40     int sipi_needed;
  41     int init;
  42     pthread_t thread;
  43     int signalled;
  44     int stop;
  45     int stopped;
  46 } vcpu_info[4];
  47
  48 static void sig_ipi_handler(int n)
  49 {
  50 }
  51
  52 void kvm_update_interrupt_request(CPUState *env)
  53 {
  54     if (env && env != vcpu_env) {
  55         if (vcpu_info[env->cpu_index].signalled)
  56             return;
  57         vcpu_info[env->cpu_index].signalled = 1;
  58         if (vcpu_info[env->cpu_index].thread)
  59             pthread_kill(vcpu_info[env->cpu_index].thread, SIG_IPI);
  60     }
  61 }
  62
  63 void kvm_update_after_sipi(CPUState *env)
  64 {
  65     vcpu_info[env->cpu_index].sipi_needed = 1;
  66     kvm_update_interrupt_request(env);
  67 }
  68
  69 void kvm_apic_init(CPUState *env)
  70 {
  71     if (env->cpu_index != 0)
  72         vcpu_info[env->cpu_index].init = 1;
  73     kvm_update_interrupt_request(env);
  74 }
  75
  76 #include <signal.h>
  77
  78 static int try_push_interrupts(void *opaque)
  79 {
  80     return kvm_arch_try_push_interrupts(opaque);
  81 }
  82
  83 static void post_kvm_run(void *opaque, int vcpu)
  84 {
  85
  86     pthread_mutex_lock(&qemu_mutex);
  87     kvm_arch_post_kvm_run(opaque, vcpu);
  88 }
  89
  90 static int pre_kvm_run(void *opaque, int vcpu)
  91 {
  92     CPUState *env = cpu_single_env;
  93
  94     kvm_arch_pre_kvm_run(opaque, vcpu);
  95
  96     if (env->interrupt_request & CPU_INTERRUPT_EXIT)
  97         return 1;
  98     pthread_mutex_unlock(&qemu_mutex);
  99     return 0;
 100 }
 101
 102 void kvm_load_registers(CPUState *env)
 103 {
 104     if (kvm_allowed)
 105         kvm_arch_load_regs(env);
 106 }
 107
 108 void kvm_save_registers(CPUState *env)
 109 {
 110     if (kvm_allowed)
 111         kvm_arch_save_regs(env);
 112 }
 113
 114 int kvm_cpu_exec(CPUState *env)
 115 {
 116     int r;
 117
 118     r = kvm_run(kvm_context, env->cpu_index);
 119     if (r < 0) {
 120         printf("kvm_run returned %d\n", r);
 121         exit(1);
 122     }
 123
 124     return 0;
 125 }
 126
 127 extern int vm_running;
 128
 129 static int has_work(CPUState *env)
 130 {
 131     if (!vm_running)
 132         return 0;
 133     if (!(env->hflags & HF_HALTED_MASK))
 134         return 1;
 135     return kvm_arch_has_work(env);
 136 }
 137
 138 static int kvm_eat_signal(CPUState *env, int timeout)
 139 {
 140     struct timespec ts;
 141     int r, e, ret = 0;
 142     siginfo_t siginfo;
 143     struct sigaction sa;
 144
 145     ts.tv_sec = timeout / 1000;
 146     ts.tv_nsec = (timeout % 1000) * 1000000;
 147     r = sigtimedwait(&io_sigset, &siginfo, &ts);
 148     if (r == -1 && (errno == EAGAIN || errno == EINTR) && !timeout)
 149         return 0;
 150     e = errno;
 151     pthread_mutex_lock(&qemu_mutex);
 152     cpu_single_env = vcpu_env;
 153     if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
 154         printf("sigtimedwait: %s\n", strerror(e));
 155         exit(1);
 156     }
 157     if (r != -1) {
 158         sigaction(siginfo.si_signo, NULL, &sa);
 159         sa.sa_handler(siginfo.si_signo);
 160         if (siginfo.si_signo == SIGUSR2)
 161             pthread_cond_signal(&qemu_aio_cond);
 162         ret = 1;
 163     }
 164     pthread_mutex_unlock(&qemu_mutex);
 165
 166     return ret;
 167 }
 168
 169
 170 static void kvm_eat_signals(CPUState *env, int timeout)
 171 {
 172     int r = 0;
 173
 174     while (kvm_eat_signal(env, 0))
 175         r = 1;
 176     if (!r && timeout) {
 177         r = kvm_eat_signal(env, timeout);
 178         if (r)
 179             while (kvm_eat_signal(env, 0))
 180                 ;
 181     }
 182     /*
 183      * we call select() even if no signal was received, to account for
 184      * for which there is no signal handler installed.
 185      */
 186     pthread_mutex_lock(&qemu_mutex);
 187     cpu_single_env = vcpu_env;
 188     main_loop_wait(0);
 189     pthread_mutex_unlock(&qemu_mutex);
 190 }
 191
 192 static void kvm_main_loop_wait(CPUState *env, int timeout)
 193 {
 194     pthread_mutex_unlock(&qemu_mutex);
 195     if (env->cpu_index == 0)
 196         kvm_eat_signals(env, timeout);
 197     else {
 198         if (!kvm_irqchip_in_kernel(kvm_context) &&
 199             (timeout || vcpu_info[env->cpu_index].stopped)) {
 200             sigset_t set;
 201             int n;
 202
 203         paused:
 204             sigemptyset(&set);
 205             sigaddset(&set, SIG_IPI);
 206             sigwait(&set, &n);
 207         } else {
 208             struct timespec ts;
 209             siginfo_t siginfo;
 210             sigset_t set;
 211
 212             ts.tv_sec = 0;
 213             ts.tv_nsec = 0;
 214             sigemptyset(&set);
 215             sigaddset(&set, SIG_IPI);
 216             sigtimedwait(&set, &siginfo, &ts);
 217         }
 218         if (vcpu_info[env->cpu_index].stop) {
 219             vcpu_info[env->cpu_index].stop = 0;
 220             vcpu_info[env->cpu_index].stopped = 1;
 221             pthread_kill(vcpu_info[0].thread, SIG_IPI);
 222             goto paused;
 223         }
 224     }
 225     pthread_mutex_lock(&qemu_mutex);
 226     cpu_single_env = env;
 227     vcpu_info[env->cpu_index].signalled = 0;
 228 }
 229
 230 static int all_threads_paused(void)
 231 {
 232     int i;
 233
 234     for (i = 1; i < smp_cpus; ++i)
 235         if (vcpu_info[i].stopped)
 236             return 0;
 237     return 1;
 238 }
 239
 240 static void pause_other_threads(void)
 241 {
 242     int i;
 243
 244     for (i = 1; i < smp_cpus; ++i) {
 245         vcpu_info[i].stop = 1;
 246         pthread_kill(vcpu_info[i].thread, SIG_IPI);
 247     }
 248     while (!all_threads_paused())
 249         kvm_eat_signals(vcpu_env, 0);
 250 }
 251
 252 static void resume_other_threads(void)
 253 {
 254     int i;
 255
 256     for (i = 1; i < smp_cpus; ++i) {
 257         vcpu_info[i].stop = 0;
 258         vcpu_info[i].stopped = 0;
 259         pthread_kill(vcpu_info[i].thread, SIG_IPI);
 260     }
 261 }
 262
 263 static void kvm_vm_state_change_handler(void *context, int running)
 264 {
 265     if (running)
 266         resume_other_threads();
 267     else
 268         pause_other_threads();
 269 }
 270
 271 static void update_regs_for_sipi(CPUState *env)
 272 {
 273     kvm_arch_update_regs_for_sipi(env);
 274     vcpu_info[env->cpu_index].sipi_needed = 0;
 275     vcpu_info[env->cpu_index].init = 0;
 276 }
 277
 278 static void update_regs_for_init(CPUState *env)
 279 {
 280     cpu_reset(env);
 281     kvm_arch_load_regs(env);
 282 }
 283
 284 static void setup_kernel_sigmask(CPUState *env)
 285 {
 286     sigset_t set;
 287
 288     sigprocmask(SIG_BLOCK, NULL, &set);
 289     sigdelset(&set, SIG_IPI);
 290     if (env->cpu_index == 0)
 291         sigandset(&set, &set, &io_negsigset);
 292
 293     kvm_set_signal_mask(kvm_context, env->cpu_index, &set);
 294 }
 295
 296 static int kvm_main_loop_cpu(CPUState *env)
 297 {
 298     struct vcpu_info *info = &vcpu_info[env->cpu_index];
 299
 300     setup_kernel_sigmask(env);
 301     pthread_mutex_lock(&qemu_mutex);
 302
 303     kvm_qemu_init_env(env);
 304     env->ready_for_interrupt_injection = 1;
 305
 306     cpu_single_env = env;
 307 #ifdef TARGET_I386
 308     kvm_tpr_opt_setup(env);
 309 #endif
 310     while (1) {
 311         while (!has_work(env))
 312             kvm_main_loop_wait(env, 10);
 313         if (env->interrupt_request & CPU_INTERRUPT_HARD)
 314             env->hflags &= ~HF_HALTED_MASK;
 315         if (!kvm_irqchip_in_kernel(kvm_context) && info->sipi_needed)
 316             update_regs_for_sipi(env);
 317         if (!kvm_irqchip_in_kernel(kvm_context) && info->init)
 318             update_regs_for_init(env);
 319         if (!(env->hflags & HF_HALTED_MASK) && !info->init)
 320             kvm_cpu_exec(env);
 321         env->interrupt_request &= ~CPU_INTERRUPT_EXIT;
 322         kvm_main_loop_wait(env, 0);
 323         if (qemu_shutdown_requested())
 324             break;
 325         else if (qemu_powerdown_requested())
 326             qemu_system_powerdown();
 327         else if (qemu_reset_requested()) {
 328             env->interrupt_request = 0;
 329             qemu_system_reset();
 330             kvm_arch_load_regs(env);
 331         }
 332     }
 333     pthread_mutex_unlock(&qemu_mutex);
 334     return 0;
 335 }
 336
 337 static void *ap_main_loop(void *_env)
 338 {
 339     CPUState *env = _env;
 340     sigset_t signals;
 341
 342     vcpu_env = env;
 343     sigfillset(&signals);
 344     //sigdelset(&signals, SIG_IPI);
 345     sigprocmask(SIG_BLOCK, &signals, NULL);
 346     kvm_create_vcpu(kvm_context, env->cpu_index);
 347     kvm_qemu_init_env(env);
 348     if (kvm_irqchip_in_kernel(kvm_context))
 349         env->hflags &= ~HF_HALTED_MASK;
 350     kvm_main_loop_cpu(env);
 351     return NULL;
 352 }
 353
 354 static void kvm_add_signal(int signum)
 355 {
 356     sigaddset(&io_sigset, signum);
 357     sigdelset(&io_negsigset, signum);
 358     sigprocmask(SIG_BLOCK,  &io_sigset, NULL);
 359 }
 360
 361 int kvm_init_ap(void)
 362 {
 363     CPUState *env = first_cpu->next_cpu;
 364     int i;
 365
 366     qemu_add_vm_change_state_handler(kvm_vm_state_change_handler, NULL);
 367     sigemptyset(&io_sigset);
 368     sigfillset(&io_negsigset);
 369     kvm_add_signal(SIGIO);
 370     kvm_add_signal(SIGALRM);
 371     kvm_add_signal(SIGUSR2);
 372     kvm_add_signal(SIG_IPI);
 373
 374     vcpu_env = first_cpu;
 375     signal(SIG_IPI, sig_ipi_handler);
 376     for (i = 1; i < smp_cpus; ++i) {
 377         pthread_create(&vcpu_info[i].thread, NULL, ap_main_loop, env);
 378         env = env->next_cpu;
 379     }
 380     return 0;
 381 }
 382
 383 int kvm_main_loop(void)
 384 {
 385     vcpu_info[0].thread = pthread_self();
 386     pthread_mutex_unlock(&qemu_mutex);
 387     return kvm_main_loop_cpu(first_cpu);
 388 }
 389
 390 static int kvm_debug(void *opaque, int vcpu)
 391 {
 392     CPUState *env = cpu_single_env;
 393
 394     env->exception_index = EXCP_DEBUG;
 395     return 1;
 396 }
 397
 398 static int kvm_inb(void *opaque, uint16_t addr, uint8_t *data)
 399 {
 400     *data = cpu_inb(0, addr);
 401     return 0;
 402 }
 403
 404 static int kvm_inw(void *opaque, uint16_t addr, uint16_t *data)
 405 {
 406     *data = cpu_inw(0, addr);
 407     return 0;
 408 }
 409
 410 static int kvm_inl(void *opaque, uint16_t addr, uint32_t *data)
 411 {
 412     *data = cpu_inl(0, addr);
 413     return 0;
 414 }
 415
 416 #define PM_IO_BASE 0xb000
 417
 418 static int kvm_outb(void *opaque, uint16_t addr, uint8_t data)
 419 {
 420     if (addr == 0xb2) {
 421         switch (data) {
 422         case 0: {
 423             cpu_outb(0, 0xb3, 0);
 424             break;
 425         }
 426         case 0xf0: {
 427             unsigned x;
 428
 429             /* enable acpi */
 430             x = cpu_inw(0, PM_IO_BASE + 4);
 431             x &= ~1;
 432             cpu_outw(0, PM_IO_BASE + 4, x);
 433             break;
 434         }
 435         case 0xf1: {
 436             unsigned x;
 437
 438             /* enable acpi */
 439             x = cpu_inw(0, PM_IO_BASE + 4);
 440             x |= 1;
 441             cpu_outw(0, PM_IO_BASE + 4, x);
 442             break;
 443         }
 444         default:
 445             break;
 446         }
 447         return 0;
 448     }
 449     cpu_outb(0, addr, data);
 450     return 0;
 451 }
 452
 453 static int kvm_outw(void *opaque, uint16_t addr, uint16_t data)
 454 {
 455     cpu_outw(0, addr, data);
 456     return 0;
 457 }
 458
 459 static int kvm_outl(void *opaque, uint16_t addr, uint32_t data)
 460 {
 461     cpu_outl(0, addr, data);
 462     return 0;
 463 }
 464
 465 static int kvm_mmio_read(void *opaque, uint64_t addr, uint8_t *data, int len)
 466 {
 467         cpu_physical_memory_rw(addr, data, len, 0);
 468         return 0;
 469 }
 470
 471 static int kvm_mmio_write(void *opaque, uint64_t addr, uint8_t *data, int len)
 472 {
 473         cpu_physical_memory_rw(addr, data, len, 1);
 474         return 0;
 475 }
 476
 477 static int kvm_io_window(void *opaque)
 478 {
 479     return 1;
 480 }
 481
 482
 483 static int kvm_halt(void *opaque, int vcpu)
 484 {
 485     return kvm_arch_halt(opaque, vcpu);
 486 }
 487
 488 static int kvm_shutdown(void *opaque, int vcpu)
 489 {
 490     qemu_system_reset_request();
 491     return 1;
 492 }
 493
 494 static struct kvm_callbacks qemu_kvm_ops = {
 495     .debug = kvm_debug,
 496     .inb   = kvm_inb,
 497     .inw   = kvm_inw,
 498     .inl   = kvm_inl,
 499     .outb  = kvm_outb,
 500     .outw  = kvm_outw,
 501     .outl  = kvm_outl,
 502     .mmio_read = kvm_mmio_read,
 503     .mmio_write = kvm_mmio_write,
 504     .halt  = kvm_halt,
 505     .shutdown = kvm_shutdown,
 506     .io_window = kvm_io_window,
 507     .try_push_interrupts = try_push_interrupts,
 508     .post_kvm_run = post_kvm_run,
 509     .pre_kvm_run = pre_kvm_run,
 510 #ifdef TARGET_I386
 511     .tpr_access = handle_tpr_access,
 512 #endif
 513 #ifdef TARGET_PPC
 514     .powerpc_dcr_read = handle_powerpc_dcr_read,
 515     .powerpc_dcr_write = handle_powerpc_dcr_write,
 516 #endif
 517 };
 518
 519 int kvm_qemu_init()
 520 {
 521     /* Try to initialize kvm */
 522     kvm_context = kvm_init(&qemu_kvm_ops, cpu_single_env);
 523     if (!kvm_context) {
 524         return -1;
 525     }
 526     pthread_mutex_lock(&qemu_mutex);
 527
 528     return 0;
 529 }
 530
 531 int kvm_qemu_create_context(void)
 532 {
 533     int r;
 534     if (!kvm_irqchip) {
 535         kvm_disable_irqchip_creation(kvm_context);
 536     }
 537     if (kvm_create(kvm_context, phys_ram_size, (void**)&phys_ram_base) < 0) {
 538         kvm_qemu_destroy();
 539         return -1;
 540     }
 541     r = kvm_arch_qemu_create_context();
 542     if(r <0)
 543         kvm_qemu_destroy();
 544     return 0;
 545 }
 546
 547 void kvm_qemu_destroy(void)
 548 {
 549     kvm_finalize(kvm_context);
 550 }
 551
 552 void kvm_cpu_register_physical_memory(target_phys_addr_t start_addr,
 553                                       unsigned long size,
 554                                       unsigned long phys_offset)
 555 {
 556 #ifdef KVM_CAP_USER_MEMORY
 557     int r = 0;
 558
 559     r = kvm_check_extension(kvm_context, KVM_CAP_USER_MEMORY);
 560     if (r) {
 561         if (!(phys_offset & ~TARGET_PAGE_MASK)) {
 562                 r = kvm_is_allocated_mem(kvm_context, start_addr, size);
 563             if (r)
 564                 return;
 565             r = kvm_is_intersecting_mem(kvm_context, start_addr);
 566             if (r)
 567                 kvm_create_mem_hole(kvm_context, start_addr, size);
 568             r = kvm_register_userspace_phys_mem(kvm_context, start_addr,
 569                                                 phys_ram_base + phys_offset,
 570                                                 size, 0);
 571         }
 572         if (phys_offset & IO_MEM_ROM) {
 573             phys_offset &= ~IO_MEM_ROM;
 574             r = kvm_is_intersecting_mem(kvm_context, start_addr);
 575             if (r)
 576                 kvm_create_mem_hole(kvm_context, start_addr, size);
 577             r = kvm_register_userspace_phys_mem(kvm_context, start_addr,
 578                                                 phys_ram_base + phys_offset,
 579                                                 size, 0);
 580         }
 581         if (r < 0) {
 582             printf("kvm_cpu_register_physical_memory: failed\n");
 583             exit(1);
 584         }
 585         return;
 586     }
 587 #endif
 588     if (phys_offset & IO_MEM_ROM) {
 589         phys_offset &= ~IO_MEM_ROM;
 590         memcpy(phys_ram_base + start_addr, phys_ram_base + phys_offset, size);
 591     }
 592 }
 593
 594 int kvm_qemu_check_extension(int ext)
 595 {
 596     return kvm_check_extension(kvm_context, ext);
 597 }
 598
 599 int kvm_qemu_init_env(CPUState *cenv)
 600 {
 601     return kvm_arch_qemu_init_env(cenv);
 602 }
 603
 604 int kvm_update_debugger(CPUState *env)
 605 {
 606     struct kvm_debug_guest dbg;
 607     int i;
 608
 609     dbg.enabled = 0;
 610     if (env->nb_breakpoints || env->singlestep_enabled) {
 611         dbg.enabled = 1;
 612         for (i = 0; i < 4 && i < env->nb_breakpoints; ++i) {
 613             dbg.breakpoints[i].enabled = 1;
 614             dbg.breakpoints[i].address = env->breakpoints[i];
 615         }
 616         dbg.singlestep = env->singlestep_enabled;
 617     }
 618     return kvm_guest_debug(kvm_context, env->cpu_index, &dbg);
 619 }
 620
 621
 622 /*
 623  * dirty pages logging
 624  */
 625 /* FIXME: use unsigned long pointer instead of unsigned char */
 626 unsigned char *kvm_dirty_bitmap = NULL;
 627 int kvm_physical_memory_set_dirty_tracking(int enable)
 628 {
 629     int r = 0;
 630
 631     if (!kvm_allowed)
 632         return 0;
 633
 634     if (enable) {
 635         if (!kvm_dirty_bitmap) {
 636             unsigned bitmap_size = BITMAP_SIZE(phys_ram_size);
 637             kvm_dirty_bitmap = qemu_malloc(bitmap_size);
 638             if (kvm_dirty_bitmap == NULL) {
 639                 perror("Failed to allocate dirty pages bitmap");
 640                 r=-1;
 641             }
 642             else {
 643                 r = kvm_dirty_pages_log_enable_all(kvm_context);
 644             }
 645         }
 646     }
 647     else {
 648         if (kvm_dirty_bitmap) {
 649             r = kvm_dirty_pages_log_reset(kvm_context);
 650             qemu_free(kvm_dirty_bitmap);
 651             kvm_dirty_bitmap = NULL;
 652         }
 653     }
 654     return r;
 655 }
 656
 657 /* get kvm's dirty pages bitmap and update qemu's */
 658 int kvm_get_dirty_pages_log_range(unsigned long start_addr,
 659                                   unsigned char *bitmap,
 660                                   unsigned int offset,
 661                                   unsigned long mem_size)
 662 {
 663     unsigned int i, j, n=0;
 664     unsigned char c;
 665     unsigned page_number, addr, addr1;
 666     unsigned int len = ((mem_size/TARGET_PAGE_SIZE) + 7) / 8;
 667
 668     /*
 669      * bitmap-traveling is faster than memory-traveling (for addr...)
 670      * especially when most of the memory is not dirty.
 671      */
 672     for (i=0; i<len; i++) {
 673         c = bitmap[i];
 674         while (c>0) {
 675             j = ffsl(c) - 1;
 676             c &= ~(1u<<j);
 677             page_number = i * 8 + j;
 678             addr1 = page_number * TARGET_PAGE_SIZE;
 679             addr  = offset + addr1;
 680             cpu_physical_memory_set_dirty(addr);
 681             n++;
 682         }
 683     }
 684     return 0;
 685 }
 686 int kvm_get_dirty_bitmap_cb(unsigned long start, unsigned long len,
 687                             void *bitmap, void *opaque)
 688 {
 689     return kvm_get_dirty_pages_log_range(start, bitmap, start, len);
 690 }
 691
 692 /*
 693  * get kvm's dirty pages bitmap and update qemu's
 694  * we only care about physical ram, which resides in slots 0 and 3
 695  */
 696 int kvm_update_dirty_pages_log(void)
 697 {
 698     int r = 0;
 699
 700
 701     r = kvm_get_dirty_pages_range(kvm_context, 0, phys_ram_size,
 702                                   kvm_dirty_bitmap, NULL,
 703                                   kvm_get_dirty_bitmap_cb);
 704     return r;
 705 }
 706
 707 int kvm_get_phys_ram_page_bitmap(unsigned char *bitmap)
 708 {
 709     unsigned int bsize  = BITMAP_SIZE(phys_ram_size);
 710     unsigned int brsize = BITMAP_SIZE(ram_size);
 711     unsigned int extra_pages = (phys_ram_size - ram_size) / TARGET_PAGE_SIZE;
 712     unsigned int extra_bytes = (extra_pages +7)/8;
 713     unsigned int hole_start = BITMAP_SIZE(0xa0000);
 714     unsigned int hole_end   = BITMAP_SIZE(0xc0000);
 715
 716     memset(bitmap, 0xFF, brsize + extra_bytes);
 717     memset(bitmap + hole_start, 0, hole_end - hole_start);
 718     memset(bitmap + brsize + extra_bytes, 0, bsize - brsize - extra_bytes);
 719
 720     return 0;
 721 }
 722
 723 #ifdef KVM_CAP_IRQCHIP
 724
 725 int kvm_set_irq(int irq, int level)
 726 {
 727     return kvm_set_irq_level(kvm_context, irq, level);
 728 }
 729
 730 #endif
 731
 732 void qemu_kvm_aio_wait_start(void)
 733 {
 734 }
 735
 736 void qemu_kvm_aio_wait(void)
 737 {
 738     if (!cpu_single_env || cpu_single_env->cpu_index == 0) {
 739         pthread_mutex_unlock(&qemu_mutex);
 740         kvm_eat_signal(cpu_single_env, 1000);
 741         pthread_mutex_lock(&qemu_mutex);
 742     } else {
 743         pthread_cond_wait(&qemu_aio_cond, &qemu_mutex);
 744     }
 745 }
 746
 747 void qemu_kvm_aio_wait_end(void)
 748 {
 749 }
 750
 751 #endif