dump.c

   1 /*
   2  * QEMU dump
   3  *
   4  * Copyright Fujitsu, Corp. 2011, 2012
   5  *
   6  * Authors:
   7  *     Wen Congyang <wency@cn.fujitsu.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 #include "qemu/osdep.h"
  15 #include "qemu/cutils.h"
  16 #include "elf.h"
  17 #include "cpu.h"
  18 #include "exec/hwaddr.h"
  19 #include "monitor/monitor.h"
  20 #include "sysemu/kvm.h"
  21 #include "sysemu/dump.h"
  22 #include "sysemu/sysemu.h"
  23 #include "sysemu/memory_mapping.h"
  24 #include "sysemu/cpus.h"
  25 #include "qapi/error.h"
  26 #include "qapi/qapi-commands-misc.h"
  27 #include "qapi/qapi-events-misc.h"
  28 #include "qapi/qmp/qerror.h"
  29 #include "qemu/error-report.h"
  30 #include "hw/misc/vmcoreinfo.h"
  31
  32 #ifdef TARGET_X86_64
  33 #include "win_dump.h"
  34 #endif
  35
  36 #include <zlib.h>
  37 #ifdef CONFIG_LZO
  38 #include <lzo/lzo1x.h>
  39 #endif
  40 #ifdef CONFIG_SNAPPY
  41 #include <snappy-c.h>
  42 #endif
  43 #ifndef ELF_MACHINE_UNAME
  44 #define ELF_MACHINE_UNAME "Unknown"
  45 #endif
  46
  47 #define MAX_GUEST_NOTE_SIZE (1 << 20) /* 1MB should be enough */
  48
  49 #define ELF_NOTE_SIZE(hdr_size, name_size, desc_size)   \
  50     ((DIV_ROUND_UP((hdr_size), 4) +                     \
  51       DIV_ROUND_UP((name_size), 4) +                    \
  52       DIV_ROUND_UP((desc_size), 4)) * 4)
  53
  54 uint16_t cpu_to_dump16(DumpState *s, uint16_t val)
  55 {
  56     if (s->dump_info.d_endian == ELFDATA2LSB) {
  57         val = cpu_to_le16(val);
  58     } else {
  59         val = cpu_to_be16(val);
  60     }
  61
  62     return val;
  63 }
  64
  65 uint32_t cpu_to_dump32(DumpState *s, uint32_t val)
  66 {
  67     if (s->dump_info.d_endian == ELFDATA2LSB) {
  68         val = cpu_to_le32(val);
  69     } else {
  70         val = cpu_to_be32(val);
  71     }
  72
  73     return val;
  74 }
  75
  76 uint64_t cpu_to_dump64(DumpState *s, uint64_t val)
  77 {
  78     if (s->dump_info.d_endian == ELFDATA2LSB) {
  79         val = cpu_to_le64(val);
  80     } else {
  81         val = cpu_to_be64(val);
  82     }
  83
  84     return val;
  85 }
  86
  87 static int dump_cleanup(DumpState *s)
  88 {
  89     guest_phys_blocks_free(&s->guest_phys_blocks);
  90     memory_mapping_list_free(&s->list);
  91     close(s->fd);
  92     g_free(s->guest_note);
  93     s->guest_note = NULL;
  94     if (s->resume) {
  95         if (s->detached) {
  96             qemu_mutex_lock_iothread();
  97         }
  98         vm_start();
  99         if (s->detached) {
 100             qemu_mutex_unlock_iothread();
 101         }
 102     }
 103
 104     return 0;
 105 }
 106
 107 static int fd_write_vmcore(const void *buf, size_t size, void *opaque)
 108 {
 109     DumpState *s = opaque;
 110     size_t written_size;
 111
 112     written_size = qemu_write_full(s->fd, buf, size);
 113     if (written_size != size) {
 114         return -errno;
 115     }
 116
 117     return 0;
 118 }
 119
 120 static void write_elf64_header(DumpState *s, Error **errp)
 121 {
 122     Elf64_Ehdr elf_header;
 123     int ret;
 124
 125     memset(&elf_header, 0, sizeof(Elf64_Ehdr));
 126     memcpy(&elf_header, ELFMAG, SELFMAG);
 127     elf_header.e_ident[EI_CLASS] = ELFCLASS64;
 128     elf_header.e_ident[EI_DATA] = s->dump_info.d_endian;
 129     elf_header.e_ident[EI_VERSION] = EV_CURRENT;
 130     elf_header.e_type = cpu_to_dump16(s, ET_CORE);
 131     elf_header.e_machine = cpu_to_dump16(s, s->dump_info.d_machine);
 132     elf_header.e_version = cpu_to_dump32(s, EV_CURRENT);
 133     elf_header.e_ehsize = cpu_to_dump16(s, sizeof(elf_header));
 134     elf_header.e_phoff = cpu_to_dump64(s, sizeof(Elf64_Ehdr));
 135     elf_header.e_phentsize = cpu_to_dump16(s, sizeof(Elf64_Phdr));
 136     elf_header.e_phnum = cpu_to_dump16(s, s->phdr_num);
 137     if (s->have_section) {
 138         uint64_t shoff = sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr) * s->sh_info;
 139
 140         elf_header.e_shoff = cpu_to_dump64(s, shoff);
 141         elf_header.e_shentsize = cpu_to_dump16(s, sizeof(Elf64_Shdr));
 142         elf_header.e_shnum = cpu_to_dump16(s, 1);
 143     }
 144
 145     ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
 146     if (ret < 0) {
 147         error_setg_errno(errp, -ret, "dump: failed to write elf header");
 148     }
 149 }
 150
 151 static void write_elf32_header(DumpState *s, Error **errp)
 152 {
 153     Elf32_Ehdr elf_header;
 154     int ret;
 155
 156     memset(&elf_header, 0, sizeof(Elf32_Ehdr));
 157     memcpy(&elf_header, ELFMAG, SELFMAG);
 158     elf_header.e_ident[EI_CLASS] = ELFCLASS32;
 159     elf_header.e_ident[EI_DATA] = s->dump_info.d_endian;
 160     elf_header.e_ident[EI_VERSION] = EV_CURRENT;
 161     elf_header.e_type = cpu_to_dump16(s, ET_CORE);
 162     elf_header.e_machine = cpu_to_dump16(s, s->dump_info.d_machine);
 163     elf_header.e_version = cpu_to_dump32(s, EV_CURRENT);
 164     elf_header.e_ehsize = cpu_to_dump16(s, sizeof(elf_header));
 165     elf_header.e_phoff = cpu_to_dump32(s, sizeof(Elf32_Ehdr));
 166     elf_header.e_phentsize = cpu_to_dump16(s, sizeof(Elf32_Phdr));
 167     elf_header.e_phnum = cpu_to_dump16(s, s->phdr_num);
 168     if (s->have_section) {
 169         uint32_t shoff = sizeof(Elf32_Ehdr) + sizeof(Elf32_Phdr) * s->sh_info;
 170
 171         elf_header.e_shoff = cpu_to_dump32(s, shoff);
 172         elf_header.e_shentsize = cpu_to_dump16(s, sizeof(Elf32_Shdr));
 173         elf_header.e_shnum = cpu_to_dump16(s, 1);
 174     }
 175
 176     ret = fd_write_vmcore(&elf_header, sizeof(elf_header), s);
 177     if (ret < 0) {
 178         error_setg_errno(errp, -ret, "dump: failed to write elf header");
 179     }
 180 }
 181
 182 static void write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,
 183                              int phdr_index, hwaddr offset,
 184                              hwaddr filesz, Error **errp)
 185 {
 186     Elf64_Phdr phdr;
 187     int ret;
 188
 189     memset(&phdr, 0, sizeof(Elf64_Phdr));
 190     phdr.p_type = cpu_to_dump32(s, PT_LOAD);
 191     phdr.p_offset = cpu_to_dump64(s, offset);
 192     phdr.p_paddr = cpu_to_dump64(s, memory_mapping->phys_addr);
 193     phdr.p_filesz = cpu_to_dump64(s, filesz);
 194     phdr.p_memsz = cpu_to_dump64(s, memory_mapping->length);
 195     phdr.p_vaddr = cpu_to_dump64(s, memory_mapping->virt_addr) ?: phdr.p_paddr;
 196
 197     assert(memory_mapping->length >= filesz);
 198
 199     ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
 200     if (ret < 0) {
 201         error_setg_errno(errp, -ret,
 202                          "dump: failed to write program header table");
 203     }
 204 }
 205
 206 static void write_elf32_load(DumpState *s, MemoryMapping *memory_mapping,
 207                              int phdr_index, hwaddr offset,
 208                              hwaddr filesz, Error **errp)
 209 {
 210     Elf32_Phdr phdr;
 211     int ret;
 212
 213     memset(&phdr, 0, sizeof(Elf32_Phdr));
 214     phdr.p_type = cpu_to_dump32(s, PT_LOAD);
 215     phdr.p_offset = cpu_to_dump32(s, offset);
 216     phdr.p_paddr = cpu_to_dump32(s, memory_mapping->phys_addr);
 217     phdr.p_filesz = cpu_to_dump32(s, filesz);
 218     phdr.p_memsz = cpu_to_dump32(s, memory_mapping->length);
 219     phdr.p_vaddr =
 220         cpu_to_dump32(s, memory_mapping->virt_addr) ?: phdr.p_paddr;
 221
 222     assert(memory_mapping->length >= filesz);
 223
 224     ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
 225     if (ret < 0) {
 226         error_setg_errno(errp, -ret,
 227                          "dump: failed to write program header table");
 228     }
 229 }
 230
 231 static void write_elf64_note(DumpState *s, Error **errp)
 232 {
 233     Elf64_Phdr phdr;
 234     hwaddr begin = s->memory_offset - s->note_size;
 235     int ret;
 236
 237     memset(&phdr, 0, sizeof(Elf64_Phdr));
 238     phdr.p_type = cpu_to_dump32(s, PT_NOTE);
 239     phdr.p_offset = cpu_to_dump64(s, begin);
 240     phdr.p_paddr = 0;
 241     phdr.p_filesz = cpu_to_dump64(s, s->note_size);
 242     phdr.p_memsz = cpu_to_dump64(s, s->note_size);
 243     phdr.p_vaddr = 0;
 244
 245     ret = fd_write_vmcore(&phdr, sizeof(Elf64_Phdr), s);
 246     if (ret < 0) {
 247         error_setg_errno(errp, -ret,
 248                          "dump: failed to write program header table");
 249     }
 250 }
 251
 252 static inline int cpu_index(CPUState *cpu)
 253 {
 254     return cpu->cpu_index + 1;
 255 }
 256
 257 static void write_guest_note(WriteCoreDumpFunction f, DumpState *s,
 258                              Error **errp)
 259 {
 260     int ret;
 261
 262     if (s->guest_note) {
 263         ret = f(s->guest_note, s->guest_note_size, s);
 264         if (ret < 0) {
 265             error_setg(errp, "dump: failed to write guest note");
 266         }
 267     }
 268 }
 269
 270 static void write_elf64_notes(WriteCoreDumpFunction f, DumpState *s,
 271                               Error **errp)
 272 {
 273     CPUState *cpu;
 274     int ret;
 275     int id;
 276
 277     CPU_FOREACH(cpu) {
 278         id = cpu_index(cpu);
 279         ret = cpu_write_elf64_note(f, cpu, id, s);
 280         if (ret < 0) {
 281             error_setg(errp, "dump: failed to write elf notes");
 282             return;
 283         }
 284     }
 285
 286     CPU_FOREACH(cpu) {
 287         ret = cpu_write_elf64_qemunote(f, cpu, s);
 288         if (ret < 0) {
 289             error_setg(errp, "dump: failed to write CPU status");
 290             return;
 291         }
 292     }
 293
 294     write_guest_note(f, s, errp);
 295 }
 296
 297 static void write_elf32_note(DumpState *s, Error **errp)
 298 {
 299     hwaddr begin = s->memory_offset - s->note_size;
 300     Elf32_Phdr phdr;
 301     int ret;
 302
 303     memset(&phdr, 0, sizeof(Elf32_Phdr));
 304     phdr.p_type = cpu_to_dump32(s, PT_NOTE);
 305     phdr.p_offset = cpu_to_dump32(s, begin);
 306     phdr.p_paddr = 0;
 307     phdr.p_filesz = cpu_to_dump32(s, s->note_size);
 308     phdr.p_memsz = cpu_to_dump32(s, s->note_size);
 309     phdr.p_vaddr = 0;
 310
 311     ret = fd_write_vmcore(&phdr, sizeof(Elf32_Phdr), s);
 312     if (ret < 0) {
 313         error_setg_errno(errp, -ret,
 314                          "dump: failed to write program header table");
 315     }
 316 }
 317
 318 static void write_elf32_notes(WriteCoreDumpFunction f, DumpState *s,
 319                               Error **errp)
 320 {
 321     CPUState *cpu;
 322     int ret;
 323     int id;
 324
 325     CPU_FOREACH(cpu) {
 326         id = cpu_index(cpu);
 327         ret = cpu_write_elf32_note(f, cpu, id, s);
 328         if (ret < 0) {
 329             error_setg(errp, "dump: failed to write elf notes");
 330             return;
 331         }
 332     }
 333
 334     CPU_FOREACH(cpu) {
 335         ret = cpu_write_elf32_qemunote(f, cpu, s);
 336         if (ret < 0) {
 337             error_setg(errp, "dump: failed to write CPU status");
 338             return;
 339         }
 340     }
 341
 342     write_guest_note(f, s, errp);
 343 }
 344
 345 static void write_elf_section(DumpState *s, int type, Error **errp)
 346 {
 347     Elf32_Shdr shdr32;
 348     Elf64_Shdr shdr64;
 349     int shdr_size;
 350     void *shdr;
 351     int ret;
 352
 353     if (type == 0) {
 354         shdr_size = sizeof(Elf32_Shdr);
 355         memset(&shdr32, 0, shdr_size);
 356         shdr32.sh_info = cpu_to_dump32(s, s->sh_info);
 357         shdr = &shdr32;
 358     } else {
 359         shdr_size = sizeof(Elf64_Shdr);
 360         memset(&shdr64, 0, shdr_size);
 361         shdr64.sh_info = cpu_to_dump32(s, s->sh_info);
 362         shdr = &shdr64;
 363     }
 364
 365     ret = fd_write_vmcore(&shdr, shdr_size, s);
 366     if (ret < 0) {
 367         error_setg_errno(errp, -ret,
 368                          "dump: failed to write section header table");
 369     }
 370 }
 371
 372 static void write_data(DumpState *s, void *buf, int length, Error **errp)
 373 {
 374     int ret;
 375
 376     ret = fd_write_vmcore(buf, length, s);
 377     if (ret < 0) {
 378         error_setg_errno(errp, -ret, "dump: failed to save memory");
 379     } else {
 380         s->written_size += length;
 381     }
 382 }
 383
 384 /* write the memory to vmcore. 1 page per I/O. */
 385 static void write_memory(DumpState *s, GuestPhysBlock *block, ram_addr_t start,
 386                          int64_t size, Error **errp)
 387 {
 388     int64_t i;
 389     Error *local_err = NULL;
 390
 391     for (i = 0; i < size / s->dump_info.page_size; i++) {
 392         write_data(s, block->host_addr + start + i * s->dump_info.page_size,
 393                    s->dump_info.page_size, &local_err);
 394         if (local_err) {
 395             error_propagate(errp, local_err);
 396             return;
 397         }
 398     }
 399
 400     if ((size % s->dump_info.page_size) != 0) {
 401         write_data(s, block->host_addr + start + i * s->dump_info.page_size,
 402                    size % s->dump_info.page_size, &local_err);
 403         if (local_err) {
 404             error_propagate(errp, local_err);
 405             return;
 406         }
 407     }
 408 }
 409
 410 /* get the memory's offset and size in the vmcore */
 411 static void get_offset_range(hwaddr phys_addr,
 412                              ram_addr_t mapping_length,
 413                              DumpState *s,
 414                              hwaddr *p_offset,
 415                              hwaddr *p_filesz)
 416 {
 417     GuestPhysBlock *block;
 418     hwaddr offset = s->memory_offset;
 419     int64_t size_in_block, start;
 420
 421     /* When the memory is not stored into vmcore, offset will be -1 */
 422     *p_offset = -1;
 423     *p_filesz = 0;
 424
 425     if (s->has_filter) {
 426         if (phys_addr < s->begin || phys_addr >= s->begin + s->length) {
 427             return;
 428         }
 429     }
 430
 431     QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
 432         if (s->has_filter) {
 433             if (block->target_start >= s->begin + s->length ||
 434                 block->target_end <= s->begin) {
 435                 /* This block is out of the range */
 436                 continue;
 437             }
 438
 439             if (s->begin <= block->target_start) {
 440                 start = block->target_start;
 441             } else {
 442                 start = s->begin;
 443             }
 444
 445             size_in_block = block->target_end - start;
 446             if (s->begin + s->length < block->target_end) {
 447                 size_in_block -= block->target_end - (s->begin + s->length);
 448             }
 449         } else {
 450             start = block->target_start;
 451             size_in_block = block->target_end - block->target_start;
 452         }
 453
 454         if (phys_addr >= start && phys_addr < start + size_in_block) {
 455             *p_offset = phys_addr - start + offset;
 456
 457             /* The offset range mapped from the vmcore file must not spill over
 458              * the GuestPhysBlock, clamp it. The rest of the mapping will be
 459              * zero-filled in memory at load time; see
 460              * <http://refspecs.linuxbase.org/elf/gabi4+/ch5.pheader.html>.
 461              */
 462             *p_filesz = phys_addr + mapping_length <= start + size_in_block ?
 463                         mapping_length :
 464                         size_in_block - (phys_addr - start);
 465             return;
 466         }
 467
 468         offset += size_in_block;
 469     }
 470 }
 471
 472 static void write_elf_loads(DumpState *s, Error **errp)
 473 {
 474     hwaddr offset, filesz;
 475     MemoryMapping *memory_mapping;
 476     uint32_t phdr_index = 1;
 477     uint32_t max_index;
 478     Error *local_err = NULL;
 479
 480     if (s->have_section) {
 481         max_index = s->sh_info;
 482     } else {
 483         max_index = s->phdr_num;
 484     }
 485
 486     QTAILQ_FOREACH(memory_mapping, &s->list.head, next) {
 487         get_offset_range(memory_mapping->phys_addr,
 488                          memory_mapping->length,
 489                          s, &offset, &filesz);
 490         if (s->dump_info.d_class == ELFCLASS64) {
 491             write_elf64_load(s, memory_mapping, phdr_index++, offset,
 492                              filesz, &local_err);
 493         } else {
 494             write_elf32_load(s, memory_mapping, phdr_index++, offset,
 495                              filesz, &local_err);
 496         }
 497
 498         if (local_err) {
 499             error_propagate(errp, local_err);
 500             return;
 501         }
 502
 503         if (phdr_index >= max_index) {
 504             break;
 505         }
 506     }
 507 }
 508
 509 /* write elf header, PT_NOTE and elf note to vmcore. */
 510 static void dump_begin(DumpState *s, Error **errp)
 511 {
 512     Error *local_err = NULL;
 513
 514     /*
 515      * the vmcore's format is:
 516      *   --------------
 517      *   |  elf header |
 518      *   --------------
 519      *   |  PT_NOTE    |
 520      *   --------------
 521      *   |  PT_LOAD    |
 522      *   --------------
 523      *   |  ......     |
 524      *   --------------
 525      *   |  PT_LOAD    |
 526      *   --------------
 527      *   |  sec_hdr    |
 528      *   --------------
 529      *   |  elf note   |
 530      *   --------------
 531      *   |  memory     |
 532      *   --------------
 533      *
 534      * we only know where the memory is saved after we write elf note into
 535      * vmcore.
 536      */
 537
 538     /* write elf header to vmcore */
 539     if (s->dump_info.d_class == ELFCLASS64) {
 540         write_elf64_header(s, &local_err);
 541     } else {
 542         write_elf32_header(s, &local_err);
 543     }
 544     if (local_err) {
 545         error_propagate(errp, local_err);
 546         return;
 547     }
 548
 549     if (s->dump_info.d_class == ELFCLASS64) {
 550         /* write PT_NOTE to vmcore */
 551         write_elf64_note(s, &local_err);
 552         if (local_err) {
 553             error_propagate(errp, local_err);
 554             return;
 555         }
 556
 557         /* write all PT_LOAD to vmcore */
 558         write_elf_loads(s, &local_err);
 559         if (local_err) {
 560             error_propagate(errp, local_err);
 561             return;
 562         }
 563
 564         /* write section to vmcore */
 565         if (s->have_section) {
 566             write_elf_section(s, 1, &local_err);
 567             if (local_err) {
 568                 error_propagate(errp, local_err);
 569                 return;
 570             }
 571         }
 572
 573         /* write notes to vmcore */
 574         write_elf64_notes(fd_write_vmcore, s, &local_err);
 575         if (local_err) {
 576             error_propagate(errp, local_err);
 577             return;
 578         }
 579     } else {
 580         /* write PT_NOTE to vmcore */
 581         write_elf32_note(s, &local_err);
 582         if (local_err) {
 583             error_propagate(errp, local_err);
 584             return;
 585         }
 586
 587         /* write all PT_LOAD to vmcore */
 588         write_elf_loads(s, &local_err);
 589         if (local_err) {
 590             error_propagate(errp, local_err);
 591             return;
 592         }
 593
 594         /* write section to vmcore */
 595         if (s->have_section) {
 596             write_elf_section(s, 0, &local_err);
 597             if (local_err) {
 598                 error_propagate(errp, local_err);
 599                 return;
 600             }
 601         }
 602
 603         /* write notes to vmcore */
 604         write_elf32_notes(fd_write_vmcore, s, &local_err);
 605         if (local_err) {
 606             error_propagate(errp, local_err);
 607             return;
 608         }
 609     }
 610 }
 611
 612 static int get_next_block(DumpState *s, GuestPhysBlock *block)
 613 {
 614     while (1) {
 615         block = QTAILQ_NEXT(block, next);
 616         if (!block) {
 617             /* no more block */
 618             return 1;
 619         }
 620
 621         s->start = 0;
 622         s->next_block = block;
 623         if (s->has_filter) {
 624             if (block->target_start >= s->begin + s->length ||
 625                 block->target_end <= s->begin) {
 626                 /* This block is out of the range */
 627                 continue;
 628             }
 629
 630             if (s->begin > block->target_start) {
 631                 s->start = s->begin - block->target_start;
 632             }
 633         }
 634
 635         return 0;
 636     }
 637 }
 638
 639 /* write all memory to vmcore */
 640 static void dump_iterate(DumpState *s, Error **errp)
 641 {
 642     GuestPhysBlock *block;
 643     int64_t size;
 644     Error *local_err = NULL;
 645
 646     do {
 647         block = s->next_block;
 648
 649         size = block->target_end - block->target_start;
 650         if (s->has_filter) {
 651             size -= s->start;
 652             if (s->begin + s->length < block->target_end) {
 653                 size -= block->target_end - (s->begin + s->length);
 654             }
 655         }
 656         write_memory(s, block, s->start, size, &local_err);
 657         if (local_err) {
 658             error_propagate(errp, local_err);
 659             return;
 660         }
 661
 662     } while (!get_next_block(s, block));
 663 }
 664
 665 static void create_vmcore(DumpState *s, Error **errp)
 666 {
 667     Error *local_err = NULL;
 668
 669     dump_begin(s, &local_err);
 670     if (local_err) {
 671         error_propagate(errp, local_err);
 672         return;
 673     }
 674
 675     dump_iterate(s, errp);
 676 }
 677
 678 static int write_start_flat_header(int fd)
 679 {
 680     MakedumpfileHeader *mh;
 681     int ret = 0;
 682
 683     QEMU_BUILD_BUG_ON(sizeof *mh > MAX_SIZE_MDF_HEADER);
 684     mh = g_malloc0(MAX_SIZE_MDF_HEADER);
 685
 686     memcpy(mh->signature, MAKEDUMPFILE_SIGNATURE,
 687            MIN(sizeof mh->signature, sizeof MAKEDUMPFILE_SIGNATURE));
 688
 689     mh->type = cpu_to_be64(TYPE_FLAT_HEADER);
 690     mh->version = cpu_to_be64(VERSION_FLAT_HEADER);
 691
 692     size_t written_size;
 693     written_size = qemu_write_full(fd, mh, MAX_SIZE_MDF_HEADER);
 694     if (written_size != MAX_SIZE_MDF_HEADER) {
 695         ret = -1;
 696     }
 697
 698     g_free(mh);
 699     return ret;
 700 }
 701
 702 static int write_end_flat_header(int fd)
 703 {
 704     MakedumpfileDataHeader mdh;
 705
 706     mdh.offset = END_FLAG_FLAT_HEADER;
 707     mdh.buf_size = END_FLAG_FLAT_HEADER;
 708
 709     size_t written_size;
 710     written_size = qemu_write_full(fd, &mdh, sizeof(mdh));
 711     if (written_size != sizeof(mdh)) {
 712         return -1;
 713     }
 714
 715     return 0;
 716 }
 717
 718 static int write_buffer(int fd, off_t offset, const void *buf, size_t size)
 719 {
 720     size_t written_size;
 721     MakedumpfileDataHeader mdh;
 722
 723     mdh.offset = cpu_to_be64(offset);
 724     mdh.buf_size = cpu_to_be64(size);
 725
 726     written_size = qemu_write_full(fd, &mdh, sizeof(mdh));
 727     if (written_size != sizeof(mdh)) {
 728         return -1;
 729     }
 730
 731     written_size = qemu_write_full(fd, buf, size);
 732     if (written_size != size) {
 733         return -1;
 734     }
 735
 736     return 0;
 737 }
 738
 739 static int buf_write_note(const void *buf, size_t size, void *opaque)
 740 {
 741     DumpState *s = opaque;
 742
 743     /* note_buf is not enough */
 744     if (s->note_buf_offset + size > s->note_size) {
 745         return -1;
 746     }
 747
 748     memcpy(s->note_buf + s->note_buf_offset, buf, size);
 749
 750     s->note_buf_offset += size;
 751
 752     return 0;
 753 }
 754
 755 /*
 756  * This function retrieves various sizes from an elf header.
 757  *
 758  * @note has to be a valid ELF note. The return sizes are unmodified
 759  * (not padded or rounded up to be multiple of 4).
 760  */
 761 static void get_note_sizes(DumpState *s, const void *note,
 762                            uint64_t *note_head_size,
 763                            uint64_t *name_size,
 764                            uint64_t *desc_size)
 765 {
 766     uint64_t note_head_sz;
 767     uint64_t name_sz;
 768     uint64_t desc_sz;
 769
 770     if (s->dump_info.d_class == ELFCLASS64) {
 771         const Elf64_Nhdr *hdr = note;
 772         note_head_sz = sizeof(Elf64_Nhdr);
 773         name_sz = tswap64(hdr->n_namesz);
 774         desc_sz = tswap64(hdr->n_descsz);
 775     } else {
 776         const Elf32_Nhdr *hdr = note;
 777         note_head_sz = sizeof(Elf32_Nhdr);
 778         name_sz = tswap32(hdr->n_namesz);
 779         desc_sz = tswap32(hdr->n_descsz);
 780     }
 781
 782     if (note_head_size) {
 783         *note_head_size = note_head_sz;
 784     }
 785     if (name_size) {
 786         *name_size = name_sz;
 787     }
 788     if (desc_size) {
 789         *desc_size = desc_sz;
 790     }
 791 }
 792
 793 static bool note_name_equal(DumpState *s,
 794                             const uint8_t *note, const char *name)
 795 {
 796     int len = strlen(name) + 1;
 797     uint64_t head_size, name_size;
 798
 799     get_note_sizes(s, note, &head_size, &name_size, NULL);
 800     head_size = ROUND_UP(head_size, 4);
 801
 802     return name_size == len && memcmp(note + head_size, name, len) == 0;
 803 }
 804
 805 /* write common header, sub header and elf note to vmcore */
 806 static void create_header32(DumpState *s, Error **errp)
 807 {
 808     DiskDumpHeader32 *dh = NULL;
 809     KdumpSubHeader32 *kh = NULL;
 810     size_t size;
 811     uint32_t block_size;
 812     uint32_t sub_hdr_size;
 813     uint32_t bitmap_blocks;
 814     uint32_t status = 0;
 815     uint64_t offset_note;
 816     Error *local_err = NULL;
 817
 818     /* write common header, the version of kdump-compressed format is 6th */
 819     size = sizeof(DiskDumpHeader32);
 820     dh = g_malloc0(size);
 821
 822     memcpy(dh->signature, KDUMP_SIGNATURE, SIG_LEN);
 823     dh->header_version = cpu_to_dump32(s, 6);
 824     block_size = s->dump_info.page_size;
 825     dh->block_size = cpu_to_dump32(s, block_size);
 826     sub_hdr_size = sizeof(struct KdumpSubHeader32) + s->note_size;
 827     sub_hdr_size = DIV_ROUND_UP(sub_hdr_size, block_size);
 828     dh->sub_hdr_size = cpu_to_dump32(s, sub_hdr_size);
 829     /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
 830     dh->max_mapnr = cpu_to_dump32(s, MIN(s->max_mapnr, UINT_MAX));
 831     dh->nr_cpus = cpu_to_dump32(s, s->nr_cpus);
 832     bitmap_blocks = DIV_ROUND_UP(s->len_dump_bitmap, block_size) * 2;
 833     dh->bitmap_blocks = cpu_to_dump32(s, bitmap_blocks);
 834     strncpy(dh->utsname.machine, ELF_MACHINE_UNAME, sizeof(dh->utsname.machine));
 835
 836     if (s->flag_compress & DUMP_DH_COMPRESSED_ZLIB) {
 837         status |= DUMP_DH_COMPRESSED_ZLIB;
 838     }
 839 #ifdef CONFIG_LZO
 840     if (s->flag_compress & DUMP_DH_COMPRESSED_LZO) {
 841         status |= DUMP_DH_COMPRESSED_LZO;
 842     }
 843 #endif
 844 #ifdef CONFIG_SNAPPY
 845     if (s->flag_compress & DUMP_DH_COMPRESSED_SNAPPY) {
 846         status |= DUMP_DH_COMPRESSED_SNAPPY;
 847     }
 848 #endif
 849     dh->status = cpu_to_dump32(s, status);
 850
 851     if (write_buffer(s->fd, 0, dh, size) < 0) {
 852         error_setg(errp, "dump: failed to write disk dump header");
 853         goto out;
 854     }
 855
 856     /* write sub header */
 857     size = sizeof(KdumpSubHeader32);
 858     kh = g_malloc0(size);
 859
 860     /* 64bit max_mapnr_64 */
 861     kh->max_mapnr_64 = cpu_to_dump64(s, s->max_mapnr);
 862     kh->phys_base = cpu_to_dump32(s, s->dump_info.phys_base);
 863     kh->dump_level = cpu_to_dump32(s, DUMP_LEVEL);
 864
 865     offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size;
 866     if (s->guest_note &&
 867         note_name_equal(s, s->guest_note, "VMCOREINFO")) {
 868         uint64_t hsize, name_size, size_vmcoreinfo_desc, offset_vmcoreinfo;
 869
 870         get_note_sizes(s, s->guest_note,
 871                        &hsize, &name_size, &size_vmcoreinfo_desc);
 872         offset_vmcoreinfo = offset_note + s->note_size - s->guest_note_size +
 873             (DIV_ROUND_UP(hsize, 4) + DIV_ROUND_UP(name_size, 4)) * 4;
 874         kh->offset_vmcoreinfo = cpu_to_dump64(s, offset_vmcoreinfo);
 875         kh->size_vmcoreinfo = cpu_to_dump32(s, size_vmcoreinfo_desc);
 876     }
 877
 878     kh->offset_note = cpu_to_dump64(s, offset_note);
 879     kh->note_size = cpu_to_dump32(s, s->note_size);
 880
 881     if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *
 882                      block_size, kh, size) < 0) {
 883         error_setg(errp, "dump: failed to write kdump sub header");
 884         goto out;
 885     }
 886
 887     /* write note */
 888     s->note_buf = g_malloc0(s->note_size);
 889     s->note_buf_offset = 0;
 890
 891     /* use s->note_buf to store notes temporarily */
 892     write_elf32_notes(buf_write_note, s, &local_err);
 893     if (local_err) {
 894         error_propagate(errp, local_err);
 895         goto out;
 896     }
 897     if (write_buffer(s->fd, offset_note, s->note_buf,
 898                      s->note_size) < 0) {
 899         error_setg(errp, "dump: failed to write notes");
 900         goto out;
 901     }
 902
 903     /* get offset of dump_bitmap */
 904     s->offset_dump_bitmap = (DISKDUMP_HEADER_BLOCKS + sub_hdr_size) *
 905                              block_size;
 906
 907     /* get offset of page */
 908     s->offset_page = (DISKDUMP_HEADER_BLOCKS + sub_hdr_size + bitmap_blocks) *
 909                      block_size;
 910
 911 out:
 912     g_free(dh);
 913     g_free(kh);
 914     g_free(s->note_buf);
 915 }
 916
 917 /* write common header, sub header and elf note to vmcore */
 918 static void create_header64(DumpState *s, Error **errp)
 919 {
 920     DiskDumpHeader64 *dh = NULL;
 921     KdumpSubHeader64 *kh = NULL;
 922     size_t size;
 923     uint32_t block_size;
 924     uint32_t sub_hdr_size;
 925     uint32_t bitmap_blocks;
 926     uint32_t status = 0;
 927     uint64_t offset_note;
 928     Error *local_err = NULL;
 929
 930     /* write common header, the version of kdump-compressed format is 6th */
 931     size = sizeof(DiskDumpHeader64);
 932     dh = g_malloc0(size);
 933
 934     memcpy(dh->signature, KDUMP_SIGNATURE, SIG_LEN);
 935     dh->header_version = cpu_to_dump32(s, 6);
 936     block_size = s->dump_info.page_size;
 937     dh->block_size = cpu_to_dump32(s, block_size);
 938     sub_hdr_size = sizeof(struct KdumpSubHeader64) + s->note_size;
 939     sub_hdr_size = DIV_ROUND_UP(sub_hdr_size, block_size);
 940     dh->sub_hdr_size = cpu_to_dump32(s, sub_hdr_size);
 941     /* dh->max_mapnr may be truncated, full 64bit is in kh.max_mapnr_64 */
 942     dh->max_mapnr = cpu_to_dump32(s, MIN(s->max_mapnr, UINT_MAX));
 943     dh->nr_cpus = cpu_to_dump32(s, s->nr_cpus);
 944     bitmap_blocks = DIV_ROUND_UP(s->len_dump_bitmap, block_size) * 2;
 945     dh->bitmap_blocks = cpu_to_dump32(s, bitmap_blocks);
 946     strncpy(dh->utsname.machine, ELF_MACHINE_UNAME, sizeof(dh->utsname.machine));
 947
 948     if (s->flag_compress & DUMP_DH_COMPRESSED_ZLIB) {
 949         status |= DUMP_DH_COMPRESSED_ZLIB;
 950     }
 951 #ifdef CONFIG_LZO
 952     if (s->flag_compress & DUMP_DH_COMPRESSED_LZO) {
 953         status |= DUMP_DH_COMPRESSED_LZO;
 954     }
 955 #endif
 956 #ifdef CONFIG_SNAPPY
 957     if (s->flag_compress & DUMP_DH_COMPRESSED_SNAPPY) {
 958         status |= DUMP_DH_COMPRESSED_SNAPPY;
 959     }
 960 #endif
 961     dh->status = cpu_to_dump32(s, status);
 962
 963     if (write_buffer(s->fd, 0, dh, size) < 0) {
 964         error_setg(errp, "dump: failed to write disk dump header");
 965         goto out;
 966     }
 967
 968     /* write sub header */
 969     size = sizeof(KdumpSubHeader64);
 970     kh = g_malloc0(size);
 971
 972     /* 64bit max_mapnr_64 */
 973     kh->max_mapnr_64 = cpu_to_dump64(s, s->max_mapnr);
 974     kh->phys_base = cpu_to_dump64(s, s->dump_info.phys_base);
 975     kh->dump_level = cpu_to_dump32(s, DUMP_LEVEL);
 976
 977     offset_note = DISKDUMP_HEADER_BLOCKS * block_size + size;
 978     if (s->guest_note &&
 979         note_name_equal(s, s->guest_note, "VMCOREINFO")) {
 980         uint64_t hsize, name_size, size_vmcoreinfo_desc, offset_vmcoreinfo;
 981
 982         get_note_sizes(s, s->guest_note,
 983                        &hsize, &name_size, &size_vmcoreinfo_desc);
 984         offset_vmcoreinfo = offset_note + s->note_size - s->guest_note_size +
 985             (DIV_ROUND_UP(hsize, 4) + DIV_ROUND_UP(name_size, 4)) * 4;
 986         kh->offset_vmcoreinfo = cpu_to_dump64(s, offset_vmcoreinfo);
 987         kh->size_vmcoreinfo = cpu_to_dump64(s, size_vmcoreinfo_desc);
 988     }
 989
 990     kh->offset_note = cpu_to_dump64(s, offset_note);
 991     kh->note_size = cpu_to_dump64(s, s->note_size);
 992
 993     if (write_buffer(s->fd, DISKDUMP_HEADER_BLOCKS *
 994                      block_size, kh, size) < 0) {
 995         error_setg(errp, "dump: failed to write kdump sub header");
 996         goto out;
 997     }
 998
 999     /* write note */
1000     s->note_buf = g_malloc0(s->note_size);
1001     s->note_buf_offset = 0;
1002
1003     /* use s->note_buf to store notes temporarily */
1004     write_elf64_notes(buf_write_note, s, &local_err);
1005     if (local_err) {
1006         error_propagate(errp, local_err);
1007         goto out;
1008     }
1009
1010     if (write_buffer(s->fd, offset_note, s->note_buf,
1011                      s->note_size) < 0) {
1012         error_setg(errp, "dump: failed to write notes");
1013         goto out;
1014     }
1015
1016     /* get offset of dump_bitmap */
1017     s->offset_dump_bitmap = (DISKDUMP_HEADER_BLOCKS + sub_hdr_size) *
1018                              block_size;
1019
1020     /* get offset of page */
1021     s->offset_page = (DISKDUMP_HEADER_BLOCKS + sub_hdr_size + bitmap_blocks) *
1022                      block_size;
1023
1024 out:
1025     g_free(dh);
1026     g_free(kh);
1027     g_free(s->note_buf);
1028 }
1029
1030 static void write_dump_header(DumpState *s, Error **errp)
1031 {
1032      Error *local_err = NULL;
1033
1034     if (s->dump_info.d_class == ELFCLASS32) {
1035         create_header32(s, &local_err);
1036     } else {
1037         create_header64(s, &local_err);
1038     }
1039     error_propagate(errp, local_err);
1040 }
1041
1042 static size_t dump_bitmap_get_bufsize(DumpState *s)
1043 {
1044     return s->dump_info.page_size;
1045 }
1046
1047 /*
1048  * set dump_bitmap sequencely. the bit before last_pfn is not allowed to be
1049  * rewritten, so if need to set the first bit, set last_pfn and pfn to 0.
1050  * set_dump_bitmap will always leave the recently set bit un-sync. And setting
1051  * (last bit + sizeof(buf) * 8) to 0 will do flushing the content in buf into
1052  * vmcore, ie. synchronizing un-sync bit into vmcore.
1053  */
1054 static int set_dump_bitmap(uint64_t last_pfn, uint64_t pfn, bool value,
1055                            uint8_t *buf, DumpState *s)
1056 {
1057     off_t old_offset, new_offset;
1058     off_t offset_bitmap1, offset_bitmap2;
1059     uint32_t byte, bit;
1060     size_t bitmap_bufsize = dump_bitmap_get_bufsize(s);
1061     size_t bits_per_buf = bitmap_bufsize * CHAR_BIT;
1062
1063     /* should not set the previous place */
1064     assert(last_pfn <= pfn);
1065
1066     /*
1067      * if the bit needed to be set is not cached in buf, flush the data in buf
1068      * to vmcore firstly.
1069      * making new_offset be bigger than old_offset can also sync remained data
1070      * into vmcore.
1071      */
1072     old_offset = bitmap_bufsize * (last_pfn / bits_per_buf);
1073     new_offset = bitmap_bufsize * (pfn / bits_per_buf);
1074
1075     while (old_offset < new_offset) {
1076         /* calculate the offset and write dump_bitmap */
1077         offset_bitmap1 = s->offset_dump_bitmap + old_offset;
1078         if (write_buffer(s->fd, offset_bitmap1, buf,
1079                          bitmap_bufsize) < 0) {
1080             return -1;
1081         }
1082
1083         /* dump level 1 is chosen, so 1st and 2nd bitmap are same */
1084         offset_bitmap2 = s->offset_dump_bitmap + s->len_dump_bitmap +
1085                          old_offset;
1086         if (write_buffer(s->fd, offset_bitmap2, buf,
1087                          bitmap_bufsize) < 0) {
1088             return -1;
1089         }
1090
1091         memset(buf, 0, bitmap_bufsize);
1092         old_offset += bitmap_bufsize;
1093     }
1094
1095     /* get the exact place of the bit in the buf, and set it */
1096     byte = (pfn % bits_per_buf) / CHAR_BIT;
1097     bit = (pfn % bits_per_buf) % CHAR_BIT;
1098     if (value) {
1099         buf[byte] |= 1u << bit;
1100     } else {
1101         buf[byte] &= ~(1u << bit);
1102     }
1103
1104     return 0;
1105 }
1106
1107 static uint64_t dump_paddr_to_pfn(DumpState *s, uint64_t addr)
1108 {
1109     int target_page_shift = ctz32(s->dump_info.page_size);
1110
1111     return (addr >> target_page_shift) - ARCH_PFN_OFFSET;
1112 }
1113
1114 static uint64_t dump_pfn_to_paddr(DumpState *s, uint64_t pfn)
1115 {
1116     int target_page_shift = ctz32(s->dump_info.page_size);
1117
1118     return (pfn + ARCH_PFN_OFFSET) << target_page_shift;
1119 }
1120
1121 /*
1122  * exam every page and return the page frame number and the address of the page.
1123  * bufptr can be NULL. note: the blocks here is supposed to reflect guest-phys
1124  * blocks, so block->target_start and block->target_end should be interal
1125  * multiples of the target page size.
1126  */
1127 static bool get_next_page(GuestPhysBlock **blockptr, uint64_t *pfnptr,
1128                           uint8_t **bufptr, DumpState *s)
1129 {
1130     GuestPhysBlock *block = *blockptr;
1131     hwaddr addr, target_page_mask = ~((hwaddr)s->dump_info.page_size - 1);
1132     uint8_t *buf;
1133
1134     /* block == NULL means the start of the iteration */
1135     if (!block) {
1136         block = QTAILQ_FIRST(&s->guest_phys_blocks.head);
1137         *blockptr = block;
1138         assert((block->target_start & ~target_page_mask) == 0);
1139         assert((block->target_end & ~target_page_mask) == 0);
1140         *pfnptr = dump_paddr_to_pfn(s, block->target_start);
1141         if (bufptr) {
1142             *bufptr = block->host_addr;
1143         }
1144         return true;
1145     }
1146
1147     *pfnptr = *pfnptr + 1;
1148     addr = dump_pfn_to_paddr(s, *pfnptr);
1149
1150     if ((addr >= block->target_start) &&
1151         (addr + s->dump_info.page_size <= block->target_end)) {
1152         buf = block->host_addr + (addr - block->target_start);
1153     } else {
1154         /* the next page is in the next block */
1155         block = QTAILQ_NEXT(block, next);
1156         *blockptr = block;
1157         if (!block) {
1158             return false;
1159         }
1160         assert((block->target_start & ~target_page_mask) == 0);
1161         assert((block->target_end & ~target_page_mask) == 0);
1162         *pfnptr = dump_paddr_to_pfn(s, block->target_start);
1163         buf = block->host_addr;
1164     }
1165
1166     if (bufptr) {
1167         *bufptr = buf;
1168     }
1169
1170     return true;
1171 }
1172
1173 static void write_dump_bitmap(DumpState *s, Error **errp)
1174 {
1175     int ret = 0;
1176     uint64_t last_pfn, pfn;
1177     void *dump_bitmap_buf;
1178     size_t num_dumpable;
1179     GuestPhysBlock *block_iter = NULL;
1180     size_t bitmap_bufsize = dump_bitmap_get_bufsize(s);
1181     size_t bits_per_buf = bitmap_bufsize * CHAR_BIT;
1182
1183     /* dump_bitmap_buf is used to store dump_bitmap temporarily */
1184     dump_bitmap_buf = g_malloc0(bitmap_bufsize);
1185
1186     num_dumpable = 0;
1187     last_pfn = 0;
1188
1189     /*
1190      * exam memory page by page, and set the bit in dump_bitmap corresponded
1191      * to the existing page.
1192      */
1193     while (get_next_page(&block_iter, &pfn, NULL, s)) {
1194         ret = set_dump_bitmap(last_pfn, pfn, true, dump_bitmap_buf, s);
1195         if (ret < 0) {
1196             error_setg(errp, "dump: failed to set dump_bitmap");
1197             goto out;
1198         }
1199
1200         last_pfn = pfn;
1201         num_dumpable++;
1202     }
1203
1204     /*
1205      * set_dump_bitmap will always leave the recently set bit un-sync. Here we
1206      * set the remaining bits from last_pfn to the end of the bitmap buffer to
1207      * 0. With those set, the un-sync bit will be synchronized into the vmcore.
1208      */
1209     if (num_dumpable > 0) {
1210         ret = set_dump_bitmap(last_pfn, last_pfn + bits_per_buf, false,
1211                               dump_bitmap_buf, s);
1212         if (ret < 0) {
1213             error_setg(errp, "dump: failed to sync dump_bitmap");
1214             goto out;
1215         }
1216     }
1217
1218     /* number of dumpable pages that will be dumped later */
1219     s->num_dumpable = num_dumpable;
1220
1221 out:
1222     g_free(dump_bitmap_buf);
1223 }
1224
1225 static void prepare_data_cache(DataCache *data_cache, DumpState *s,
1226                                off_t offset)
1227 {
1228     data_cache->fd = s->fd;
1229     data_cache->data_size = 0;
1230     data_cache->buf_size = 4 * dump_bitmap_get_bufsize(s);
1231     data_cache->buf = g_malloc0(data_cache->buf_size);
1232     data_cache->offset = offset;
1233 }
1234
1235 static int write_cache(DataCache *dc, const void *buf, size_t size,
1236                        bool flag_sync)
1237 {
1238     /*
1239      * dc->buf_size should not be less than size, otherwise dc will never be
1240      * enough
1241      */
1242     assert(size <= dc->buf_size);
1243
1244     /*
1245      * if flag_sync is set, synchronize data in dc->buf into vmcore.
1246      * otherwise check if the space is enough for caching data in buf, if not,
1247      * write the data in dc->buf to dc->fd and reset dc->buf
1248      */
1249     if ((!flag_sync && dc->data_size + size > dc->buf_size) ||
1250         (flag_sync && dc->data_size > 0)) {
1251         if (write_buffer(dc->fd, dc->offset, dc->buf, dc->data_size) < 0) {
1252             return -1;
1253         }
1254
1255         dc->offset += dc->data_size;
1256         dc->data_size = 0;
1257     }
1258
1259     if (!flag_sync) {
1260         memcpy(dc->buf + dc->data_size, buf, size);
1261         dc->data_size += size;
1262     }
1263
1264     return 0;
1265 }
1266
1267 static void free_data_cache(DataCache *data_cache)
1268 {
1269     g_free(data_cache->buf);
1270 }
1271
1272 static size_t get_len_buf_out(size_t page_size, uint32_t flag_compress)
1273 {
1274     switch (flag_compress) {
1275     case DUMP_DH_COMPRESSED_ZLIB:
1276         return compressBound(page_size);
1277
1278     case DUMP_DH_COMPRESSED_LZO:
1279         /*
1280          * LZO will expand incompressible data by a little amount. Please check
1281          * the following URL to see the expansion calculation:
1282          * http://www.oberhumer.com/opensource/lzo/lzofaq.php
1283          */
1284         return page_size + page_size / 16 + 64 + 3;
1285
1286 #ifdef CONFIG_SNAPPY
1287     case DUMP_DH_COMPRESSED_SNAPPY:
1288         return snappy_max_compressed_length(page_size);
1289 #endif
1290     }
1291     return 0;
1292 }
1293
1294 /*
1295  * check if the page is all 0
1296  */
1297 static inline bool is_zero_page(const uint8_t *buf, size_t page_size)
1298 {
1299     return buffer_is_zero(buf, page_size);
1300 }
1301
1302 static void write_dump_pages(DumpState *s, Error **errp)
1303 {
1304     int ret = 0;
1305     DataCache page_desc, page_data;
1306     size_t len_buf_out, size_out;
1307 #ifdef CONFIG_LZO
1308     lzo_bytep wrkmem = NULL;
1309 #endif
1310     uint8_t *buf_out = NULL;
1311     off_t offset_desc, offset_data;
1312     PageDescriptor pd, pd_zero;
1313     uint8_t *buf;
1314     GuestPhysBlock *block_iter = NULL;
1315     uint64_t pfn_iter;
1316
1317     /* get offset of page_desc and page_data in dump file */
1318     offset_desc = s->offset_page;
1319     offset_data = offset_desc + sizeof(PageDescriptor) * s->num_dumpable;
1320
1321     prepare_data_cache(&page_desc, s, offset_desc);
1322     prepare_data_cache(&page_data, s, offset_data);
1323
1324     /* prepare buffer to store compressed data */
1325     len_buf_out = get_len_buf_out(s->dump_info.page_size, s->flag_compress);
1326     assert(len_buf_out != 0);
1327
1328 #ifdef CONFIG_LZO
1329     wrkmem = g_malloc(LZO1X_1_MEM_COMPRESS);
1330 #endif
1331
1332     buf_out = g_malloc(len_buf_out);
1333
1334     /*
1335      * init zero page's page_desc and page_data, because every zero page
1336      * uses the same page_data
1337      */
1338     pd_zero.size = cpu_to_dump32(s, s->dump_info.page_size);
1339     pd_zero.flags = cpu_to_dump32(s, 0);
1340     pd_zero.offset = cpu_to_dump64(s, offset_data);
1341     pd_zero.page_flags = cpu_to_dump64(s, 0);
1342     buf = g_malloc0(s->dump_info.page_size);
1343     ret = write_cache(&page_data, buf, s->dump_info.page_size, false);
1344     g_free(buf);
1345     if (ret < 0) {
1346         error_setg(errp, "dump: failed to write page data (zero page)");
1347         goto out;
1348     }
1349
1350     offset_data += s->dump_info.page_size;
1351
1352     /*
1353      * dump memory to vmcore page by page. zero page will all be resided in the
1354      * first page of page section
1355      */
1356     while (get_next_page(&block_iter, &pfn_iter, &buf, s)) {
1357         /* check zero page */
1358         if (is_zero_page(buf, s->dump_info.page_size)) {
1359             ret = write_cache(&page_desc, &pd_zero, sizeof(PageDescriptor),
1360                               false);
1361             if (ret < 0) {
1362                 error_setg(errp, "dump: failed to write page desc");
1363                 goto out;
1364             }
1365         } else {
1366             /*
1367              * not zero page, then:
1368              * 1. compress the page
1369              * 2. write the compressed page into the cache of page_data
1370              * 3. get page desc of the compressed page and write it into the
1371              *    cache of page_desc
1372              *
1373              * only one compression format will be used here, for
1374              * s->flag_compress is set. But when compression fails to work,
1375              * we fall back to save in plaintext.
1376              */
1377              size_out = len_buf_out;
1378              if ((s->flag_compress & DUMP_DH_COMPRESSED_ZLIB) &&
1379                     (compress2(buf_out, (uLongf *)&size_out, buf,
1380                                s->dump_info.page_size, Z_BEST_SPEED) == Z_OK) &&
1381                     (size_out < s->dump_info.page_size)) {
1382                 pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_ZLIB);
1383                 pd.size  = cpu_to_dump32(s, size_out);
1384
1385                 ret = write_cache(&page_data, buf_out, size_out, false);
1386                 if (ret < 0) {
1387                     error_setg(errp, "dump: failed to write page data");
1388                     goto out;
1389                 }
1390 #ifdef CONFIG_LZO
1391             } else if ((s->flag_compress & DUMP_DH_COMPRESSED_LZO) &&
1392                     (lzo1x_1_compress(buf, s->dump_info.page_size, buf_out,
1393                     (lzo_uint *)&size_out, wrkmem) == LZO_E_OK) &&
1394                     (size_out < s->dump_info.page_size)) {
1395                 pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_LZO);
1396                 pd.size  = cpu_to_dump32(s, size_out);
1397
1398                 ret = write_cache(&page_data, buf_out, size_out, false);
1399                 if (ret < 0) {
1400                     error_setg(errp, "dump: failed to write page data");
1401                     goto out;
1402                 }
1403 #endif
1404 #ifdef CONFIG_SNAPPY
1405             } else if ((s->flag_compress & DUMP_DH_COMPRESSED_SNAPPY) &&
1406                     (snappy_compress((char *)buf, s->dump_info.page_size,
1407                     (char *)buf_out, &size_out) == SNAPPY_OK) &&
1408                     (size_out < s->dump_info.page_size)) {
1409                 pd.flags = cpu_to_dump32(s, DUMP_DH_COMPRESSED_SNAPPY);
1410                 pd.size  = cpu_to_dump32(s, size_out);
1411
1412                 ret = write_cache(&page_data, buf_out, size_out, false);
1413                 if (ret < 0) {
1414                     error_setg(errp, "dump: failed to write page data");
1415                     goto out;
1416                 }
1417 #endif
1418             } else {
1419                 /*
1420                  * fall back to save in plaintext, size_out should be
1421                  * assigned the target's page size
1422                  */
1423                 pd.flags = cpu_to_dump32(s, 0);
1424                 size_out = s->dump_info.page_size;
1425                 pd.size = cpu_to_dump32(s, size_out);
1426
1427                 ret = write_cache(&page_data, buf,
1428                                   s->dump_info.page_size, false);
1429                 if (ret < 0) {
1430                     error_setg(errp, "dump: failed to write page data");
1431                     goto out;
1432                 }
1433             }
1434
1435             /* get and write page desc here */
1436             pd.page_flags = cpu_to_dump64(s, 0);
1437             pd.offset = cpu_to_dump64(s, offset_data);
1438             offset_data += size_out;
1439
1440             ret = write_cache(&page_desc, &pd, sizeof(PageDescriptor), false);
1441             if (ret < 0) {
1442                 error_setg(errp, "dump: failed to write page desc");
1443                 goto out;
1444             }
1445         }
1446         s->written_size += s->dump_info.page_size;
1447     }
1448
1449     ret = write_cache(&page_desc, NULL, 0, true);
1450     if (ret < 0) {
1451         error_setg(errp, "dump: failed to sync cache for page_desc");
1452         goto out;
1453     }
1454     ret = write_cache(&page_data, NULL, 0, true);
1455     if (ret < 0) {
1456         error_setg(errp, "dump: failed to sync cache for page_data");
1457         goto out;
1458     }
1459
1460 out:
1461     free_data_cache(&page_desc);
1462     free_data_cache(&page_data);
1463
1464 #ifdef CONFIG_LZO
1465     g_free(wrkmem);
1466 #endif
1467
1468     g_free(buf_out);
1469 }
1470
1471 static void create_kdump_vmcore(DumpState *s, Error **errp)
1472 {
1473     int ret;
1474     Error *local_err = NULL;
1475
1476     /*
1477      * the kdump-compressed format is:
1478      *                                               File offset
1479      *  +------------------------------------------+ 0x0
1480      *  |    main header (struct disk_dump_header) |
1481      *  |------------------------------------------+ block 1
1482      *  |    sub header (struct kdump_sub_header)  |
1483      *  |------------------------------------------+ block 2
1484      *  |            1st-dump_bitmap               |
1485      *  |------------------------------------------+ block 2 + X blocks
1486      *  |            2nd-dump_bitmap               | (aligned by block)
1487      *  |------------------------------------------+ block 2 + 2 * X blocks
1488      *  |  page desc for pfn 0 (struct page_desc)  | (aligned by block)
1489      *  |  page desc for pfn 1 (struct page_desc)  |
1490      *  |                    :                     |
1491      *  |------------------------------------------| (not aligned by block)
1492      *  |         page data (pfn 0)                |
1493      *  |         page data (pfn 1)                |
1494      *  |                    :                     |
1495      *  +------------------------------------------+
1496      */
1497
1498     ret = write_start_flat_header(s->fd);
1499     if (ret < 0) {
1500         error_setg(errp, "dump: failed to write start flat header");
1501         return;
1502     }
1503
1504     write_dump_header(s, &local_err);
1505     if (local_err) {
1506         error_propagate(errp, local_err);
1507         return;
1508     }
1509
1510     write_dump_bitmap(s, &local_err);
1511     if (local_err) {
1512         error_propagate(errp, local_err);
1513         return;
1514     }
1515
1516     write_dump_pages(s, &local_err);
1517     if (local_err) {
1518         error_propagate(errp, local_err);
1519         return;
1520     }
1521
1522     ret = write_end_flat_header(s->fd);
1523     if (ret < 0) {
1524         error_setg(errp, "dump: failed to write end flat header");
1525         return;
1526     }
1527 }
1528
1529 static ram_addr_t get_start_block(DumpState *s)
1530 {
1531     GuestPhysBlock *block;
1532
1533     if (!s->has_filter) {
1534         s->next_block = QTAILQ_FIRST(&s->guest_phys_blocks.head);
1535         return 0;
1536     }
1537
1538     QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
1539         if (block->target_start >= s->begin + s->length ||
1540             block->target_end <= s->begin) {
1541             /* This block is out of the range */
1542             continue;
1543         }
1544
1545         s->next_block = block;
1546         if (s->begin > block->target_start) {
1547             s->start = s->begin - block->target_start;
1548         } else {
1549             s->start = 0;
1550         }
1551         return s->start;
1552     }
1553
1554     return -1;
1555 }
1556
1557 static void get_max_mapnr(DumpState *s)
1558 {
1559     GuestPhysBlock *last_block;
1560
1561     last_block = QTAILQ_LAST(&s->guest_phys_blocks.head);
1562     s->max_mapnr = dump_paddr_to_pfn(s, last_block->target_end);
1563 }
1564
1565 static DumpState dump_state_global = { .status = DUMP_STATUS_NONE };
1566
1567 static void dump_state_prepare(DumpState *s)
1568 {
1569     /* zero the struct, setting status to active */
1570     *s = (DumpState) { .status = DUMP_STATUS_ACTIVE };
1571 }
1572
1573 bool dump_in_progress(void)
1574 {
1575     DumpState *state = &dump_state_global;
1576     return (atomic_read(&state->status) == DUMP_STATUS_ACTIVE);
1577 }
1578
1579 /* calculate total size of memory to be dumped (taking filter into
1580  * acoount.) */
1581 static int64_t dump_calculate_size(DumpState *s)
1582 {
1583     GuestPhysBlock *block;
1584     int64_t size = 0, total = 0, left = 0, right = 0;
1585
1586     QTAILQ_FOREACH(block, &s->guest_phys_blocks.head, next) {
1587         if (s->has_filter) {
1588             /* calculate the overlapped region. */
1589             left = MAX(s->begin, block->target_start);
1590             right = MIN(s->begin + s->length, block->target_end);
1591             size = right - left;
1592             size = size > 0 ? size : 0;
1593         } else {
1594             /* count the whole region in */
1595             size = (block->target_end - block->target_start);
1596         }
1597         total += size;
1598     }
1599
1600     return total;
1601 }
1602
1603 static void vmcoreinfo_update_phys_base(DumpState *s)
1604 {
1605     uint64_t size, note_head_size, name_size, phys_base;
1606     char **lines;
1607     uint8_t *vmci;
1608     size_t i;
1609
1610     if (!note_name_equal(s, s->guest_note, "VMCOREINFO")) {
1611         return;
1612     }
1613
1614     get_note_sizes(s, s->guest_note, &note_head_size, &name_size, &size);
1615     note_head_size = ROUND_UP(note_head_size, 4);
1616
1617     vmci = s->guest_note + note_head_size + ROUND_UP(name_size, 4);
1618     *(vmci + size) = '\0';
1619
1620     lines = g_strsplit((char *)vmci, "\n", -1);
1621     for (i = 0; lines[i]; i++) {
1622         const char *prefix = NULL;
1623
1624         if (s->dump_info.d_machine == EM_X86_64) {
1625             prefix = "NUMBER(phys_base)=";
1626         } else if (s->dump_info.d_machine == EM_AARCH64) {
1627             prefix = "NUMBER(PHYS_OFFSET)=";
1628         }
1629
1630         if (prefix && g_str_has_prefix(lines[i], prefix)) {
1631             if (qemu_strtou64(lines[i] + strlen(prefix), NULL, 16,
1632                               &phys_base) < 0) {
1633                 warn_report("Failed to read %s", prefix);
1634             } else {
1635                 s->dump_info.phys_base = phys_base;
1636             }
1637             break;
1638         }
1639     }
1640
1641     g_strfreev(lines);
1642 }
1643
1644 static void dump_init(DumpState *s, int fd, bool has_format,
1645                       DumpGuestMemoryFormat format, bool paging, bool has_filter,
1646                       int64_t begin, int64_t length, Error **errp)
1647 {
1648     VMCoreInfoState *vmci = vmcoreinfo_find();
1649     CPUState *cpu;
1650     int nr_cpus;
1651     Error *err = NULL;
1652     int ret;
1653
1654     s->has_format = has_format;
1655     s->format = format;
1656     s->written_size = 0;
1657
1658     /* kdump-compressed is conflict with paging and filter */
1659     if (has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) {
1660         assert(!paging && !has_filter);
1661     }
1662
1663     if (runstate_is_running()) {
1664         vm_stop(RUN_STATE_SAVE_VM);
1665         s->resume = true;
1666     } else {
1667         s->resume = false;
1668     }
1669
1670     /* If we use KVM, we should synchronize the registers before we get dump
1671      * info or physmap info.
1672      */
1673     cpu_synchronize_all_states();
1674     nr_cpus = 0;
1675     CPU_FOREACH(cpu) {
1676         nr_cpus++;
1677     }
1678
1679     s->fd = fd;
1680     s->has_filter = has_filter;
1681     s->begin = begin;
1682     s->length = length;
1683
1684     memory_mapping_list_init(&s->list);
1685
1686     guest_phys_blocks_init(&s->guest_phys_blocks);
1687     guest_phys_blocks_append(&s->guest_phys_blocks);
1688     s->total_size = dump_calculate_size(s);
1689 #ifdef DEBUG_DUMP_GUEST_MEMORY
1690     fprintf(stderr, "DUMP: total memory to dump: %lu\n", s->total_size);
1691 #endif
1692
1693     /* it does not make sense to dump non-existent memory */
1694     if (!s->total_size) {
1695         error_setg(errp, "dump: no guest memory to dump");
1696         goto cleanup;
1697     }
1698
1699     s->start = get_start_block(s);
1700     if (s->start == -1) {
1701         error_setg(errp, QERR_INVALID_PARAMETER, "begin");
1702         goto cleanup;
1703     }
1704
1705     /* get dump info: endian, class and architecture.
1706      * If the target architecture is not supported, cpu_get_dump_info() will
1707      * return -1.
1708      */
1709     ret = cpu_get_dump_info(&s->dump_info, &s->guest_phys_blocks);
1710     if (ret < 0) {
1711         error_setg(errp, QERR_UNSUPPORTED);
1712         goto cleanup;
1713     }
1714
1715     if (!s->dump_info.page_size) {
1716         s->dump_info.page_size = TARGET_PAGE_SIZE;
1717     }
1718
1719     s->note_size = cpu_get_note_size(s->dump_info.d_class,
1720                                      s->dump_info.d_machine, nr_cpus);
1721     if (s->note_size < 0) {
1722         error_setg(errp, QERR_UNSUPPORTED);
1723         goto cleanup;
1724     }
1725
1726     /*
1727      * The goal of this block is to (a) update the previously guessed
1728      * phys_base, (b) copy the guest note out of the guest.
1729      * Failure to do so is not fatal for dumping.
1730      */
1731     if (vmci) {
1732         uint64_t addr, note_head_size, name_size, desc_size;
1733         uint32_t size;
1734         uint16_t format;
1735
1736         note_head_size = s->dump_info.d_class == ELFCLASS32 ?
1737             sizeof(Elf32_Nhdr) : sizeof(Elf64_Nhdr);
1738
1739         format = le16_to_cpu(vmci->vmcoreinfo.guest_format);
1740         size = le32_to_cpu(vmci->vmcoreinfo.size);
1741         addr = le64_to_cpu(vmci->vmcoreinfo.paddr);
1742         if (!vmci->has_vmcoreinfo) {
1743             warn_report("guest note is not present");
1744         } else if (size < note_head_size || size > MAX_GUEST_NOTE_SIZE) {
1745             warn_report("guest note size is invalid: %" PRIu32, size);
1746         } else if (format != FW_CFG_VMCOREINFO_FORMAT_ELF) {
1747             warn_report("guest note format is unsupported: %" PRIu16, format);
1748         } else {
1749             s->guest_note = g_malloc(size + 1); /* +1 for adding \0 */
1750             cpu_physical_memory_read(addr, s->guest_note, size);
1751
1752             get_note_sizes(s, s->guest_note, NULL, &name_size, &desc_size);
1753             s->guest_note_size = ELF_NOTE_SIZE(note_head_size, name_size,
1754                                                desc_size);
1755             if (name_size > MAX_GUEST_NOTE_SIZE ||
1756                 desc_size > MAX_GUEST_NOTE_SIZE ||
1757                 s->guest_note_size > size) {
1758                 warn_report("Invalid guest note header");
1759                 g_free(s->guest_note);
1760                 s->guest_note = NULL;
1761             } else {
1762                 vmcoreinfo_update_phys_base(s);
1763                 s->note_size += s->guest_note_size;
1764             }
1765         }
1766     }
1767
1768     /* get memory mapping */
1769     if (paging) {
1770         qemu_get_guest_memory_mapping(&s->list, &s->guest_phys_blocks, &err);
1771         if (err != NULL) {
1772             error_propagate(errp, err);
1773             goto cleanup;
1774         }
1775     } else {
1776         qemu_get_guest_simple_memory_mapping(&s->list, &s->guest_phys_blocks);
1777     }
1778
1779     s->nr_cpus = nr_cpus;
1780
1781     get_max_mapnr(s);
1782
1783     uint64_t tmp;
1784     tmp = DIV_ROUND_UP(DIV_ROUND_UP(s->max_mapnr, CHAR_BIT),
1785                        s->dump_info.page_size);
1786     s->len_dump_bitmap = tmp * s->dump_info.page_size;
1787
1788     /* init for kdump-compressed format */
1789     if (has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) {
1790         switch (format) {
1791         case DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB:
1792             s->flag_compress = DUMP_DH_COMPRESSED_ZLIB;
1793             break;
1794
1795         case DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO:
1796 #ifdef CONFIG_LZO
1797             if (lzo_init() != LZO_E_OK) {
1798                 error_setg(errp, "failed to initialize the LZO library");
1799                 goto cleanup;
1800             }
1801 #endif
1802             s->flag_compress = DUMP_DH_COMPRESSED_LZO;
1803             break;
1804
1805         case DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY:
1806             s->flag_compress = DUMP_DH_COMPRESSED_SNAPPY;
1807             break;
1808
1809         default:
1810             s->flag_compress = 0;
1811         }
1812
1813         return;
1814     }
1815
1816     if (s->has_filter) {
1817         memory_mapping_filter(&s->list, s->begin, s->length);
1818     }
1819
1820     /*
1821      * calculate phdr_num
1822      *
1823      * the type of ehdr->e_phnum is uint16_t, so we should avoid overflow
1824      */
1825     s->phdr_num = 1; /* PT_NOTE */
1826     if (s->list.num < UINT16_MAX - 2) {
1827         s->phdr_num += s->list.num;
1828         s->have_section = false;
1829     } else {
1830         s->have_section = true;
1831         s->phdr_num = PN_XNUM;
1832         s->sh_info = 1; /* PT_NOTE */
1833
1834         /* the type of shdr->sh_info is uint32_t, so we should avoid overflow */
1835         if (s->list.num <= UINT32_MAX - 1) {
1836             s->sh_info += s->list.num;
1837         } else {
1838             s->sh_info = UINT32_MAX;
1839         }
1840     }
1841
1842     if (s->dump_info.d_class == ELFCLASS64) {
1843         if (s->have_section) {
1844             s->memory_offset = sizeof(Elf64_Ehdr) +
1845                                sizeof(Elf64_Phdr) * s->sh_info +
1846                                sizeof(Elf64_Shdr) + s->note_size;
1847         } else {
1848             s->memory_offset = sizeof(Elf64_Ehdr) +
1849                                sizeof(Elf64_Phdr) * s->phdr_num + s->note_size;
1850         }
1851     } else {
1852         if (s->have_section) {
1853             s->memory_offset = sizeof(Elf32_Ehdr) +
1854                                sizeof(Elf32_Phdr) * s->sh_info +
1855                                sizeof(Elf32_Shdr) + s->note_size;
1856         } else {
1857             s->memory_offset = sizeof(Elf32_Ehdr) +
1858                                sizeof(Elf32_Phdr) * s->phdr_num + s->note_size;
1859         }
1860     }
1861
1862     return;
1863
1864 cleanup:
1865     dump_cleanup(s);
1866 }
1867
1868 /* this operation might be time consuming. */
1869 static void dump_process(DumpState *s, Error **errp)
1870 {
1871     Error *local_err = NULL;
1872     DumpQueryResult *result = NULL;
1873
1874     if (s->has_format && s->format == DUMP_GUEST_MEMORY_FORMAT_WIN_DMP) {
1875 #ifdef TARGET_X86_64
1876         create_win_dump(s, &local_err);
1877 #endif
1878     } else if (s->has_format && s->format != DUMP_GUEST_MEMORY_FORMAT_ELF) {
1879         create_kdump_vmcore(s, &local_err);
1880     } else {
1881         create_vmcore(s, &local_err);
1882     }
1883
1884     /* make sure status is written after written_size updates */
1885     smp_wmb();
1886     atomic_set(&s->status,
1887                (local_err ? DUMP_STATUS_FAILED : DUMP_STATUS_COMPLETED));
1888
1889     /* send DUMP_COMPLETED message (unconditionally) */
1890     result = qmp_query_dump(NULL);
1891     /* should never fail */
1892     assert(result);
1893     qapi_event_send_dump_completed(result, !!local_err, (local_err ? \
1894                                    error_get_pretty(local_err) : NULL));
1895     qapi_free_DumpQueryResult(result);
1896
1897     error_propagate(errp, local_err);
1898     dump_cleanup(s);
1899 }
1900
1901 static void *dump_thread(void *data)
1902 {
1903     DumpState *s = (DumpState *)data;
1904     dump_process(s, NULL);
1905     return NULL;
1906 }
1907
1908 DumpQueryResult *qmp_query_dump(Error **errp)
1909 {
1910     DumpQueryResult *result = g_new(DumpQueryResult, 1);
1911     DumpState *state = &dump_state_global;
1912     result->status = atomic_read(&state->status);
1913     /* make sure we are reading status and written_size in order */
1914     smp_rmb();
1915     result->completed = state->written_size;
1916     result->total = state->total_size;
1917     return result;
1918 }
1919
1920 void qmp_dump_guest_memory(bool paging, const char *file,
1921                            bool has_detach, bool detach,
1922                            bool has_begin, int64_t begin, bool has_length,
1923                            int64_t length, bool has_format,
1924                            DumpGuestMemoryFormat format, Error **errp)
1925 {
1926     const char *p;
1927     int fd = -1;
1928     DumpState *s;
1929     Error *local_err = NULL;
1930     bool detach_p = false;
1931
1932     if (runstate_check(RUN_STATE_INMIGRATE)) {
1933         error_setg(errp, "Dump not allowed during incoming migration.");
1934         return;
1935     }
1936
1937     /* if there is a dump in background, we should wait until the dump
1938      * finished */
1939     if (dump_in_progress()) {
1940         error_setg(errp, "There is a dump in process, please wait.");
1941         return;
1942     }
1943
1944     /*
1945      * kdump-compressed format need the whole memory dumped, so paging or
1946      * filter is not supported here.
1947      */
1948     if ((has_format && format != DUMP_GUEST_MEMORY_FORMAT_ELF) &&
1949         (paging || has_begin || has_length)) {
1950         error_setg(errp, "kdump-compressed format doesn't support paging or "
1951                          "filter");
1952         return;
1953     }
1954     if (has_begin && !has_length) {
1955         error_setg(errp, QERR_MISSING_PARAMETER, "length");
1956         return;
1957     }
1958     if (!has_begin && has_length) {
1959         error_setg(errp, QERR_MISSING_PARAMETER, "begin");
1960         return;
1961     }
1962     if (has_detach) {
1963         detach_p = detach;
1964     }
1965
1966     /* check whether lzo/snappy is supported */
1967 #ifndef CONFIG_LZO
1968     if (has_format && format == DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO) {
1969         error_setg(errp, "kdump-lzo is not available now");
1970         return;
1971     }
1972 #endif
1973
1974 #ifndef CONFIG_SNAPPY
1975     if (has_format && format == DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY) {
1976         error_setg(errp, "kdump-snappy is not available now");
1977         return;
1978     }
1979 #endif
1980
1981 #ifndef TARGET_X86_64
1982     if (has_format && format == DUMP_GUEST_MEMORY_FORMAT_WIN_DMP) {
1983         error_setg(errp, "Windows dump is only available for x86-64");
1984         return;
1985     }
1986 #endif
1987
1988 #if !defined(WIN32)
1989     if (strstart(file, "fd:", &p)) {
1990         fd = monitor_get_fd(cur_mon, p, errp);
1991         if (fd == -1) {
1992             return;
1993         }
1994     }
1995 #endif
1996
1997     if  (strstart(file, "file:", &p)) {
1998         fd = qemu_open(p, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR);
1999         if (fd < 0) {
2000             error_setg_file_open(errp, errno, p);
2001             return;
2002         }
2003     }
2004
2005     if (fd == -1) {
2006         error_setg(errp, QERR_INVALID_PARAMETER, "protocol");
2007         return;
2008     }
2009
2010     s = &dump_state_global;
2011     dump_state_prepare(s);
2012
2013     dump_init(s, fd, has_format, format, paging, has_begin,
2014               begin, length, &local_err);
2015     if (local_err) {
2016         error_propagate(errp, local_err);
2017         atomic_set(&s->status, DUMP_STATUS_FAILED);
2018         return;
2019     }
2020
2021     if (detach_p) {
2022         /* detached dump */
2023         s->detached = true;
2024         qemu_thread_create(&s->dump_thread, "dump_thread", dump_thread,
2025                            s, QEMU_THREAD_DETACHED);
2026     } else {
2027         /* sync dump */
2028         dump_process(s, errp);
2029     }
2030 }
2031
2032 DumpGuestMemoryCapability *qmp_query_dump_guest_memory_capability(Error **errp)
2033 {
2034     DumpGuestMemoryFormatList *item;
2035     DumpGuestMemoryCapability *cap =
2036                                   g_malloc0(sizeof(DumpGuestMemoryCapability));
2037
2038     /* elf is always available */
2039     item = g_malloc0(sizeof(DumpGuestMemoryFormatList));
2040     cap->formats = item;
2041     item->value = DUMP_GUEST_MEMORY_FORMAT_ELF;
2042
2043     /* kdump-zlib is always available */
2044     item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
2045     item = item->next;
2046     item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
2047
2048     /* add new item if kdump-lzo is available */
2049 #ifdef CONFIG_LZO
2050     item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
2051     item = item->next;
2052     item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
2053 #endif
2054
2055     /* add new item if kdump-snappy is available */
2056 #ifdef CONFIG_SNAPPY
2057     item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
2058     item = item->next;
2059     item->value = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
2060 #endif
2061
2062     /* Windows dump is available only if target is x86_64 */
2063 #ifdef TARGET_X86_64
2064     item->next = g_malloc0(sizeof(DumpGuestMemoryFormatList));
2065     item = item->next;
2066     item->value = DUMP_GUEST_MEMORY_FORMAT_WIN_DMP;
2067 #endif
2068
2069     return cap;
2070 }