qemu-kvm.c

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