softmmu/cpus.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "qemu-common.h"
  27 #include "monitor/monitor.h"
  28 #include "qapi/error.h"
  29 #include "qapi/qapi-commands-misc.h"
  30 #include "qapi/qapi-events-run-state.h"
  31 #include "qapi/qmp/qerror.h"
  32 #include "exec/gdbstub.h"
  33 #include "sysemu/hw_accel.h"
  34 #include "exec/exec-all.h"
  35 #include "qemu/thread.h"
  36 #include "qemu/plugin.h"
  37 #include "sysemu/cpus.h"
  38 #include "qemu/guest-random.h"
  39 #include "hw/nmi.h"
  40 #include "sysemu/replay.h"
  41 #include "sysemu/runstate.h"
  42 #include "sysemu/cpu-timers.h"
  43 #include "hw/boards.h"
  44 #include "hw/hw.h"
  45
  46 #ifdef CONFIG_LINUX
  47
  48 #include <sys/prctl.h>
  49
  50 #ifndef PR_MCE_KILL
  51 #define PR_MCE_KILL 33
  52 #endif
  53
  54 #ifndef PR_MCE_KILL_SET
  55 #define PR_MCE_KILL_SET 1
  56 #endif
  57
  58 #ifndef PR_MCE_KILL_EARLY
  59 #define PR_MCE_KILL_EARLY 1
  60 #endif
  61
  62 #endif /* CONFIG_LINUX */
  63
  64 static QemuMutex qemu_global_mutex;
  65
  66 bool cpu_is_stopped(CPUState *cpu)
  67 {
  68     return cpu->stopped || !runstate_is_running();
  69 }
  70
  71 bool cpu_work_list_empty(CPUState *cpu)
  72 {
  73     bool ret;
  74
  75     qemu_mutex_lock(&cpu->work_mutex);
  76     ret = QSIMPLEQ_EMPTY(&cpu->work_list);
  77     qemu_mutex_unlock(&cpu->work_mutex);
  78     return ret;
  79 }
  80
  81 bool cpu_thread_is_idle(CPUState *cpu)
  82 {
  83     if (cpu->stop || !cpu_work_list_empty(cpu)) {
  84         return false;
  85     }
  86     if (cpu_is_stopped(cpu)) {
  87         return true;
  88     }
  89     if (!cpu->halted || cpu_has_work(cpu) ||
  90         kvm_halt_in_kernel()) {
  91         return false;
  92     }
  93     return true;
  94 }
  95
  96 bool all_cpu_threads_idle(void)
  97 {
  98     CPUState *cpu;
  99
 100     CPU_FOREACH(cpu) {
 101         if (!cpu_thread_is_idle(cpu)) {
 102             return false;
 103         }
 104     }
 105     return true;
 106 }
 107
 108 /***********************************************************/
 109 void hw_error(const char *fmt, ...)
 110 {
 111     va_list ap;
 112     CPUState *cpu;
 113
 114     va_start(ap, fmt);
 115     fprintf(stderr, "qemu: hardware error: ");
 116     vfprintf(stderr, fmt, ap);
 117     fprintf(stderr, "\n");
 118     CPU_FOREACH(cpu) {
 119         fprintf(stderr, "CPU #%d:\n", cpu->cpu_index);
 120         cpu_dump_state(cpu, stderr, CPU_DUMP_FPU);
 121     }
 122     va_end(ap);
 123     abort();
 124 }
 125
 126 /*
 127  * The chosen accelerator is supposed to register this.
 128  */
 129 static const CpusAccel *cpus_accel;
 130
 131 void cpu_synchronize_all_states(void)
 132 {
 133     CPUState *cpu;
 134
 135     CPU_FOREACH(cpu) {
 136         cpu_synchronize_state(cpu);
 137     }
 138 }
 139
 140 void cpu_synchronize_all_post_reset(void)
 141 {
 142     CPUState *cpu;
 143
 144     CPU_FOREACH(cpu) {
 145         cpu_synchronize_post_reset(cpu);
 146     }
 147 }
 148
 149 void cpu_synchronize_all_post_init(void)
 150 {
 151     CPUState *cpu;
 152
 153     CPU_FOREACH(cpu) {
 154         cpu_synchronize_post_init(cpu);
 155     }
 156 }
 157
 158 void cpu_synchronize_all_pre_loadvm(void)
 159 {
 160     CPUState *cpu;
 161
 162     CPU_FOREACH(cpu) {
 163         cpu_synchronize_pre_loadvm(cpu);
 164     }
 165 }
 166
 167 void cpu_synchronize_state(CPUState *cpu)
 168 {
 169     if (cpus_accel->synchronize_state) {
 170         cpus_accel->synchronize_state(cpu);
 171     }
 172 }
 173
 174 void cpu_synchronize_post_reset(CPUState *cpu)
 175 {
 176     if (cpus_accel->synchronize_post_reset) {
 177         cpus_accel->synchronize_post_reset(cpu);
 178     }
 179 }
 180
 181 void cpu_synchronize_post_init(CPUState *cpu)
 182 {
 183     if (cpus_accel->synchronize_post_init) {
 184         cpus_accel->synchronize_post_init(cpu);
 185     }
 186 }
 187
 188 void cpu_synchronize_pre_loadvm(CPUState *cpu)
 189 {
 190     if (cpus_accel->synchronize_pre_loadvm) {
 191         cpus_accel->synchronize_pre_loadvm(cpu);
 192     }
 193 }
 194
 195 int64_t cpus_get_virtual_clock(void)
 196 {
 197     /*
 198      * XXX
 199      *
 200      * need to check that cpus_accel is not NULL, because qcow2 calls
 201      * qemu_get_clock_ns(CLOCK_VIRTUAL) without any accel initialized and
 202      * with ticks disabled in some io-tests:
 203      * 030 040 041 060 099 120 127 140 156 161 172 181 191 192 195 203 229 249 256 267
 204      *
 205      * is this expected?
 206      *
 207      * XXX
 208      */
 209     if (cpus_accel && cpus_accel->get_virtual_clock) {
 210         return cpus_accel->get_virtual_clock();
 211     }
 212     return cpu_get_clock();
 213 }
 214
 215 /*
 216  * return the time elapsed in VM between vm_start and vm_stop.  Unless
 217  * icount is active, cpus_get_elapsed_ticks() uses units of the host CPU cycle
 218  * counter.
 219  */
 220 int64_t cpus_get_elapsed_ticks(void)
 221 {
 222     if (cpus_accel->get_elapsed_ticks) {
 223         return cpus_accel->get_elapsed_ticks();
 224     }
 225     return cpu_get_ticks();
 226 }
 227
 228 static void generic_handle_interrupt(CPUState *cpu, int mask)
 229 {
 230     cpu->interrupt_request |= mask;
 231
 232     if (!qemu_cpu_is_self(cpu)) {
 233         qemu_cpu_kick(cpu);
 234     }
 235 }
 236
 237 void cpu_interrupt(CPUState *cpu, int mask)
 238 {
 239     if (cpus_accel->handle_interrupt) {
 240         cpus_accel->handle_interrupt(cpu, mask);
 241     } else {
 242         generic_handle_interrupt(cpu, mask);
 243     }
 244 }
 245
 246 static int do_vm_stop(RunState state, bool send_stop)
 247 {
 248     int ret = 0;
 249
 250     if (runstate_is_running()) {
 251         runstate_set(state);
 252         cpu_disable_ticks();
 253         pause_all_vcpus();
 254         vm_state_notify(0, state);
 255         if (send_stop) {
 256             qapi_event_send_stop();
 257         }
 258     }
 259
 260     bdrv_drain_all();
 261     ret = bdrv_flush_all();
 262
 263     return ret;
 264 }
 265
 266 /* Special vm_stop() variant for terminating the process.  Historically clients
 267  * did not expect a QMP STOP event and so we need to retain compatibility.
 268  */
 269 int vm_shutdown(void)
 270 {
 271     return do_vm_stop(RUN_STATE_SHUTDOWN, false);
 272 }
 273
 274 bool cpu_can_run(CPUState *cpu)
 275 {
 276     if (cpu->stop) {
 277         return false;
 278     }
 279     if (cpu_is_stopped(cpu)) {
 280         return false;
 281     }
 282     return true;
 283 }
 284
 285 void cpu_handle_guest_debug(CPUState *cpu)
 286 {
 287     if (replay_running_debug()) {
 288         if (!cpu->singlestep_enabled) {
 289             /*
 290              * Report about the breakpoint and
 291              * make a single step to skip it
 292              */
 293             replay_breakpoint();
 294             cpu_single_step(cpu, SSTEP_ENABLE);
 295         } else {
 296             cpu_single_step(cpu, 0);
 297         }
 298     } else {
 299         gdb_set_stop_cpu(cpu);
 300         qemu_system_debug_request();
 301         cpu->stopped = true;
 302     }
 303 }
 304
 305 #ifdef CONFIG_LINUX
 306 static void sigbus_reraise(void)
 307 {
 308     sigset_t set;
 309     struct sigaction action;
 310
 311     memset(&action, 0, sizeof(action));
 312     action.sa_handler = SIG_DFL;
 313     if (!sigaction(SIGBUS, &action, NULL)) {
 314         raise(SIGBUS);
 315         sigemptyset(&set);
 316         sigaddset(&set, SIGBUS);
 317         pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 318     }
 319     perror("Failed to re-raise SIGBUS!\n");
 320     abort();
 321 }
 322
 323 static void sigbus_handler(int n, siginfo_t *siginfo, void *ctx)
 324 {
 325     if (siginfo->si_code != BUS_MCEERR_AO && siginfo->si_code != BUS_MCEERR_AR) {
 326         sigbus_reraise();
 327     }
 328
 329     if (current_cpu) {
 330         /* Called asynchronously in VCPU thread.  */
 331         if (kvm_on_sigbus_vcpu(current_cpu, siginfo->si_code, siginfo->si_addr)) {
 332             sigbus_reraise();
 333         }
 334     } else {
 335         /* Called synchronously (via signalfd) in main thread.  */
 336         if (kvm_on_sigbus(siginfo->si_code, siginfo->si_addr)) {
 337             sigbus_reraise();
 338         }
 339     }
 340 }
 341
 342 static void qemu_init_sigbus(void)
 343 {
 344     struct sigaction action;
 345
 346     memset(&action, 0, sizeof(action));
 347     action.sa_flags = SA_SIGINFO;
 348     action.sa_sigaction = sigbus_handler;
 349     sigaction(SIGBUS, &action, NULL);
 350
 351     prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
 352 }
 353 #else /* !CONFIG_LINUX */
 354 static void qemu_init_sigbus(void)
 355 {
 356 }
 357 #endif /* !CONFIG_LINUX */
 358
 359 static QemuThread io_thread;
 360
 361 /* cpu creation */
 362 static QemuCond qemu_cpu_cond;
 363 /* system init */
 364 static QemuCond qemu_pause_cond;
 365
 366 void qemu_init_cpu_loop(void)
 367 {
 368     qemu_init_sigbus();
 369     qemu_cond_init(&qemu_cpu_cond);
 370     qemu_cond_init(&qemu_pause_cond);
 371     qemu_mutex_init(&qemu_global_mutex);
 372
 373     qemu_thread_get_self(&io_thread);
 374 }
 375
 376 void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)
 377 {
 378     do_run_on_cpu(cpu, func, data, &qemu_global_mutex);
 379 }
 380
 381 static void qemu_cpu_stop(CPUState *cpu, bool exit)
 382 {
 383     g_assert(qemu_cpu_is_self(cpu));
 384     cpu->stop = false;
 385     cpu->stopped = true;
 386     if (exit) {
 387         cpu_exit(cpu);
 388     }
 389     qemu_cond_broadcast(&qemu_pause_cond);
 390 }
 391
 392 void qemu_wait_io_event_common(CPUState *cpu)
 393 {
 394     qatomic_mb_set(&cpu->thread_kicked, false);
 395     if (cpu->stop) {
 396         qemu_cpu_stop(cpu, false);
 397     }
 398     process_queued_cpu_work(cpu);
 399 }
 400
 401 void qemu_wait_io_event(CPUState *cpu)
 402 {
 403     bool slept = false;
 404
 405     while (cpu_thread_is_idle(cpu)) {
 406         if (!slept) {
 407             slept = true;
 408             qemu_plugin_vcpu_idle_cb(cpu);
 409         }
 410         qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
 411     }
 412     if (slept) {
 413         qemu_plugin_vcpu_resume_cb(cpu);
 414     }
 415
 416 #ifdef _WIN32
 417     /* Eat dummy APC queued by cpus_kick_thread. */
 418     if (hax_enabled()) {
 419         SleepEx(0, TRUE);
 420     }
 421 #endif
 422     qemu_wait_io_event_common(cpu);
 423 }
 424
 425 void cpus_kick_thread(CPUState *cpu)
 426 {
 427 #ifndef _WIN32
 428     int err;
 429
 430     if (cpu->thread_kicked) {
 431         return;
 432     }
 433     cpu->thread_kicked = true;
 434     err = pthread_kill(cpu->thread->thread, SIG_IPI);
 435     if (err && err != ESRCH) {
 436         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
 437         exit(1);
 438     }
 439 #endif
 440 }
 441
 442 void qemu_cpu_kick(CPUState *cpu)
 443 {
 444     qemu_cond_broadcast(cpu->halt_cond);
 445     if (cpus_accel->kick_vcpu_thread) {
 446         cpus_accel->kick_vcpu_thread(cpu);
 447     } else { /* default */
 448         cpus_kick_thread(cpu);
 449     }
 450 }
 451
 452 void qemu_cpu_kick_self(void)
 453 {
 454     assert(current_cpu);
 455     cpus_kick_thread(current_cpu);
 456 }
 457
 458 bool qemu_cpu_is_self(CPUState *cpu)
 459 {
 460     return qemu_thread_is_self(cpu->thread);
 461 }
 462
 463 bool qemu_in_vcpu_thread(void)
 464 {
 465     return current_cpu && qemu_cpu_is_self(current_cpu);
 466 }
 467
 468 static __thread bool iothread_locked = false;
 469
 470 bool qemu_mutex_iothread_locked(void)
 471 {
 472     return iothread_locked;
 473 }
 474
 475 /*
 476  * The BQL is taken from so many places that it is worth profiling the
 477  * callers directly, instead of funneling them all through a single function.
 478  */
 479 void qemu_mutex_lock_iothread_impl(const char *file, int line)
 480 {
 481     QemuMutexLockFunc bql_lock = qatomic_read(&qemu_bql_mutex_lock_func);
 482
 483     g_assert(!qemu_mutex_iothread_locked());
 484     bql_lock(&qemu_global_mutex, file, line);
 485     iothread_locked = true;
 486 }
 487
 488 void qemu_mutex_unlock_iothread(void)
 489 {
 490     g_assert(qemu_mutex_iothread_locked());
 491     iothread_locked = false;
 492     qemu_mutex_unlock(&qemu_global_mutex);
 493 }
 494
 495 void qemu_cond_wait_iothread(QemuCond *cond)
 496 {
 497     qemu_cond_wait(cond, &qemu_global_mutex);
 498 }
 499
 500 void qemu_cond_timedwait_iothread(QemuCond *cond, int ms)
 501 {
 502     qemu_cond_timedwait(cond, &qemu_global_mutex, ms);
 503 }
 504
 505 /* signal CPU creation */
 506 void cpu_thread_signal_created(CPUState *cpu)
 507 {
 508     cpu->created = true;
 509     qemu_cond_signal(&qemu_cpu_cond);
 510 }
 511
 512 /* signal CPU destruction */
 513 void cpu_thread_signal_destroyed(CPUState *cpu)
 514 {
 515     cpu->created = false;
 516     qemu_cond_signal(&qemu_cpu_cond);
 517 }
 518
 519
 520 static bool all_vcpus_paused(void)
 521 {
 522     CPUState *cpu;
 523
 524     CPU_FOREACH(cpu) {
 525         if (!cpu->stopped) {
 526             return false;
 527         }
 528     }
 529
 530     return true;
 531 }
 532
 533 void pause_all_vcpus(void)
 534 {
 535     CPUState *cpu;
 536
 537     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
 538     CPU_FOREACH(cpu) {
 539         if (qemu_cpu_is_self(cpu)) {
 540             qemu_cpu_stop(cpu, true);
 541         } else {
 542             cpu->stop = true;
 543             qemu_cpu_kick(cpu);
 544         }
 545     }
 546
 547     /* We need to drop the replay_lock so any vCPU threads woken up
 548      * can finish their replay tasks
 549      */
 550     replay_mutex_unlock();
 551
 552     while (!all_vcpus_paused()) {
 553         qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
 554         CPU_FOREACH(cpu) {
 555             qemu_cpu_kick(cpu);
 556         }
 557     }
 558
 559     qemu_mutex_unlock_iothread();
 560     replay_mutex_lock();
 561     qemu_mutex_lock_iothread();
 562 }
 563
 564 void cpu_resume(CPUState *cpu)
 565 {
 566     cpu->stop = false;
 567     cpu->stopped = false;
 568     qemu_cpu_kick(cpu);
 569 }
 570
 571 void resume_all_vcpus(void)
 572 {
 573     CPUState *cpu;
 574
 575     if (!runstate_is_running()) {
 576         return;
 577     }
 578
 579     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
 580     CPU_FOREACH(cpu) {
 581         cpu_resume(cpu);
 582     }
 583 }
 584
 585 void cpu_remove_sync(CPUState *cpu)
 586 {
 587     cpu->stop = true;
 588     cpu->unplug = true;
 589     qemu_cpu_kick(cpu);
 590     qemu_mutex_unlock_iothread();
 591     qemu_thread_join(cpu->thread);
 592     qemu_mutex_lock_iothread();
 593 }
 594
 595 void cpus_register_accel(const CpusAccel *ca)
 596 {
 597     assert(ca != NULL);
 598     assert(ca->create_vcpu_thread != NULL); /* mandatory */
 599     cpus_accel = ca;
 600 }
 601
 602 void qemu_init_vcpu(CPUState *cpu)
 603 {
 604     MachineState *ms = MACHINE(qdev_get_machine());
 605
 606     cpu->nr_cores = ms->smp.cores;
 607     cpu->nr_threads =  ms->smp.threads;
 608     cpu->stopped = true;
 609     cpu->random_seed = qemu_guest_random_seed_thread_part1();
 610
 611     if (!cpu->as) {
 612         /* If the target cpu hasn't set up any address spaces itself,
 613          * give it the default one.
 614          */
 615         cpu->num_ases = 1;
 616         cpu_address_space_init(cpu, 0, "cpu-memory", cpu->memory);
 617     }
 618
 619     /* accelerators all implement the CpusAccel interface */
 620     g_assert(cpus_accel != NULL && cpus_accel->create_vcpu_thread != NULL);
 621     cpus_accel->create_vcpu_thread(cpu);
 622
 623     while (!cpu->created) {
 624         qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex);
 625     }
 626 }
 627
 628 void cpu_stop_current(void)
 629 {
 630     if (current_cpu) {
 631         current_cpu->stop = true;
 632         cpu_exit(current_cpu);
 633     }
 634 }
 635
 636 int vm_stop(RunState state)
 637 {
 638     if (qemu_in_vcpu_thread()) {
 639         qemu_system_vmstop_request_prepare();
 640         qemu_system_vmstop_request(state);
 641         /*
 642          * FIXME: should not return to device code in case
 643          * vm_stop() has been requested.
 644          */
 645         cpu_stop_current();
 646         return 0;
 647     }
 648
 649     return do_vm_stop(state, true);
 650 }
 651
 652 /**
 653  * Prepare for (re)starting the VM.
 654  * Returns -1 if the vCPUs are not to be restarted (e.g. if they are already
 655  * running or in case of an error condition), 0 otherwise.
 656  */
 657 int vm_prepare_start(void)
 658 {
 659     RunState requested;
 660
 661     qemu_vmstop_requested(&requested);
 662     if (runstate_is_running() && requested == RUN_STATE__MAX) {
 663         return -1;
 664     }
 665
 666     /* Ensure that a STOP/RESUME pair of events is emitted if a
 667      * vmstop request was pending.  The BLOCK_IO_ERROR event, for
 668      * example, according to documentation is always followed by
 669      * the STOP event.
 670      */
 671     if (runstate_is_running()) {
 672         qapi_event_send_stop();
 673         qapi_event_send_resume();
 674         return -1;
 675     }
 676
 677     /* We are sending this now, but the CPUs will be resumed shortly later */
 678     qapi_event_send_resume();
 679
 680     cpu_enable_ticks();
 681     runstate_set(RUN_STATE_RUNNING);
 682     vm_state_notify(1, RUN_STATE_RUNNING);
 683     return 0;
 684 }
 685
 686 void vm_start(void)
 687 {
 688     if (!vm_prepare_start()) {
 689         resume_all_vcpus();
 690     }
 691 }
 692
 693 /* does a state transition even if the VM is already stopped,
 694    current state is forgotten forever */
 695 int vm_stop_force_state(RunState state)
 696 {
 697     if (runstate_is_running()) {
 698         return vm_stop(state);
 699     } else {
 700         runstate_set(state);
 701
 702         bdrv_drain_all();
 703         /* Make sure to return an error if the flush in a previous vm_stop()
 704          * failed. */
 705         return bdrv_flush_all();
 706     }
 707 }
 708
 709 void list_cpus(const char *optarg)
 710 {
 711     /* XXX: implement xxx_cpu_list for targets that still miss it */
 712 #if defined(cpu_list)
 713     cpu_list();
 714 #endif
 715 }
 716
 717 void qmp_memsave(int64_t addr, int64_t size, const char *filename,
 718                  bool has_cpu, int64_t cpu_index, Error **errp)
 719 {
 720     FILE *f;
 721     uint32_t l;
 722     CPUState *cpu;
 723     uint8_t buf[1024];
 724     int64_t orig_addr = addr, orig_size = size;
 725
 726     if (!has_cpu) {
 727         cpu_index = 0;
 728     }
 729
 730     cpu = qemu_get_cpu(cpu_index);
 731     if (cpu == NULL) {
 732         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
 733                    "a CPU number");
 734         return;
 735     }
 736
 737     f = fopen(filename, "wb");
 738     if (!f) {
 739         error_setg_file_open(errp, errno, filename);
 740         return;
 741     }
 742
 743     while (size != 0) {
 744         l = sizeof(buf);
 745         if (l > size)
 746             l = size;
 747         if (cpu_memory_rw_debug(cpu, addr, buf, l, 0) != 0) {
 748             error_setg(errp, "Invalid addr 0x%016" PRIx64 "/size %" PRId64
 749                              " specified", orig_addr, orig_size);
 750             goto exit;
 751         }
 752         if (fwrite(buf, 1, l, f) != l) {
 753             error_setg(errp, QERR_IO_ERROR);
 754             goto exit;
 755         }
 756         addr += l;
 757         size -= l;
 758     }
 759
 760 exit:
 761     fclose(f);
 762 }
 763
 764 void qmp_pmemsave(int64_t addr, int64_t size, const char *filename,
 765                   Error **errp)
 766 {
 767     FILE *f;
 768     uint32_t l;
 769     uint8_t buf[1024];
 770
 771     f = fopen(filename, "wb");
 772     if (!f) {
 773         error_setg_file_open(errp, errno, filename);
 774         return;
 775     }
 776
 777     while (size != 0) {
 778         l = sizeof(buf);
 779         if (l > size)
 780             l = size;
 781         cpu_physical_memory_read(addr, buf, l);
 782         if (fwrite(buf, 1, l, f) != l) {
 783             error_setg(errp, QERR_IO_ERROR);
 784             goto exit;
 785         }
 786         addr += l;
 787         size -= l;
 788     }
 789
 790 exit:
 791     fclose(f);
 792 }
 793
 794 void qmp_inject_nmi(Error **errp)
 795 {
 796     nmi_monitor_handle(monitor_get_cpu_index(monitor_cur()), errp);
 797 }
 798